- ChArray[ChIndex] = (struct CharsetItem *) malloc(sizeof(struct CharsetItem));
struct parse pa;
struct re_guts *g;
struct parse *p = &pa;
- int i;
- size_t len;
+ int i;
+ size_t len;
#ifdef REDEBUG
#define GOODFLAGS(f) (f)
struct parse *p;
int stop; /* character this ERE should end at */
{
- char c;
- sopno prevback = 0;
- sopno prevfwd = 0;
- sopno conc;
- int first = 1; /* is this the first alternative? */
+ char c;
+ sopno prevback = 0;
+ sopno prevfwd = 0;
+ sopno conc;
+ int first = 1; /* is this the first alternative? */
for (;;)
{
p_ere_exp(p)
struct parse *p;
{
- char c;
- sopno pos;
- int count;
- int count2;
- sopno subno;
+ char c;
+ sopno pos;
+ int count;
+ int count2;
+ sopno subno;
int wascaret = 0;
assert(MORE()); /* caller should have ensured this */
static void
p_bre(p, end1, end2)
struct parse *p;
-int end1; /* first terminating character */
-int end2; /* second terminating character */
+int end1; /* first terminating character */
+int end2; /* second terminating character */
{
- sopno start = HERE();
- int first = 1; /* first subexpression? */
- int wasdollar = 0;
+ sopno start = HERE();
+ int first = 1; /* first subexpression? */
+ int wasdollar = 0;
if (EAT('^'))
{
struct parse *p;
int starordinary; /* is a leading * an ordinary character? */
{
- int c;
- int count;
- int count2;
- sopno pos;
- int i;
- sopno subno;
+ int c;
+ int count;
+ int count2;
+ sopno pos;
+ int i;
+ sopno subno;
#define BACKSL (1<
p_count(p)
struct parse *p;
{
- int count = 0;
- int ndigits = 0;
+ int count = 0;
+ int ndigits = 0;
while (MORE() && isdigit(PEEK()) && count <= DUPMAX)
{
p_bracket(p)
struct parse *p;
{
- cset *cs = allocset(p);
- int invert = 0;
+ cset *cs = allocset(p);
+ int invert = 0;
/* Dept of Truly Sickening Special-Case Kludges */
if (p->next + 5 < p->end && strncmp(p->next, "[:<:]]", 6) == 0)
if (p->g->cflags & REG_ICASE)
{
- int i;
- int ci;
+ int i;
+ int ci;
for (i = p->g->csetsize - 1; i >= 0; i--)
if (CHIN(cs, i) && isalpha(i))
}
if (invert)
{
- int i;
+ int i;
for (i = p->g->csetsize - 1; i >= 0; i--)
if (CHIN(cs, i))
static void
p_b_term(p, cs)
struct parse *p;
-cset *cs;
+cset *cs;
{
- char c;
- char start,
+ char c;
+ char start,
finish;
- int i;
+ int i;
/* classify what we've got */
switch ((MORE()) ? PEEK() : '\0')
static void
p_b_cclass(p, cs)
struct parse *p;
-cset *cs;
+cset *cs;
{
- char *sp = p->next;
+ char *sp = p->next;
struct cclass *cp;
- size_t len;
- char *u;
- char c;
+ size_t len;
+ char *u;
+ char c;
while (MORE() && isalpha(PEEK()))
NEXT();
static void
p_b_eclass(p, cs)
struct parse *p;
-cset *cs;
+cset *cs;
{
- char c;
+ char c;
c = p_b_coll_elem(p, '=');
CHadd(cs, c);
p_b_symbol(p)
struct parse *p;
{
- char value;
+ char value;
REQUIRE(MORE(), REG_EBRACK);
if (!EATTWO('[', '.'))
struct parse *p;
int endc; /* name ended by endc,']' */
{
- char *sp = p->next;
+ char *sp = p->next;
struct cname *cp;
- int len;
+ int len;
while (MORE() && !SEETWO(endc, ']'))
NEXT();
struct parse *p;
int ch;
{
- char *oldnext = p->next;
- char *oldend = p->end;
+ char *oldnext = p->next;
+ char *oldend = p->end;
char bracket[3];
assert(othercase(ch) != ch);/* p_bracket() would recurse */
static void
ordinary(p, ch)
struct parse *p;
-int ch;
+int ch;
{
- cat_t *cap = p->g->categories;
+ cat_t *cap = p->g->categories;
if ((p->g->cflags & REG_ICASE) && isalpha(ch) && othercase(ch) != ch)
bothcases(p, ch);
nonnewline(p)
struct parse *p;
{
- char *oldnext = p->next;
- char *oldend = p->end;
+ char *oldnext = p->next;
+ char *oldend = p->end;
char bracket[4];
p->next = bracket;
int to; /* to this number of times (maybe
* INFINITY) */
{
- sopno finish = HERE();
+ sopno finish = HERE();
#define N 2
#define INF 3
#define REP(f, t) ((f)*8 + (t))
#define MAP(n) (((n) <= 1) ? (n) : ((n) == INFINITY) ? INF : N)
- sopno copy;
+ sopno copy;
if (p->error != 0) /* head off possible runaway recursion */
return;
allocset(p)
struct parse *p;
{
- int no = p->g->ncsets++;
- size_t nc;
- size_t nbytes;
- cset *cs;
- size_t css = (size_t) p->g->csetsize;
- int i;
+ int no = p->g->ncsets++;
+ size_t nc;
+ size_t nbytes;
+ cset *cs;
+ size_t css = (size_t) p->g->csetsize;
+ int i;
if (no >= p->ncsalloc)
{ /* need another column of space */
static void
freeset(p, cs)
struct parse *p;
-cset *cs;
+cset *cs;
{
- int i;
- cset *top = &p->g->sets[p->g->ncsets];
- size_t css = (size_t) p->g->csetsize;
+ int i;
+ cset *top = &p->g->sets[p->g->ncsets];
+ size_t css = (size_t) p->g->csetsize;
for (i = 0; i < css; i++)
CHsub(cs, i);
static int /* set number */
freezeset(p, cs)
struct parse *p;
-cset *cs;
+cset *cs;
{
- uch h = cs->hash;
- int i;
- cset *top = &p->g->sets[p->g->ncsets];
- cset *cs2;
- size_t css = (size_t) p->g->csetsize;
+ uch h = cs->hash;
+ int i;
+ cset *top = &p->g->sets[p->g->ncsets];
+ cset *cs2;
+ size_t css = (size_t) p->g->csetsize;
/* look for an earlier one which is the same */
for (cs2 = &p->g->sets[0]; cs2 < top; cs2++)
static int /* character; there is no "none" value */
firstch(p, cs)
struct parse *p;
-cset *cs;
+cset *cs;
{
- int i;
- size_t css = (size_t) p->g->csetsize;
+ int i;
+ size_t css = (size_t) p->g->csetsize;
for (i = 0; i < css; i++)
if (CHIN(cs, i))
static int
nch(p, cs)
struct parse *p;
-cset *cs;
+cset *cs;
{
- int i;
- size_t css = (size_t) p->g->csetsize;
- int n = 0;
+ int i;
+ size_t css = (size_t) p->g->csetsize;
+ int n = 0;
for (i = 0; i < css; i++)
if (CHIN(cs, i))
static void
mcadd(p, cs, cp)
struct parse *p;
-cset *cs;
-char *cp;
+cset *cs;
+char *cp;
{
- size_t oldend = cs->smultis;
+ size_t oldend = cs->smultis;
cs->smultis += strlen(cp) + 1;
if (cs->multis == NULL)
static void
mcinvert(p, cs)
struct parse *p;
-cset *cs;
+cset *cs;
{
assert(cs->multis == NULL); /* xxx */
}
static void
mccase(p, cs)
struct parse *p;
-cset *cs;
+cset *cs;
{
assert(cs->multis == NULL); /* xxx */
}
struct re_guts *g;
int c;
{
- uch *col;
- int i;
- int ncols = (g->ncsets + (CHAR_BIT - 1)) / CHAR_BIT;
- unsigned uc = (unsigned char) c;
+ uch *col;
+ int i;
+ int ncols = (g->ncsets + (CHAR_BIT - 1)) / CHAR_BIT;
+ unsigned uc = (unsigned char) c;
for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
if (col[uc] != 0)
int c1;
int c2;
{
- uch *col;
- int i;
- int ncols = (g->ncsets + (CHAR_BIT - 1)) / CHAR_BIT;
- unsigned uc1 = (unsigned char) c1;
- unsigned uc2 = (unsigned char) c2;
+ uch *col;
+ int i;
+ int ncols = (g->ncsets + (CHAR_BIT - 1)) / CHAR_BIT;
+ unsigned uc1 = (unsigned char) c1;
+ unsigned uc2 = (unsigned char) c2;
for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
if (col[uc1] != col[uc2])
struct parse *p;
struct re_guts *g;
{
- cat_t *cats = g->categories;
- int c;
- int c2;
- cat_t cat;
+ cat_t *cats = g->categories;
+ int c;
+ int c2;
+ cat_t cat;
/* avoid making error situations worse */
if (p->error != 0)
sopno start; /* from here */
sopno finish; /* to this less one */
{
- sopno ret = HERE();
- sopno len = finish - start;
+ sopno ret = HERE();
+ sopno len = finish - start;
assert(finish >= start);
if (len == 0)
size_t opnd;
sopno pos;
{
- sopno sn;
- sop s;
- int i;
+ sopno sn;
+ sop s;
+ int i;
/* avoid making error situations worse */
if (p->error != 0)
static void
dofwd(p, pos, value)
struct parse *p;
-sopno pos;
+sopno pos;
sop value;
{
/* avoid making error situations worse */
static void
enlarge(p, size)
struct parse *p;
-sopno size;
+sopno size;
{
- sop *sp;
+ sop *sp;
if (p->ssize >= size)
return;
struct parse *p;
struct re_guts *g;
{
- sop *scan;
+ sop *scan;
sop *start = 0;
- sop *newstart = 0;
- sopno newlen;
- sop s;
- char *cp;
- sopno i;
+ sop *newstart = 0;
+ sopno newlen;
+ sop s;
+ char *cp;
+ sopno i;
/* avoid making error situations worse */
if (p->error != 0)
struct parse *p;
struct re_guts *g;
{
- sop *scan;
- sop s;
- sopno plusnest = 0;
- sopno maxnest = 0;
+ sop *scan;
+ sop s;
+ sopno plusnest = 0;
+ sopno maxnest = 0;
if (p->error != 0)
return (0); /* there may not be an OEND */
size_t errbuf_size;
{
struct rerr *r;
- size_t len;
- int target = errcode & ~REG_ITOA;
- char *s;
+ size_t len;
+ int target = errcode & ~REG_ITOA;
+ char *s;
char convbuf[50];
if (errcode == REG_ATOI)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/Attic/locks.c,v 1.8 1998/01/21 04:24:34 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/Attic/locks.c,v 1.9 1998/02/26 04:35:15 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
static bool
nodeThisLockWasTriggered(Node *node, int varno, AttrNumber attnum,
- int sublevels_up)
+ int sublevels_up)
{
if (node == NULL)
return FALSE;
Expr *expr = (Expr *) node;
return nodeThisLockWasTriggered((Node *) expr->args, varno,
- attnum, sublevels_up);
+ attnum, sublevels_up);
}
break;
case T_TargetEntry:
TargetEntry *tle = (TargetEntry *) node;
return nodeThisLockWasTriggered(tle->expr, varno, attnum,
- sublevels_up);
+ sublevels_up);
}
break;
case T_Aggreg:
{
- Aggreg *agg = (Aggreg *) node;
+ Aggreg *agg = (Aggreg *) node;
return nodeThisLockWasTriggered(agg->target, varno, attnum,
- sublevels_up);
+ sublevels_up);
}
break;
case T_List:
foreach(l, (List *) node)
{
if (nodeThisLockWasTriggered(lfirst(l), varno, attnum,
- sublevels_up))
+ sublevels_up))
return TRUE;
}
return FALSE;
break;
case T_SubLink:
{
- SubLink *sublink = (SubLink *) node;
- Query *query = (Query *)sublink->subselect;
+ SubLink *sublink = (SubLink *) node;
+ Query *query = (Query *) sublink->subselect;
return nodeThisLockWasTriggered(query->qual, varno, attnum,
- sublevels_up + 1);
+ sublevels_up + 1);
}
break;
default:
AttrNumber attnum,
Query *parsetree)
{
-
+
if (nodeThisLockWasTriggered(parsetree->qual, varno, attnum, 0))
return true;
return true;
return false;
-
+
}
/*
* matchLocks -
* match the list of locks and returns the matching rules
*/
-List *
+List *
matchLocks(CmdType event,
RuleLock *rulelocks,
int varno,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.13 1998/02/25 13:07:18 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.14 1998/02/26 04:35:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/acl.h"
#include "catalog/pg_shadow.h"
-static void ApplyRetrieveRule(Query *parsetree, RewriteRule *rule,
+static void
+ApplyRetrieveRule(Query *parsetree, RewriteRule *rule,
int rt_index, int relation_level,
Relation relation, int *modified);
-static List *fireRules(Query *parsetree, int rt_index, CmdType event,
+static List *
+fireRules(Query *parsetree, int rt_index, CmdType event,
bool *instead_flag, List *locks, List **qual_products);
static void QueryRewriteSubLink(Node *node);
-static List *QueryRewriteOne(Query *parsetree);
+static List *QueryRewriteOne(Query *parsetree);
static List *deepRewriteQuery(Query *parsetree);
static void CheckViewPerms(Relation view, List *rtable);
if (rule->actions)
{
if (length(rule->actions) > 1) /* ??? because we don't handle
- * rules with more than one
- * action? -ay */
-
- /* WARNING!!!
- * If we sometimes handle
- * rules with more than one
- * action, the view acl checks
- * might get broken.
- * viewAclOverride should only
- * become true (below) if this
- * is a relation_level, instead,
- * select query - Jan
- */
+ * rules with more than one
+ * action? -ay */
+
+ /*
+ * WARNING!!! If we sometimes handle rules with more than one
+ * action, the view acl checks might get broken.
+ * viewAclOverride should only become true (below) if this is
+ * a relation_level, instead, select query - Jan
+ */
return;
rule_action = copyObject(lfirst(rule->actions));
nothing = FALSE;
/*
- * If this rule is on the relation level, the rule action
- * is a select and the rule is instead then it must be
- * a view. Permissions for views now follow the owner of
- * the view, not the current user.
+ * If this rule is on the relation level, the rule action is a
+ * select and the rule is instead then it must be a view.
+ * Permissions for views now follow the owner of the view, not the
+ * current user.
*/
if (relation_level && rule_action->commandType == CMD_SELECT
- && rule->isInstead)
+ && rule->isInstead)
{
- CheckViewPerms(relation, rule_action->rtable);
- viewAclOverride = TRUE;
+ CheckViewPerms(relation, rule_action->rtable);
+ viewAclOverride = TRUE;
}
}
else
if (viewAclOverride)
{
- List *rule_rtable, *rule_rt;
- RangeTblEntry *rte;
+ List *rule_rtable,
+ *rule_rt;
+ RangeTblEntry *rte;
rule_rtable = copyObject(rule_action->rtable);
foreach(rule_rt, rule_rtable)
rte = lfirst(rule_rt);
/*
- * tell the executor that the ACL check on this
- * range table entry is already done
+ * tell the executor that the ACL check on this range table
+ * entry is already done
*/
rte->skipAcl = true;
}
Query *other;
/*
- * ApplyRetrieveRule changes the range table
- * XXX Unions are copied again.
+ * ApplyRetrieveRule changes the range table XXX Unions are copied
+ * again.
*/
other = copyObject(parsetree);
* rewrite one query via QueryRewrite system, possibly returning 0, or many
* queries
*/
-List *
+List *
QueryRewrite(Query *parsetree)
{
{
Expr *expr = (Expr *) node;
- QueryRewriteSubLink((Node *)expr->args);
+ QueryRewriteSubLink((Node *) expr->args);
}
break;
case T_Var:
break;
case T_SubLink:
{
- SubLink *sublink = (SubLink *) node;
- Query *query = (Query *)sublink->subselect;
- List *ret;
+ SubLink *sublink = (SubLink *) node;
+ Query *query = (Query *) sublink->subselect;
+ List *ret;
/*
- * Nest down first. We do this so if a rewrite adds a
- * SubLink we don't process it as part of this loop.
+ * Nest down first. We do this so if a rewrite adds a
+ * SubLink we don't process it as part of this loop.
*/
- QueryRewriteSubLink((Node *)query->qual);
+ QueryRewriteSubLink((Node *) query->qual);
ret = QueryRewriteOne(query);
if (!ret)
else if (lnext(ret) == NIL)
sublink->subselect = lfirst(ret);
else
- elog(ERROR,"Don't know how to process subquery that rewrites to multiple queries.");
+ elog(ERROR, "Don't know how to process subquery that rewrites to multiple queries.");
}
break;
default:
* QueryOneRewrite -
* rewrite one query
*/
-static List *
+static List *
QueryRewriteOne(Query *parsetree)
{
numQueryRewriteInvoked = 0;
{
HeapTuple utup;
NameData uname;
- List *rt;
- RangeTblEntry *rte;
+ List *rt;
+ RangeTblEntry *rte;
int32 aclcheck_res;
/*
if (!HeapTupleIsValid(utup))
{
elog(ERROR, "cache lookup for userid %d failed",
- view->rd_rel->relowner);
+ view->rd_rel->relowner);
}
StrNCpy(uname.data,
((Form_pg_shadow) GETSTRUCT(utup))->usename.data,
NAMEDATALEN);
/*
- * check that we have read access to all the
- * classes in the range table of the view
+ * check that we have read access to all the classes in the range
+ * table of the view
*/
foreach(rt, rtable)
{
- rte = (RangeTblEntry *)lfirst(rt);
+ rte = (RangeTblEntry *) lfirst(rt);
aclcheck_res = pg_aclcheck(rte->relname, uname.data, ACL_RD);
if (aclcheck_res != ACLCHECK_OK)
}
}
}
-
-
-
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.12 1998/02/10 04:02:02 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.13 1998/02/26 04:35:17 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/plannodes.h"
#include "optimizer/clauses.h"
-static void ResolveNew(RewriteInfo *info, List *targetlist,
- Node **node, int sublevels_up);
+static void
+ResolveNew(RewriteInfo *info, List *targetlist,
+ Node **node, int sublevels_up);
break;
case T_Aggreg:
{
- Aggreg *agg = (Aggreg *) node;
+ Aggreg *agg = (Aggreg *) node;
OffsetVarNodes(agg->target, offset);
}
break;
case T_Aggreg:
{
- Aggreg *agg = (Aggreg *) node;
+ Aggreg *agg = (Aggreg *) node;
ChangeVarNodes(agg->target, old_varno, new_varno, sublevels_up);
}
break;
case T_SubLink:
{
- SubLink *sublink = (SubLink *) node;
- Query *query = (Query *)sublink->subselect;
+ SubLink *sublink = (SubLink *) node;
+ Query *query = (Query *) sublink->subselect;
- ChangeVarNodes((Node *)query->qual, old_varno, new_varno,
- sublevels_up + 1);
+ ChangeVarNodes((Node *) query->qual, old_varno, new_varno,
+ sublevels_up + 1);
}
break;
default:
static void
ResolveNew(RewriteInfo *info, List *targetlist, Node **nodePtr,
- int sublevels_up)
+ int sublevels_up)
{
Node *node = *nodePtr;
{
case T_TargetEntry:
ResolveNew(info, targetlist, &((TargetEntry *) node)->expr,
- sublevels_up);
+ sublevels_up);
break;
case T_Aggreg:
ResolveNew(info, targetlist, &((Aggreg *) node)->target,
- sublevels_up);
+ sublevels_up);
break;
case T_Expr:
ResolveNew(info, targetlist, (Node **) (&(((Expr *) node)->args)),
- sublevels_up);
+ sublevels_up);
break;
case T_Var:
{
- int this_varno = (int) ((Var *) node)->varno;
- int this_varlevelsup = (int) ((Var *) node)->varlevelsup;
- Node *n;
+ int this_varno = (int) ((Var *) node)->varno;
+ int this_varlevelsup = (int) ((Var *) node)->varlevelsup;
+ Node *n;
if (this_varno == info->new_varno &&
this_varlevelsup == sublevels_up)
foreach(l, (List *) node)
ResolveNew(info, targetlist, (Node **) &(lfirst(l)),
- sublevels_up);
+ sublevels_up);
break;
}
case T_SubLink:
{
- SubLink *sublink = (SubLink *) node;
- Query *query = (Query *)sublink->subselect;
+ SubLink *sublink = (SubLink *) node;
+ Query *query = (Query *) sublink->subselect;
- ResolveNew(info, targetlist, (Node **)&(query->qual), sublevels_up + 1);
+ ResolveNew(info, targetlist, (Node **) &(query->qual), sublevels_up + 1);
}
break;
default:
TargetEntry *tle = (TargetEntry *) node;
nodeHandleRIRAttributeRule(&tle->expr, rtable, targetlist,
- rt_index, attr_num, modified, badsql,
- sublevels_up);
+ rt_index, attr_num, modified, badsql,
+ sublevels_up);
}
break;
case T_Aggreg:
{
- Aggreg *agg = (Aggreg *) node;
+ Aggreg *agg = (Aggreg *) node;
nodeHandleRIRAttributeRule(&agg->target, rtable, targetlist,
- rt_index, attr_num, modified, badsql,
- sublevels_up);
+ rt_index, attr_num, modified, badsql,
+ sublevels_up);
}
break;
case T_Expr:
if (name_to_look_for.data[0])
{
Node *n;
-
+
n = FindMatchingTLEntry(targetlist, (char *) &name_to_look_for);
if (n == NULL)
*nodePtr = make_null(((Var *) node)->vartype);
{
nodeHandleRIRAttributeRule((Node **) (&(lfirst(i))), rtable,
targetlist, rt_index, attr_num,
- modified, badsql, sublevels_up);
+ modified, badsql, sublevels_up);
}
}
break;
case T_SubLink:
{
- SubLink *sublink = (SubLink *) node;
- Query *query = (Query *)sublink->subselect;
+ SubLink *sublink = (SubLink *) node;
+ Query *query = (Query *) sublink->subselect;
- nodeHandleRIRAttributeRule((Node **)&(query->qual), rtable, targetlist,
- rt_index, attr_num, modified, badsql,
- sublevels_up + 1);
+ nodeHandleRIRAttributeRule((Node **) &(query->qual), rtable, targetlist,
+ rt_index, attr_num, modified, badsql,
+ sublevels_up + 1);
}
break;
default:
int *modified,
int *badsql)
{
-
+
nodeHandleRIRAttributeRule((Node **) (&(parsetree->targetList)), rtable,
targetlist, rt_index, attr_num,
modified, badsql, 0);
List *targetlist,
int rt_index,
int *modified,
- int sublevels_up)
+ int sublevels_up)
{
Node *node = *nodePtr;
break;
case T_Aggreg:
{
- Aggreg *agg = (Aggreg *) node;
+ Aggreg *agg = (Aggreg *) node;
nodeHandleViewRule(&(agg->target), rtable, targetlist,
rt_index, modified, sublevels_up);
Node *n;
if (this_varno == rt_index &&
- this_varlevelsup == sublevels_up)
+ this_varlevelsup == sublevels_up)
{
n = FindMatchingTLEntry(targetlist,
get_attname(getrelid(this_varno,
break;
case T_SubLink:
{
- SubLink *sublink = (SubLink *) node;
- Query *query = (Query *)sublink->subselect;
+ SubLink *sublink = (SubLink *) node;
+ Query *query = (Query *) sublink->subselect;
- nodeHandleViewRule((Node **)&(query->qual), rtable, targetlist,
+ nodeHandleViewRule((Node **) &(query->qual), rtable, targetlist,
rt_index, modified, sublevels_up + 1);
}
break;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteRemove.c,v 1.10 1998/01/31 04:38:38 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteRemove.c,v 1.11 1998/02/26 04:35:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* RewriteGetRuleEventRel
*-----------------------------------------------------------------------
*/
-char *
+char *
RewriteGetRuleEventRel(char *rulename)
{
HeapTuple htp;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteSupport.c,v 1.15 1998/01/31 04:38:39 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteSupport.c,v 1.16 1998/02/26 04:35:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (ruletuple == NULL)
elog(ERROR, "rule %u isn't in rewrite system relation", ruleoid);
- ruleaction = (char *)heap_getattr(ruletuple,
- Anum_pg_rewrite_ev_action,
- ruleTupdesc,
- &action_is_null);
- rule_evqual_string = (char *)heap_getattr(ruletuple,
- Anum_pg_rewrite_ev_qual,
- ruleTupdesc, &action_is_null);
+ ruleaction = (char *) heap_getattr(ruletuple,
+ Anum_pg_rewrite_ev_action,
+ ruleTupdesc,
+ &action_is_null);
+ rule_evqual_string = (char *) heap_getattr(ruletuple,
+ Anum_pg_rewrite_ev_qual,
+ ruleTupdesc, &action_is_null);
*instead_flag = !!heap_getattr(ruletuple,
Anum_pg_rewrite_is_instead,
ruleTupdesc, &instead_is_null);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.34 1998/02/11 19:11:42 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.35 1998/02/26 04:35:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static int BufferReplace(BufferDesc *bufHdr, bool bufferLockHeld);
/* not static but used by vacuum only ... */
-int BlowawayRelationBuffers(Relation rdesc, BlockNumber block);
+int BlowawayRelationBuffers(Relation rdesc, BlockNumber block);
/* ---------------------------------------------------
* RelationGetBufferWithBuffer
status = smgrflush(DEFAULT_SMGR, bufrel, bufHdr->tag.blockNum,
(char *) MAKE_PTR(bufHdr->data));
-
+
RelationDecrementReferenceCount(bufrel);
if (status == SM_FAIL)
void
ResetBufferPool()
{
- int i;
+ int i;
for (i = 1; i <= NBuffers; i++)
{
int
BufferPoolCheckLeak()
{
- int i;
+ int i;
int error = 0;
for (i = 1; i <= NBuffers; i++)
bufHdr->tag.blockNum,
(char *) MAKE_PTR(bufHdr->data));
}
-
+
if (reln != (Relation) NULL)
RelationDecrementReferenceCount(reln);
void
ReleaseRelationBuffers(Relation rdesc)
{
- int i;
+ int i;
int holding = 0;
BufferDesc *buf;
void
DropBuffers(Oid dbid)
{
- int i;
+ int i;
BufferDesc *buf;
SpinAcquire(BufMgrLock);
void
BufferPoolBlowaway()
{
- int i;
+ int i;
BufferSync();
for (i = 1; i <= NBuffers; i++)
*
* This function blowaway all the pages with blocknumber >= passed
* of a relation in the buffer pool. Used by vacuum before truncation...
- *
+ *
* Returns: 0 - Ok, -1 - DIRTY, -2 - PINNED
- *
+ *
* XXX currently it sequentially searches the buffer pool, should be
* changed to more clever ways of searching.
* --------------------------------------------------------------------
int
BlowawayRelationBuffers(Relation rdesc, BlockNumber block)
{
- int i;
- BufferDesc *buf;
+ int i;
+ BufferDesc *buf;
if (rdesc->rd_islocal)
{
for (i = 0; i < NLocBuffer; i++)
{
buf = &LocalBufferDescriptors[i];
- if (buf->tag.relId.relId == rdesc->rd_id &&
+ if (buf->tag.relId.relId == rdesc->rd_id &&
buf->tag.blockNum >= block)
{
if (buf->flags & BM_DIRTY)
{
- elog (NOTICE, "BlowawayRelationBuffers(%s (local), %u): block %u is dirty",
- rdesc->rd_rel->relname.data, block, buf->tag.blockNum);
+ elog(NOTICE, "BlowawayRelationBuffers(%s (local), %u): block %u is dirty",
+ rdesc->rd_rel->relname.data, block, buf->tag.blockNum);
return (-1);
}
if (LocalRefCount[i] > 0)
{
- elog (NOTICE, "BlowawayRelationBuffers(%s (local), %u): block %u is referenced (%d)",
- rdesc->rd_rel->relname.data, block,
- buf->tag.blockNum, LocalRefCount[i]);
+ elog(NOTICE, "BlowawayRelationBuffers(%s (local), %u): block %u is referenced (%d)",
+ rdesc->rd_rel->relname.data, block,
+ buf->tag.blockNum, LocalRefCount[i]);
return (-2);
}
buf->tag.relId.relId = InvalidOid;
{
buf = &BufferDescriptors[i];
if (buf->tag.relId.dbId == MyDatabaseId &&
- buf->tag.relId.relId == rdesc->rd_id &&
+ buf->tag.relId.relId == rdesc->rd_id &&
buf->tag.blockNum >= block)
{
if (buf->flags & BM_DIRTY)
{
- elog (NOTICE, "BlowawayRelationBuffers(%s, %u): block %u is dirty (private %d, last %d, global %d)",
- buf->sb_relname, block, buf->tag.blockNum,
- PrivateRefCount[i], LastRefCount[i], buf->refcount);
+ elog(NOTICE, "BlowawayRelationBuffers(%s, %u): block %u is dirty (private %d, last %d, global %d)",
+ buf->sb_relname, block, buf->tag.blockNum,
+ PrivateRefCount[i], LastRefCount[i], buf->refcount);
SpinRelease(BufMgrLock);
return (-1);
}
if (!(buf->flags & BM_FREE))
{
- elog (NOTICE, "BlowawayRelationBuffers(%s, %u): block %u is referenced (private %d, last %d, global %d)",
- buf->sb_relname, block, buf->tag.blockNum,
- PrivateRefCount[i], LastRefCount[i], buf->refcount);
+ elog(NOTICE, "BlowawayRelationBuffers(%s, %u): block %u is referenced (private %d, last %d, global %d)",
+ buf->sb_relname, block, buf->tag.blockNum,
+ PrivateRefCount[i], LastRefCount[i], buf->refcount);
SpinRelease(BufMgrLock);
return (-2);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/localbuf.c,v 1.17 1998/01/13 04:04:20 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/localbuf.c,v 1.18 1998/02/26 04:35:26 momjian Exp $
*
*-------------------------------------------------------------------------
*/
(char *) MAKE_PTR(bufHdr->data));
LocalBufferFlushCount++;
RelationDecrementReferenceCount(bufrel);
-
+
Assert(LocalRefCount[bufid] > 0);
if (release)
LocalRefCount[bufid]--;
(char *) MAKE_PTR(buf->data));
LocalBufferFlushCount++;
RelationDecrementReferenceCount(bufrel);
-
+
buf->tag.relId.relId = InvalidOid;
buf->flags &= ~BM_DIRTY;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/Attic/s_lock.c,v 1.2 1998/01/07 17:02:52 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/Attic/s_lock.c,v 1.3 1998/02/26 04:35:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* S_LOCK() -- Implements the S_LOCK function for the Linux/Alpha platform.
- * This function is usually an inlined macro for all other platforms,
- * but must be a seperate function for the Linux/Alpha platform, due
- * to the assembly code involved.
+ * This function is usually an inlined macro for all other platforms,
+ * but must be a seperate function for the Linux/Alpha platform, due
+ * to the assembly code involved.
*/
#include "storage/s_lock.h"
#if defined(__alpha__) && defined(linux)
-void S_LOCK(slock_t* lock)
+void
+S_LOCK(slock_t *lock)
{
- do
- {
- slock_t _res;
- do
- {
- __asm__(" ldq $0, %0 \n\
+ do
+ {
+ slock_t _res;
+
+ do
+ {
+ __asm__(" ldq $0, %0 \n\
bne $0, already_set \n\
ldq_l $0, %0 \n\
bne $0, already_set \n\
stqc_fail: or $31, 1, $0 \n\
already_set: bis $0, $0, %1 \n\
end: nop ": "=m"(*lock), "=r"(_res): :"0");
- } while (_res != 0);
- } while (0);
+ } while (_res != 0);
+ } while (0);
}
+
#endif
* Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Id: fd.c,v 1.29 1998/01/07 21:04:58 momjian Exp $
+ * $Id: fd.c,v 1.30 1998/02/26 04:35:29 momjian Exp $
*
* NOTES:
*
}
#ifdef FILEDEBUG
-printf("filepath: path is %s\n", buf);
+ printf("filepath: path is %s\n", buf);
#endif
return (buf);
*/
static int allocatedFiles = 0;
-FILE *
+FILE *
AllocateFile(char *name, char *mode)
{
FILE *file;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipc.c,v 1.18 1998/01/07 21:05:03 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipc.c,v 1.19 1998/02/26 04:35:38 momjian Exp $
*
* NOTES
*
/* CALL IT: addr = (struct *) IpcMemoryAttach(memId); */
/* */
/****************************************************************************/
-char *
+char *
IpcMemoryAttach(IpcMemoryId memId)
{
char *memAddress;
*/
/* used in spin.c */
-SLock *SLockArray = NULL;
+SLock *SLockArray = NULL;
static SLock **FreeSLockPP;
static int *UnusedSLockIP;
{
return (SLockArray[lockid].flag == NOLOCK);
}
+
#endif
#endif /* HAS_TEST_AND_SET */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmem.c,v 1.16 1998/01/07 21:05:08 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmem.c,v 1.17 1998/02/26 04:35:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* of space. Has to return a real pointer in order
* to be compatable with malloc().
*/
-long *
+long *
ShmemAlloc(unsigned long size)
{
unsigned long tmpFree;
* table at once. Use SpinAlloc() to create a spinlock
* for the structure before creating the structure itself.
*/
-HTAB *
+HTAB *
ShmemInitHash(char *name, /* table string name for binding */
long init_size, /* initial size */
long max_size, /* max size of the table */
* the object is already in the binding table (hence, already
* initialized).
*/
-long *
+long *
ShmemInitStruct(char *name, unsigned long size, bool *foundPtr)
{
BindingEnt *result,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.25 1998/01/28 06:52:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.26 1998/02/26 04:36:07 momjian Exp $
*
* NOTES
* Outside modules can create a lock table and acquire/release
#include "access/xact.h"
#include "access/transam.h"
-static int WaitOnLock(LOCKTAB *ltable, LockTableId tableId, LOCK *lock,
+static int
+WaitOnLock(LOCKTAB *ltable, LockTableId tableId, LOCK *lock,
LOCKT lockt);
-
+
/*#define LOCK_MGR_DEBUG*/
#ifndef LOCK_MGR_DEBUG
* word alignment and ensures hashing consistency).
* ------------------
*/
- MemSet(&item, 0, XID_TAGSIZE); /* must clear padding, needed */
+ MemSet(&item, 0, XID_TAGSIZE); /* must clear padding, needed */
TransactionIdStore(myXid, &item.tag.xid);
item.tag.lock = MAKE_OFFSET(lock);
#if 0
{
/* ------------------------
* If someone with a greater priority is waiting for the lock,
- * do not continue and share the lock, even if we can. bjm
+ * do not continue and share the lock, even if we can. bjm
* ------------------------
*/
- int myprio = ltable->ctl->prio[lockt];
- PROC_QUEUE *waitQueue = &(lock->waitProcs);
- PROC *topproc = (PROC *) MAKE_PTR(waitQueue->links.prev);
+ int myprio = ltable->ctl->prio[lockt];
+ PROC_QUEUE *waitQueue = &(lock->waitProcs);
+ PROC *topproc = (PROC *) MAKE_PTR(waitQueue->links.prev);
if (waitQueue->size && topproc->prio > myprio)
return STATUS_FOUND;
#endif
/*
- * let the caller print its own error message, too. Do not elog(ERROR).
+ * let the caller print its own error message, too. Do not
+ * elog(ERROR).
*/
if (!lock)
{
SHMEM_OFFSET end = MAKE_OFFSET(lockQueue);
LOCK *lock;
- LOCKTAB *ltable;
+ LOCKTAB *ltable;
XIDLookupEnt *result,
item;
HTAB *xidTable;
bool found;
- static PROC* checked_procs[MaxBackendId];
- static int nprocs;
- static bool MyNHolding;
-
+ static PROC *checked_procs[MaxBackendId];
+ static int nprocs;
+ static bool MyNHolding;
+
/* initialize at start of recursion */
if (skip_check)
{
#if 0
item.tag.pid = pid;
#endif
-
+
if (!(result = (XIDLookupEnt *)
- hash_search(xidTable, (Pointer) &item, HASH_FIND, &found)) || !found)
+ hash_search(xidTable, (Pointer) &item, HASH_FIND, &found)) || !found)
{
elog(NOTICE, "LockAcquire: xid table corrupted");
return true;
}
MyNHolding = result->nHolding;
- }
+ }
if (SHMQueueEmpty(lockQueue))
return false;
/*
* This is our only check to see if we found the lock we want.
*
- * The lock we are waiting for is already in MyProc->lockQueue
- * so we need to skip it here. We are trying to find it in
- * someone else's lockQueue.
+ * The lock we are waiting for is already in MyProc->lockQueue so we
+ * need to skip it here. We are trying to find it in someone
+ * else's lockQueue.
*/
if (lock == findlock && !skip_check)
return true;
- {
- PROC_QUEUE *waitQueue = &(lock->waitProcs);
- PROC *proc;
+ {
+ PROC_QUEUE *waitQueue = &(lock->waitProcs);
+ PROC *proc;
int i;
int j;
-
+
proc = (PROC *) MAKE_PTR(waitQueue->links.prev);
for (i = 0; i < waitQueue->size; i++)
{
lock == findlock && /* skip_check also true */
MyNHolding) /* I already hold some lock on it */
{
+
/*
- * For findlock's wait queue, we are interested in
- * procs who are blocked waiting for a write-lock on the
- * table we are waiting on, and already hold a lock on it.
- * We first check to see if there is an escalation
- * deadlock, where we hold a readlock and want a
- * writelock, and someone else holds readlock on
- * the same table, and wants a writelock.
+ * For findlock's wait queue, we are interested in
+ * procs who are blocked waiting for a write-lock on
+ * the table we are waiting on, and already hold a
+ * lock on it. We first check to see if there is an
+ * escalation deadlock, where we hold a readlock and
+ * want a writelock, and someone else holds readlock
+ * on the same table, and wants a writelock.
*
- * Basically, the test is, "Do we both hold some lock
- * on findlock, and we are both waiting in the lock
- * queue?"
+ * Basically, the test is, "Do we both hold some lock on
+ * findlock, and we are both waiting in the lock
+ * queue?"
*/
Assert(skip_check);
Assert(MyProc->prio == 2);
-
+
ltable = AllTables[1];
xidTable = ltable->xidHash;
#if 0
item.tag.pid = pid;
#endif
-
+
if (!(result = (XIDLookupEnt *)
- hash_search(xidTable, (Pointer) &item, HASH_FIND, &found)) || !found)
+ hash_search(xidTable, (Pointer) &item, HASH_FIND, &found)) || !found)
{
elog(NOTICE, "LockAcquire: xid table corrupted");
return true;
if (result->nHolding)
return true;
}
+
/*
- * No sense in looking at the wait queue of the lock we are
- * looking for.
- * If lock == findlock, and I got here, skip_check must be
- * true too.
+ * No sense in looking at the wait queue of the lock we
+ * are looking for. If lock == findlock, and I got here,
+ * skip_check must be true too.
*/
if (lock != findlock)
{
{
checked_procs[nprocs++] = proc;
Assert(nprocs <= MaxBackendId);
+
/*
- * For non-MyProc entries, we are looking only waiters,
- * not necessarily people who already hold locks and are
- * waiting.
- * Now we check for cases where we have two or more
- * tables in a deadlock. We do this by continuing
- * to search for someone holding a lock
+ * For non-MyProc entries, we are looking only
+ * waiters, not necessarily people who already
+ * hold locks and are waiting. Now we check for
+ * cases where we have two or more tables in a
+ * deadlock. We do this by continuing to search
+ * for someone holding a lock
*/
if (DeadLockCheck(&(proc->lockQueue), findlock, false))
return true;
proc = (PROC *) MAKE_PTR(proc->links.prev);
}
}
-
+
if (done)
break;
SHMQueueFirst(&xidLook->queue, (Pointer *) &tmp, &tmp->queue);
SPINLOCK masterLock;
int nLockTypes;
LOCK *lock;
- count;
+
+ count;
int tableId = 1;
LOCKTAB *ltable;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.33 1998/02/25 00:31:14 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.34 1998/02/26 04:36:12 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* This is so that we can support more backends. (system-wide semaphore
* sets run out pretty fast.) -ay 4/95
*
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.33 1998/02/25 00:31:14 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.34 1998/02/26 04:36:12 momjian Exp $
*/
#include
#include
dummy;
/*
- * If the first entries in the waitQueue have a greater priority than
- * we have, we must be a reader, and they must be a writers, and we
- * must be here because the current holder is a writer or a
- * reader but we don't share shared locks if a writer is waiting.
- * We put ourselves after the writers. This way, we have a FIFO, but
- * keep the readers together to give them decent priority, and no one
- * starves. Because we group all readers together, a non-empty queue
- * only has a few possible configurations:
+ * If the first entries in the waitQueue have a greater priority than
+ * we have, we must be a reader, and they must be a writers, and we
+ * must be here because the current holder is a writer or a reader but
+ * we don't share shared locks if a writer is waiting. We put
+ * ourselves after the writers. This way, we have a FIFO, but keep
+ * the readers together to give them decent priority, and no one
+ * starves. Because we group all readers together, a non-empty queue
+ * only has a few possible configurations:
*
- * [readers]
- * [writers]
- * [readers][writers]
- * [writers][readers]
- * [writers][readers][writers]
+ * [readers] [writers] [readers][writers] [writers][readers]
+ * [writers][readers][writers]
*
- * In a full queue, we would have a reader holding a lock, then a
- * writer gets the lock, then a bunch of readers, made up of readers
- * who could not share the first readlock because a writer was waiting,
- * and new readers arriving while the writer had the lock.
+ * In a full queue, we would have a reader holding a lock, then a writer
+ * gets the lock, then a bunch of readers, made up of readers who
+ * could not share the first readlock because a writer was waiting,
+ * and new readers arriving while the writer had the lock.
*
*/
proc = (PROC *) MAKE_PTR(waitQueue->links.prev);
proc = (PROC *) MAKE_PTR(proc->links.prev);
/* The rest of the queue is FIFO, with readers first, writers last */
- for ( ; i < waitQueue->size && proc->prio <= prio; i++)
+ for (; i < waitQueue->size && proc->prio <= prio; i++)
proc = (PROC *) MAKE_PTR(proc->links.prev);
MyProc->prio = prio;
MyProc->token = token;
MyProc->waitLock = lock;
-
+
/* -------------------
* currently, we only need this for the ProcWakeup routines
* -------------------
do
{
- MyProc->errType = NO_ERROR; /* reset flag after deadlock check */
+ MyProc->errType = NO_ERROR; /* reset flag after deadlock check */
if (setitimer(ITIMER_REAL, &timeval, &dummy))
elog(FATAL, "ProcSleep: Unable to set timer for process wakeup");
* --------------
*/
IpcSemaphoreLock(MyProc->sem.semId, MyProc->sem.semNum, IpcExclusiveLock);
- } while (MyProc->errType == STATUS_NOT_FOUND); /* sleep after deadlock check */
-
+ } while (MyProc->errType == STATUS_NOT_FOUND); /* sleep after deadlock
+ * check */
+
/* ---------------
* We were awoken before a timeout - now disable the timer
* ---------------
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/smgr/md.c,v 1.28 1998/02/23 13:58:04 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/smgr/md.c,v 1.29 1998/02/26 04:36:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* The number needs to be (2 ** 31) / BLCKSZ, but to be keep
* the math under MAXINT, pre-divide by 256 and use ...
*
- * (((2 ** 23) / BLCKSZ) * (2 ** 8))
+ * (((2 ** 23) / BLCKSZ) * (2 ** 8))
*
* 07 Jan 98 darrenk
*/
/* user table? then put in user database area... */
else if (dbid == MyDatabaseId)
{
- extern char *DatabasePath;
-
+ extern char *DatabasePath;
+
path = (char *) palloc(strlen(DatabasePath) + 2 * sizeof(NameData) + 2 + nchars);
if (segno == 0)
sprintf(path, "%s%c%s", DatabasePath, SEP_CHAR, relstr);
else
sprintf(path, "%s%c%s.%d", DatabasePath, SEP_CHAR, relstr, segno);
}
- else /* this is work arround only !!! */
+ else
+/* this is work arround only !!! */
{
- char dbpath[MAXPGPATH+1];
- Oid owner, id;
- char *tmpPath;
-
+ char dbpath[MAXPGPATH + 1];
+ Oid owner,
+ id;
+ char *tmpPath;
+
GetRawDatabaseInfo(dbstr, &owner, &id, dbpath);
-
+
if (id != dbid)
- elog (FATAL, "mdblindwrt: oid of db %s is not %u", dbstr, dbid);
+ elog(FATAL, "mdblindwrt: oid of db %s is not %u", dbstr, dbid);
tmpPath = ExpandDatabasePath(dbpath);
if (tmpPath == NULL)
- elog (FATAL, "mdblindwrt: can't expand path for db %s", dbstr);
+ elog(FATAL, "mdblindwrt: can't expand path for db %s", dbstr);
path = (char *) palloc(strlen(tmpPath) + 2 * sizeof(NameData) + 2 + nchars);
if (segno == 0)
sprintf(path, "%s%c%s", tmpPath, SEP_CHAR, relstr);
else
sprintf(path, "%s%c%s.%d", tmpPath, SEP_CHAR, relstr, segno);
- pfree (tmpPath);
+ pfree(tmpPath);
}
if ((fd = open(path, O_RDWR, 0600)) < 0)
return (nblocks);
-} /* mdtruncate */
+} /* mdtruncate */
/*
* mdcommit() -- Commit a transaction.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgrtype.c,v 1.7 1998/01/07 21:05:47 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgrtype.c,v 1.8 1998/02/26 04:36:17 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return 0;
}
-char *
+char *
smgrout(int2 i)
{
char *s;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/dest.c,v 1.16 1998/01/26 01:41:23 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/dest.c,v 1.17 1998/02/26 04:36:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
switch (dest)
{
- case RemoteInternal:
+ case RemoteInternal:
return printtup_internal;
break;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/fastpath.c,v 1.12 1998/01/26 01:41:28 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/fastpath.c,v 1.13 1998/02/26 04:36:26 momjian Exp $
*
* NOTES
* This cruft is the server side of PQfn.
{ /* by-reference ... */
if (fip->arglen[i] < 0)
{ /* ... varlena */
- if (!(p = palloc(argsize + VARHDRSZ + 1))) /* Added +1 to solve memory leak - Peter 98 Jan 6 */
+ if (!(p = palloc(argsize + VARHDRSZ + 1))) /* Added +1 to solve
+ * memory leak - Peter
+ * 98 Jan 6 */
{
elog(ERROR, "HandleFunctionRequest: palloc failed");
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.66 1998/02/24 15:19:23 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.67 1998/02/26 04:36:31 momjian Exp $
*
* NOTES
* this is the "main" module of the postgres backend and
return InteractiveBackend(inBuf);
}
-List *
-pg_parse_and_plan(char *query_string, /* string to execute */
- Oid *typev, /* argument types */
- int nargs, /* number of arguments */
- QueryTreeList **queryListP, /* pointer to the parse trees */
- CommandDest dest) /* where results should go */
+List *
+pg_parse_and_plan(char *query_string, /* string to execute */
+ Oid *typev, /* argument types */
+ int nargs, /* number of arguments */
+ QueryTreeList **queryListP, /* pointer to the parse
+ * trees */
+ CommandDest dest) /* where results should go */
{
QueryTreeList *querytree_list;
int i;
* rewrites */
for (i = 0; i < querytree_list->len; i++)
{
- List *union_result, *union_list, *rewritten_list;
-
+ List *union_result,
+ *union_list,
+ *rewritten_list;
+
querytree = querytree_list->qtrees[i];
rewritten = QueryRewrite(querytree);
/*
- * Rewrite the UNIONS.
+ * Rewrite the UNIONS.
*/
foreach(rewritten_list, rewritten)
{
- Query *qry = (Query *)lfirst(rewritten_list);
+ Query *qry = (Query *) lfirst(rewritten_list);
+
union_result = NIL;
foreach(union_list, qry->unionClause)
- union_result = nconc(union_result, QueryRewrite((Query *)lfirst(union_list)));
+ union_result = nconc(union_result, QueryRewrite((Query *) lfirst(union_list)));
qry->unionClause = union_result;
}
}
void
-pg_exec_query_dest(char *query_string,/* string to execute */
- char **argv, /* arguments */
- Oid *typev, /* argument types */
- int nargs, /* number of arguments */
- CommandDest dest) /* where results should go */
+pg_exec_query_dest(char *query_string, /* string to execute */
+ char **argv, /* arguments */
+ Oid *typev, /* argument types */
+ int nargs, /* number of arguments */
+ CommandDest dest) /* where results should go */
{
List *plan_list;
Plan *plan;
quickdie(SIGNAL_ARGS)
{
elog(NOTICE, "Message from PostgreSQL backend:"
- "\n\tThe Postmaster has informed me that some other backend"
- " died abnormally and possibly corrupted shared memory."
- "\n\tI have rolled back the current transaction and am"
- " going to terminate your database system connection and exit."
- "\n\tPlease reconnect to the database system and repeat your query.");
+ "\n\tThe Postmaster has informed me that some other backend"
+ " died abnormally and possibly corrupted shared memory."
+ "\n\tI have rolled back the current transaction and am"
+ " going to terminate your database system connection and exit."
+ "\n\tPlease reconnect to the database system and repeat your query.");
/*
FloatExceptionHandler(SIGNAL_ARGS)
{
elog(ERROR, "floating point exception!"
- " The last floating point operation either exceeded legal ranges"
- " or was a divide by zero");
+ " The last floating point operation either exceeded legal ranges"
+ " or was a divide by zero");
}
#endif
/*
- * get hostname is either the environment variable PGHOST or NULL
- * NULL means Unix-socket only
+ * get hostname is either the environment variable PGHOST or NULL NULL
+ * means Unix-socket only
*/
DataDir = getenv("PGDATA");
+
/*
- * Try to get initial values for date styles and formats.
- * Does not do a complete job, but should be good enough for backend.
- * Cannot call parse_date() since palloc/pfree memory is not set up yet.
+ * Try to get initial values for date styles and formats. Does not do
+ * a complete job, but should be good enough for backend. Cannot call
+ * parse_date() since palloc/pfree memory is not set up yet.
*/
DBDate = getenv("PGDATESTYLE");
if (DBDate != NULL)
* ----------------
*/
{
- int S;
-
+ int S;
+
S = atoi(optarg);
- if ( S >= 4*BLCKSZ/1024 )
+ if (S >= 4 * BLCKSZ / 1024)
SortMem = S;
}
break;
break;
case 'v':
- FrontendProtocol = (ProtocolVersion)atoi(optarg);
+ FrontendProtocol = (ProtocolVersion) atoi(optarg);
break;
case 'x':
userName = GetPgUserName();
#ifdef CYR_RECODE
- SetCharSet();
+ SetCharSet();
#endif
if (FindBackend(pg_pathname, argv[0]) < 0)
if (IsUnderPostmaster == false)
{
puts("\nPOSTGRES backend interactive interface");
- puts("$Revision: 1.66 $ $Date: 1998/02/24 15:19:23 $");
+ puts("$Revision: 1.67 $ $Date: 1998/02/26 04:36:31 $");
}
/* ----------------
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/pquery.c,v 1.14 1998/02/13 03:42:32 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/pquery.c,v 1.15 1998/02/26 04:36:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* Note: this may someday take parameters -cim 9/18/89
* ----------------------------------------------------------------
*/
-EState *
+EState *
CreateExecutorState(void)
{
EState *state;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/utility.c,v 1.37 1998/01/25 05:14:27 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/utility.c,v 1.38 1998/02/26 04:36:36 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/syscache.h"
#endif
-void DefineUser(CreateUserStmt *stmt);
-void AlterUser(AlterUserStmt *stmt);
-void RemoveUser(char *username);
+void DefineUser(CreateUserStmt *stmt);
+void AlterUser(AlterUserStmt *stmt);
+void RemoveUser(char *username);
/* ----------------
* CHECK_IF_ABORTED() is used to avoid doing unnecessary
* ----------------
*/
void
-ProcessUtility(Node * parsetree,
+ProcessUtility(Node *parsetree,
CommandDest dest)
{
char *commandTag = NULL;
CHECK_IF_ABORTED();
/*
- * owner checking done in PerformAddAttribute (now recursive)
+ * owner checking done in PerformAddAttribute (now
+ * recursive)
*/
PerformAddAttribute(stmt->relname,
userName,
stmt->inh,
- (ColumnDef *)stmt->colDef);
+ (ColumnDef *) stmt->colDef);
}
break;
DropProceduralLanguage((DropPLangStmt *) parsetree);
break;
- /*
- * ******************************** USER statements ****
- *
- */
- case T_CreateUserStmt:
- commandTag = "CREATE USER";
- CHECK_IF_ABORTED();
+ /*
+ * ******************************** USER statements ****
+ *
+ */
+ case T_CreateUserStmt:
+ commandTag = "CREATE USER";
+ CHECK_IF_ABORTED();
- DefineUser((CreateUserStmt*)parsetree);
- break;
+ DefineUser((CreateUserStmt *) parsetree);
+ break;
- case T_AlterUserStmt:
- commandTag = "ALTER USER";
- CHECK_IF_ABORTED();
+ case T_AlterUserStmt:
+ commandTag = "ALTER USER";
+ CHECK_IF_ABORTED();
- AlterUser((AlterUserStmt*)parsetree);
- break;
+ AlterUser((AlterUserStmt *) parsetree);
+ break;
- case T_DropUserStmt:
- commandTag = "DROP USER";
- CHECK_IF_ABORTED();
+ case T_DropUserStmt:
+ commandTag = "DROP USER";
+ CHECK_IF_ABORTED();
- RemoveUser(((DropUserStmt*)parsetree)->user);
- break;
+ RemoveUser(((DropUserStmt *) parsetree)->user);
+ break;
/*
#include
#include "Varray.h"
-Varray *
+Varray *
NewVarray(size_t nobj, size_t size)
/*
* NewVarray -- allocate a Varray to contain an array of val each of which
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tioga/Attic/tgRecipe.c,v 1.7 1997/10/25 01:10:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tioga/Attic/tgRecipe.c,v 1.8 1998/02/26 04:36:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
XXX Currently, this is done by linear search. Change to using a hash table.
-------------------------------------- */
-TgNode *
+TgNode *
findNodeInRecipe(TgRecipe * r, char *nodeName)
{
int i;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: tgRecipe.h,v 1.5 1997/09/08 21:48:03 momjian Exp $
+ * $Id: tgRecipe.h,v 1.6 1998/02/26 04:36:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*
*
*
+ *
* geo-decls.h */
#endif /* TIOGA_FRONTEND */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.26 1998/02/25 13:07:43 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.27 1998/02/26 04:36:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* RETURNS:
* the new Acl
*/
-Acl *
+Acl *
makeacl(int n)
{
Acl *new_acl;
* RETURNS:
* the new string
*/
-char *
+char *
aclitemout(AclItem *aip)
{
- char *p;
+ char *p;
char *out;
HeapTuple htp;
unsigned i;
#ifdef NOT_USED
- When this elog(NOTICE) goes to the libpq client, it crashes the
- client because the NOTICE protocol is coming right in the middle
- of a request for a field value. We skip the NOTICE for now.
+ When this elog(NOTICE) goes to the libpq client,
+ it crashes the
+ client because the NOTICE protocol is coming right in the middle
+ of a request for a field value.We skip the NOTICE for now.
- elog(NOTICE, "aclitemout: usesysid %d not found",
- aip->ai_id);
+ elog(NOTICE, "aclitemout: usesysid %d not found",
+ aip->ai_id);
#endif
(a1->ai_idtype == a2->ai_idtype && a1->ai_id > a2->ai_id));
}
-Acl *
+Acl *
aclownerdefault(char *relname, AclId ownerid)
{
Acl *acl;
return (acl);
}
-Acl *
+Acl *
acldefault(char *relname)
{
Acl *acl;
return (acl);
}
-Acl *
+Acl *
aclinsert3(Acl *old_acl, AclItem *mod_aip, unsigned modechg)
{
Acl *new_acl;
* aclinsert
*
*/
-Acl *
+Acl *
aclinsert(Acl *old_acl, AclItem *mod_aip)
{
return (aclinsert3(old_acl, mod_aip, ACL_MODECHG_EQL));
}
-Acl *
+Acl *
aclremove(Acl *old_acl, AclItem *mod_aip)
{
Acl *new_acl;
*
*/
-char *
+char *
aclmakepriv(char *old_privlist, char new_priv)
{
char *priv;
*
*/
-char *
+char *
aclmakeuser(char *user_type, char *user)
{
char *user_list;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.26 1998/02/14 18:00:37 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.27 1998/02/26 04:36:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*-=-=--=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-*/
static int _ArrayCount(char *str, int dim[], int typdelim);
-static char *_ReadArrayStr(char *arrayStr, int nitems, int ndim, int dim[],
+static char *
+_ReadArrayStr(char *arrayStr, int nitems, int ndim, int dim[],
FmgrInfo *inputproc, Oid typelem, int16 typmod,
char typdelim, int typlen, bool typbyval,
char typalign, int *nbytes);
* the internal representation of the input array
*--------------------------------------------------------------------
*/
-char *
+char *
array_in(char *string, /* input array in external form */
Oid element_type, /* type OID of an array element */
int16 typmod)
/* array not a large object */
dataPtr =
(char *) _ReadArrayStr(p, nitems, ndim, dim, &inputproc, typelem,
- typmod, typdelim, typlen, typbyval, typalign,
+ typmod, typdelim, typlen, typbyval, typalign,
&nbytes);
nbytes += ARR_OVERHEAD(ndim);
retval = (ArrayType *) palloc(nbytes);
* containing the array in its external format.
*-------------------------------------------------------------------------
*/
-char *
+char *
array_out(ArrayType *v, Oid element_type)
{
int typlen;
* returns the dimension of the array pointed to by "v"
*----------------------------------------------------------------------------
*/
-char *
+char *
array_dims(ArrayType *v, bool *isNull)
{
char *p,
* returns a pointer to the modified array.
*-----------------------------------------------------------------------------
*/
-char *
+char *
array_set(ArrayType *array,
int n,
int indx[],
* returns a pointer to the modified array.
*----------------------------------------------------------------------------
*/
-char *
+char *
array_assgn(ArrayType *array,
int n,
int upperIndx[],
#undef MAX_READ
}
-char *
+char *
_array_newLO(int *fd, int flag)
{
char *p;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/bool.c,v 1.13 1998/01/05 16:39:42 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/bool.c,v 1.14 1998/02/26 04:36:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
bool
boolin(char *b)
{
- switch(*b) {
- case 't':
- case 'T':
+ switch (*b)
+ {
+ case 't':
+ case 'T':
if (strncasecmp(b, "true", strlen(b)) == 0)
return (TRUE);
break;
break;
}
- elog(ERROR,"Bad boolean external representation '%s'", b);
+ elog(ERROR, "Bad boolean external representation '%s'", b);
/* not reached */
return (FALSE);
-} /* boolin() */
+} /* boolin() */
/*
* boolout - converts 1 or 0 to "t" or "f"
*result = (b) ? 't' : 'f';
result[1] = '\0';
return (result);
-} /* boolout() */
+} /* boolout() */
/*****************************************************************************
bool
istrue(bool arg1)
{
- return(arg1 == TRUE);
-} /* istrue() */
+ return (arg1 == TRUE);
+} /* istrue() */
bool
isfalse(bool arg1)
{
- return(arg1 != TRUE);
-} /* isfalse() */
+ return (arg1 != TRUE);
+} /* isfalse() */
* workings can be found in the book "Software Solutions in C" by
* Dale Schumacher, Academic Press, ISBN: 0-12-632360-7.
*
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/cash.c,v 1.21 1998/01/07 18:46:34 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/cash.c,v 1.22 1998/02/26 04:36:53 momjian Exp $
*/
#include
#ifdef USE_LOCALE
static struct lconv *lconvert = NULL;
+
#endif
/* cash_in()
* monetary values returned by localeconv() can be multiple
* bytes/characters. This code assumes one byte only. - tgl 97/04/14
*/
-Cash *
+Cash *
cash_in(const char *str)
{
Cash *result;
/* frac_digits in the C locale seems to return CHAR_MAX */
/* best guess is 2 in this case I think */
- fpoint = ((lconvert->frac_digits != CHAR_MAX) ? lconvert->frac_digits : 2); /* int_frac_digits? */
+ fpoint = ((lconvert->frac_digits != CHAR_MAX) ? lconvert->frac_digits : 2); /* int_frac_digits? */
dsymbol = *lconvert->mon_decimal_point;
ssymbol = *lconvert->mon_thousands_sep;
#endif
#ifdef CASHDEBUG
-printf( "cashin- precision %d; decimal %c; thousands %c; currency %c; positive %c; negative %c\n",
- fpoint, dsymbol, ssymbol, csymbol, psymbol, nsymbol);
+ printf("cashin- precision %d; decimal %c; thousands %c; currency %c; positive %c; negative %c\n",
+ fpoint, dsymbol, ssymbol, csymbol, psymbol, nsymbol);
#endif
/* we need to add all sorts of checking here. For now just */
*result = (value * sgn);
return (result);
-} /* cash_in() */
+} /* cash_in() */
/* cash_out()
nsymbol = lconvert->negative_sign;
/* frac_digits in the C locale seems to return CHAR_MAX */
/* best guess is 2 in this case I think */
- points = ((lconvert->frac_digits != CHAR_MAX) ? lconvert->frac_digits : 2); /* int_frac_digits? */
+ points = ((lconvert->frac_digits != CHAR_MAX) ? lconvert->frac_digits : 2); /* int_frac_digits? */
convention = lconvert->n_sign_posn;
#else
mon_group = 3;
}
return (result);
-} /* cash_out() */
+} /* cash_out() */
bool
return (FALSE);
return (*c1 == *c2);
-} /* cash_eq() */
+} /* cash_eq() */
bool
cash_ne(Cash *c1, Cash *c2)
return (FALSE);
return (*c1 != *c2);
-} /* cash_ne() */
+} /* cash_ne() */
bool
cash_lt(Cash *c1, Cash *c2)
return (FALSE);
return (*c1 < *c2);
-} /* cash_lt() */
+} /* cash_lt() */
bool
cash_le(Cash *c1, Cash *c2)
return (FALSE);
return (*c1 <= *c2);
-} /* cash_le() */
+} /* cash_le() */
bool
cash_gt(Cash *c1, Cash *c2)
return (FALSE);
return (*c1 > *c2);
-} /* cash_gt() */
+} /* cash_gt() */
bool
cash_ge(Cash *c1, Cash *c2)
return (FALSE);
return (*c1 >= *c2);
-} /* cash_ge() */
+} /* cash_ge() */
/* cash_pl()
* Add two cash values.
*/
-Cash *
+Cash *
cash_pl(Cash *c1, Cash *c2)
{
Cash *result;
*result = (*c1 + *c2);
return (result);
-} /* cash_pl() */
+} /* cash_pl() */
/* cash_mi()
* Subtract two cash values.
*/
-Cash *
+Cash *
cash_mi(Cash *c1, Cash *c2)
{
Cash *result;
*result = (*c1 - *c2);
return (result);
-} /* cash_mi() */
+} /* cash_mi() */
/* cash_mul_flt8()
* Multiply cash by float8.
*/
-Cash *
+Cash *
cash_mul_flt8(Cash *c, float8 *f)
{
Cash *result;
*result = ((*f) * (*c));
return (result);
-} /* cash_mul_flt8() */
+} /* cash_mul_flt8() */
/* flt8_mul_cash()
* Multiply float8 by cash.
*/
-Cash *
+Cash *
flt8_mul_cash(float8 *f, Cash *c)
{
return (cash_mul_flt8(c, f));
-} /* flt8_mul_cash() */
+} /* flt8_mul_cash() */
/* cash_div_flt8()
* XXX Don't know if rounding or truncating is correct behavior.
* Round for now. - tgl 97/04/15
*/
-Cash *
+Cash *
cash_div_flt8(Cash *c, float8 *f)
{
Cash *result;
*result = rint(*c / *f);
return (result);
-} /* cash_div_flt8() */
+} /* cash_div_flt8() */
/* cash_mul_flt4()
* Multiply cash by float4.
*/
-Cash *
+Cash *
cash_mul_flt4(Cash *c, float4 *f)
{
Cash *result;
*result = ((*f) * (*c));
return (result);
-} /* cash_mul_flt4() */
+} /* cash_mul_flt4() */
/* flt4_mul_cash()
* Multiply float4 by float4.
*/
-Cash *
+Cash *
flt4_mul_cash(float4 *f, Cash *c)
{
return (cash_mul_flt4(c, f));
-} /* flt4_mul_cash() */
+} /* flt4_mul_cash() */
/* cash_div_flt4()
* XXX Don't know if rounding or truncating is correct behavior.
* Round for now. - tgl 97/04/15
*/
-Cash *
+Cash *
cash_div_flt4(Cash *c, float4 *f)
{
Cash *result;
*result = rint(*c / *f);
return (result);
-} /* cash_div_flt4() */
+} /* cash_div_flt4() */
/* cash_mul_int4()
* Multiply cash by int4.
*/
-Cash *
+Cash *
cash_mul_int4(Cash *c, int4 i)
{
Cash *result;
*result = ((i) * (*c));
return (result);
-} /* cash_mul_int4() */
+} /* cash_mul_int4() */
/* int4_mul_cash()
* Multiply int4 by cash.
*/
-Cash *
+Cash *
int4_mul_cash(int4 i, Cash *c)
{
return (cash_mul_int4(c, i));
-} /* int4_mul_cash() */
+} /* int4_mul_cash() */
/* cash_div_int4()
* XXX Don't know if rounding or truncating is correct behavior.
* Round for now. - tgl 97/04/15
*/
-Cash *
+Cash *
cash_div_int4(Cash *c, int4 i)
{
Cash *result;
*result = rint(*c / i);
return (result);
-} /* cash_div_int4() */
+} /* cash_div_int4() */
/* cash_mul_int2()
* Multiply cash by int2.
*/
-Cash *
+Cash *
cash_mul_int2(Cash *c, int2 s)
{
Cash *result;
*result = ((s) * (*c));
return (result);
-} /* cash_mul_int2() */
+} /* cash_mul_int2() */
/* int2_mul_cash()
* Multiply int2 by cash.
*/
-Cash *
+Cash *
int2_mul_cash(int2 s, Cash *c)
{
return (cash_mul_int2(c, s));
-} /* int2_mul_cash() */
+} /* int2_mul_cash() */
/* cash_div_int2()
* XXX Don't know if rounding or truncating is correct behavior.
* Round for now. - tgl 97/04/15
*/
-Cash *
+Cash *
cash_div_int2(Cash *c, int2 s)
{
Cash *result;
*result = rint(*c / s);
return (result);
-} /* cash_div_int2() */
+} /* cash_div_int2() */
/* cashlarger()
* Return larger of two cash values.
*/
-Cash *
+Cash *
cashlarger(Cash *c1, Cash *c2)
{
Cash *result;
*result = ((*c1 > *c2) ? *c1 : *c2);
return (result);
-} /* cashlarger() */
+} /* cashlarger() */
/* cashsmaller()
* Return smaller of two cash values.
*/
-Cash *
+Cash *
cashsmaller(Cash *c1, Cash *c2)
{
Cash *result;
*result = ((*c1 < *c2) ? *c1 : *c2);
return (result);
-} /* cashsmaller() */
+} /* cashsmaller() */
/* cash_words_out()
strcat(buf, m0 == 1 ? " cent" : " cents");
*buf = toupper(*buf);
return (buf);
-} /* cash_words_out() */
+} /* cash_words_out() */
/*************************************************************************
}
return (buf);
-} /* num_word() */
+} /* num_word() */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/char.c,v 1.14 1997/11/02 15:25:57 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/char.c,v 1.15 1998/02/26 04:36:54 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* charout - converts 'x' to "x"
*/
-char *
+char *
charout(int32 ch)
{
char *result = (char *) palloc(2);
* NOTE: we must no use 'charout' because cid might be a non
* printable character...
*/
-char *
+char *
cidout(int32 c)
{
char *result;
* Note:
* Currently if strlen(s) < 14, the extra chars are nulls
*/
-char *
+char *
char16in(char *s)
{
char *result;
/*
* char16out - converts internal reprsentation to "..."
*/
-char *
+char *
char16out(char *s)
{
char *result = (char *) palloc(17);
return (res);
}
-char *
+char *
char2out(uint16 s)
{
char *result = (char *) palloc(3);
return (res);
}
-char *
+char *
char4out(s)
uint32 s;
{
}
/* ============================== char8 ============================== */
-char *
+char *
char8in(char *s)
{
char *result;
return (result);
}
-char *
+char *
char8out(char *s)
{
char *result = (char *) palloc(9);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/chunk.c,v 1.15 1998/02/11 19:12:08 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/chunk.c,v 1.16 1998/02/26 04:36:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* information about the chunked file
*-----------------------------------------------------------------------
*/
-char *
+char *
_ChunkArray(int fd,
FILE *afd,
int ndim,
* compute the number of page fetches for a given chunk size (d[])
* and access pattern (A[][])
*/
- int i,
+ int i,
j,
nc;
static int
get_next(int d[], int k, int C, int dmax[])
{
- int i,
+ int i,
j,
temp;
}
#ifdef LOARRAY
-static char a_chunk[BLCKSZ + VARHDRSZ];/* VARHDRSZ since a_chunk is in varlena format */
+static char a_chunk[BLCKSZ + VARHDRSZ]; /* VARHDRSZ since a_chunk is in
+ * varlena format */
#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.23 1998/02/11 19:12:19 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.24 1998/02/26 04:36:57 momjian Exp $
*
* NOTES
* This code is actually (almost) unused.
elog(ERROR, "Bad reltime (internal coding error) '%s'", str);
return (INVALID_RELTIME);
-} /* reltimein() */
+} /* reltimein() */
/*
* reltimeout - converts the internal format to a reltime string
*/
-char *
+char *
reltimeout(int32 time)
{
char *result;
strcpy(result, buf);
return (result);
-} /* reltimeout() */
+} /* reltimeout() */
#define TMODULO(t,q,u) {q = (t / u); \
TMODULO(time, tm->tm_sec, 1);
return;
-} /* reltime2tm() */
+} /* reltime2tm() */
#if FALSE
char *timestring;
long quantity;
-int i;
+int i;
int unitnr;
timestring = (char *) palloc(Max(strlen(INVALID_RELTIME_STR),
* tintervalout - converts an internal interval format to a string
*
*/
-char *
+char *
tintervalout(TimeInterval interval)
{
char *i_str,
}
return (time);
-} /* timespan_reltime() */
+} /* timespan_reltime() */
TimeSpan *
}
return (result);
-} /* reltime_timespan() */
+} /* reltime_timespan() */
/*
return (FALSE); /* invalid interval */
return (abstimeeq(i1->data[0], i2->data[0]) &&
abstimeeq(i1->data[1], i2->data[1]));
-} /* intervalsame() */
+} /* intervalsame() */
/*
bool
intervaleq(TimeInterval i1, TimeInterval i2)
{
- AbsoluteTime t10, t11, t20, t21;
+ AbsoluteTime t10,
+ t11,
+ t20,
+ t21;
if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
return (FALSE); /* invalid interval */
t21 = i2->data[1];
if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
+ || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
return (FALSE);
if (t10 == CURRENT_ABSTIME)
if (t21 == CURRENT_ABSTIME)
t21 = GetCurrentTransactionStartTime();
- return ((t11-t10) == (t21-t20));
-} /* intervaleq() */
+ return ((t11 - t10) == (t21 - t20));
+} /* intervaleq() */
/*
* intervalne - returns 1, iff interval i1 is not equal to interval i2
bool
intervalne(TimeInterval i1, TimeInterval i2)
{
- AbsoluteTime t10, t11, t20, t21;
+ AbsoluteTime t10,
+ t11,
+ t20,
+ t21;
if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
return (FALSE); /* invalid interval */
t21 = i2->data[1];
if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
+ || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
return (FALSE);
if (t10 == CURRENT_ABSTIME)
if (t21 == CURRENT_ABSTIME)
t21 = GetCurrentTransactionStartTime();
- return ((t11-t10) != (t21-t20));
-} /* intervalne() */
+ return ((t11 - t10) != (t21 - t20));
+} /* intervalne() */
/*
* intervallt - returns TRUE, iff interval i1 is less than interval i2
bool
intervallt(TimeInterval i1, TimeInterval i2)
{
- AbsoluteTime t10, t11, t20, t21;
+ AbsoluteTime t10,
+ t11,
+ t20,
+ t21;
if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
return (FALSE); /* invalid interval */
t21 = i2->data[1];
if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
+ || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
return (FALSE);
if (t10 == CURRENT_ABSTIME)
if (t21 == CURRENT_ABSTIME)
t21 = GetCurrentTransactionStartTime();
- return ((t11-t10) < (t21-t20));
-} /* intervallt() */
+ return ((t11 - t10) < (t21 - t20));
+} /* intervallt() */
/*
* intervalle - returns TRUE, iff interval i1 is less than or equal to interval i2
bool
intervalle(TimeInterval i1, TimeInterval i2)
{
- AbsoluteTime t10, t11, t20, t21;
+ AbsoluteTime t10,
+ t11,
+ t20,
+ t21;
if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
return (FALSE); /* invalid interval */
t21 = i2->data[1];
if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
+ || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
return (FALSE);
if (t10 == CURRENT_ABSTIME)
if (t21 == CURRENT_ABSTIME)
t21 = GetCurrentTransactionStartTime();
- return ((t11-t10) <= (t21-t20));
-} /* intervalle() */
+ return ((t11 - t10) <= (t21 - t20));
+} /* intervalle() */
/*
* intervalgt - returns TRUE, iff interval i1 is less than interval i2
bool
intervalgt(TimeInterval i1, TimeInterval i2)
{
- AbsoluteTime t10, t11, t20, t21;
+ AbsoluteTime t10,
+ t11,
+ t20,
+ t21;
if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
return (FALSE); /* invalid interval */
t21 = i2->data[1];
if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
+ || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
return (FALSE);
if (t10 == CURRENT_ABSTIME)
if (t21 == CURRENT_ABSTIME)
t21 = GetCurrentTransactionStartTime();
- return ((t11-t10) > (t21-t20));
-} /* intervalgt() */
+ return ((t11 - t10) > (t21 - t20));
+} /* intervalgt() */
/*
* intervalge - returns TRUE, iff interval i1 is less than or equal to interval i2
bool
intervalge(TimeInterval i1, TimeInterval i2)
{
- AbsoluteTime t10, t11, t20, t21;
+ AbsoluteTime t10,
+ t11,
+ t20,
+ t21;
if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
return (FALSE); /* invalid interval */
t21 = i2->data[1];
if ((t10 == INVALID_ABSTIME) || (t20 == INVALID_ABSTIME)
- || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
+ || (t20 == INVALID_ABSTIME) || (t21 == INVALID_ABSTIME))
return (FALSE);
if (t10 == CURRENT_ABSTIME)
if (t21 == CURRENT_ABSTIME)
t21 = GetCurrentTransactionStartTime();
- return ((t11-t10) >= (t21-t20));
-} /* intervalge() */
+ return ((t11 - t10) >= (t21 - t20));
+} /* intervalge() */
/*
}
return 0;
-} /* isreltime() */
+} /* isreltime() */
#if FALSE
-char *p;
-char c;
+char *p;
+char c;
int i;
char unit[UNITMAXLEN];
char direction[DIRMAXLEN];
AbsoluteTime *i_start,
AbsoluteTime *i_end)
{
- char *p,
+ char *p,
*p1;
- char c;
+ char c;
p = i_string;
/* skip leading blanks up to '[' */
* the Wisconsin benchmark with Illustra whose TimeNow() shows current
* time with precision up to microsecs.) - ay 3/95
*/
-text *
+text *
timeofday(void)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.21 1998/01/07 18:46:41 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.22 1998/02/26 04:36:59 momjian Exp $
*
*-------------------------------------------------------------------------
*/
date = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1));
return (date);
-} /* date_in() */
+} /* date_in() */
/* date_out()
* Given internal format date, convert to text string.
strcpy(result, buf);
return (result);
-} /* date_out() */
+} /* date_out() */
bool
date_eq(DateADT dateVal1, DateADT dateVal2)
date_lt(DateADT dateVal1, DateADT dateVal2)
{
return (dateVal1 < dateVal2);
-} /* date_lt() */
+} /* date_lt() */
bool
date_le(DateADT dateVal1, DateADT dateVal2)
{
return (dateVal1 <= dateVal2);
-} /* date_le() */
+} /* date_le() */
bool
date_gt(DateADT dateVal1, DateADT dateVal2)
{
return (dateVal1 > dateVal2);
-} /* date_gt() */
+} /* date_gt() */
bool
date_ge(DateADT dateVal1, DateADT dateVal2)
{
return (dateVal1 >= dateVal2);
-} /* date_ge() */
+} /* date_ge() */
int
date_cmp(DateADT dateVal1, DateADT dateVal2)
return 1;
}
return 0;
-} /* date_cmp() */
+} /* date_cmp() */
DateADT
date_larger(DateADT dateVal1, DateADT dateVal2)
{
return (date_gt(dateVal1, dateVal2) ? dateVal1 : dateVal2);
-} /* date_larger() */
+} /* date_larger() */
DateADT
date_smaller(DateADT dateVal1, DateADT dateVal2)
{
return (date_lt(dateVal1, dateVal2) ? dateVal1 : dateVal2);
-} /* date_smaller() */
+} /* date_smaller() */
/* Compute difference between two dates in days.
*/
date_mi(DateADT dateVal1, DateADT dateVal2)
{
return (dateVal1 - dateVal2);
-} /* date_mi() */
+} /* date_mi() */
/* Add a number of days to a date, giving a new date.
* Must handle both positive and negative numbers of days.
date_pli(DateADT dateVal, int4 days)
{
return (dateVal + days);
-} /* date_pli() */
+} /* date_pli() */
/* Subtract a number of days from a date, giving a new date.
*/
date_mii(DateADT dateVal, int4 days)
{
return (date_pli(dateVal, -days));
-} /* date_mii() */
+} /* date_mii() */
/* date_datetime()
* Convert date to datetime data type.
*/
-DateTime *
+DateTime *
date_datetime(DateADT dateVal)
{
DateTime *result;
elog(ERROR, "Datetime out of range", NULL);
return (result);
-} /* date_datetime() */
+} /* date_datetime() */
/* datetime_date()
result = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(2000, 1, 1));
return (result);
-} /* datetime_date() */
+} /* datetime_date() */
/* abstime_date()
}
return (result);
-} /* abstime_date() */
+} /* abstime_date() */
/* date2tm()
}
return 0;
-} /* date2tm() */
+} /* date2tm() */
/*****************************************************************************
*****************************************************************************/
-TimeADT *
+TimeADT *
time_in(char *str)
{
TimeADT *time;
*time = ((((tm->tm_hour * 60) + tm->tm_min) * 60) + tm->tm_sec + fsec);
return (time);
-} /* time_in() */
+} /* time_in() */
char *
strcpy(result, buf);
return (result);
-} /* time_out() */
+} /* time_out() */
bool
return (FALSE);
return (*time1 == *time2);
-} /* time_eq() */
+} /* time_eq() */
bool
time_ne(TimeADT *time1, TimeADT *time2)
return (FALSE);
return (*time1 != *time2);
-} /* time_eq() */
+} /* time_eq() */
bool
time_lt(TimeADT *time1, TimeADT *time2)
return (FALSE);
return (*time1 < *time2);
-} /* time_eq() */
+} /* time_eq() */
bool
time_le(TimeADT *time1, TimeADT *time2)
return (FALSE);
return (*time1 <= *time2);
-} /* time_eq() */
+} /* time_eq() */
bool
time_gt(TimeADT *time1, TimeADT *time2)
return (FALSE);
return (*time1 > *time2);
-} /* time_eq() */
+} /* time_eq() */
bool
time_ge(TimeADT *time1, TimeADT *time2)
return (FALSE);
return (*time1 >= *time2);
-} /* time_eq() */
+} /* time_eq() */
int
time_cmp(TimeADT *time1, TimeADT *time2)
{
return ((*time1 < *time2) ? -1 : (((*time1 > *time2) ? 1 : 0)));
-} /* time_cmp() */
+} /* time_cmp() */
/* datetime_time()
* Convert datetime to time data type.
*/
-TimeADT *
+TimeADT *
datetime_time(DateTime *datetime)
{
- TimeADT *result;
+ TimeADT *result;
struct tm tt,
*tm = &tt;
int tz;
*result = ((((tm->tm_hour * 60) + tm->tm_min) * 60) + tm->tm_sec + fsec);
return (result);
-} /* datetime_time() */
+} /* datetime_time() */
/* datetime_datetime()
* Convert date and time to datetime data type.
*/
-DateTime *
+DateTime *
datetime_datetime(DateADT date, TimeADT *time)
{
DateTime *result;
{
result = palloc(sizeof(DateTime));
DATETIME_INVALID(*result);
- } else {
+ }
+ else
+ {
result = date_datetime(date);
*result += *time;
}
return (result);
-} /* datetime_datetime() */
+} /* datetime_datetime() */
int32 /* RelativeTime */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/dt.c,v 1.51 1998/02/11 19:12:33 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/dt.c,v 1.52 1998/02/26 04:37:02 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#endif
#include "utils/builtins.h"
-static int DecodeDate(char *str, int fmask, int *tmask, struct tm * tm);
+static int DecodeDate(char *str, int fmask, int *tmask, struct tm * tm);
static int
DecodeNumber(int flen, char *field,
int fmask, int *tmask, struct tm * tm, double *fsec);
static int
DecodeNumberField(int len, char *str,
int fmask, int *tmask, struct tm * tm, double *fsec);
-static int DecodeSpecial(int field, char *lowtoken, int *val);
+static int DecodeSpecial(int field, char *lowtoken, int *val);
static int
DecodeTime(char *str, int fmask, int *tmask,
struct tm * tm, double *fsec);
-static int DecodeTimezone(char *str, int *tzp);
-static int DecodeUnits(int field, char *lowtoken, int *val);
-static int EncodeSpecialDateTime(DateTime dt, char *str);
+static int DecodeTimezone(char *str, int *tzp);
+static int DecodeUnits(int field, char *lowtoken, int *val);
+static int EncodeSpecialDateTime(DateTime dt, char *str);
static datetkn *datebsearch(char *key, datetkn *base, unsigned int nel);
static DateTime dt2local(DateTime dt, int timezone);
static void dt2time(DateTime dt, int *hour, int *min, double *sec);
-static int j2day(int jd);
+static int j2day(int jd);
#define USE_DATE_CACHE 1
#define ROUND_ALL 0
}
return (result);
-} /* datetime_in() */
+} /* datetime_in() */
/* datetime_out()
* Convert a datetime to external form.
*/
-char *
+char *
datetime_out(DateTime *dt)
{
char *result;
strcpy(result, buf);
return (result);
-} /* datetime_out() */
+} /* datetime_out() */
/* timespan_in()
}
return (span);
-} /* timespan_in() */
+} /* timespan_in() */
/* timespan_out()
* Convert a time span to external form.
*/
-char *
+char *
timespan_out(TimeSpan *span)
{
char *result;
strcpy(result, buf);
return (result);
-} /* timespan_out() */
+} /* timespan_out() */
/*****************************************************************************
return FALSE;
return (!DATETIME_NOT_FINITE(*datetime));
-} /* datetime_finite() */
+} /* datetime_finite() */
bool
timespan_finite(TimeSpan *timespan)
return FALSE;
return (!TIMESPAN_NOT_FINITE(*timespan));
-} /* timespan_finite() */
+} /* timespan_finite() */
/*----------------------------------------------------------
#endif
return;
-} /* GetEpochTime() */
+} /* GetEpochTime() */
DateTime
SetDateTime(DateTime dt)
}
return (dt);
-} /* SetDateTime() */
+} /* SetDateTime() */
/* datetime_relop - is datetime1 relop datetime2
*/
dt2 = SetDateTime(dt2);
return (dt1 == dt2);
-} /* datetime_eq() */
+} /* datetime_eq() */
bool
datetime_ne(DateTime *datetime1, DateTime *datetime2)
dt2 = SetDateTime(dt2);
return (dt1 != dt2);
-} /* datetime_ne() */
+} /* datetime_ne() */
bool
datetime_lt(DateTime *datetime1, DateTime *datetime2)
dt2 = SetDateTime(dt2);
return (dt1 < dt2);
-} /* datetime_lt() */
+} /* datetime_lt() */
bool
datetime_gt(DateTime *datetime1, DateTime *datetime2)
printf("datetime_gt- %f %s greater than %f\n", dt1, ((dt1 > dt2) ? "is" : "is not"), dt2);
#endif
return (dt1 > dt2);
-} /* datetime_gt() */
+} /* datetime_gt() */
bool
datetime_le(DateTime *datetime1, DateTime *datetime2)
dt2 = SetDateTime(dt2);
return (dt1 <= dt2);
-} /* datetime_le() */
+} /* datetime_le() */
bool
datetime_ge(DateTime *datetime1, DateTime *datetime2)
dt2 = SetDateTime(dt2);
return (dt1 >= dt2);
-} /* datetime_ge() */
+} /* datetime_ge() */
/* datetime_cmp - 3-state comparison for datetime
}
return (((dt1 < dt2) ? -1 : ((dt1 > dt2) ? 1 : 0)));
-} /* datetime_cmp() */
+} /* datetime_cmp() */
/* timespan_relop - is timespan1 relop timespan2
return ((timespan1->time == timespan2->time)
&& (timespan1->month == timespan2->month));
-} /* timespan_eq() */
+} /* timespan_eq() */
bool
timespan_ne(TimeSpan *timespan1, TimeSpan *timespan2)
return ((timespan1->time != timespan2->time)
|| (timespan1->month != timespan2->month));
-} /* timespan_ne() */
+} /* timespan_ne() */
bool
timespan_lt(TimeSpan *timespan1, TimeSpan *timespan2)
span2 += (timespan2->month * (30.0 * 86400));
return (span1 < span2);
-} /* timespan_lt() */
+} /* timespan_lt() */
bool
timespan_gt(TimeSpan *timespan1, TimeSpan *timespan2)
span2 += (timespan2->month * (30.0 * 86400));
return (span1 > span2);
-} /* timespan_gt() */
+} /* timespan_gt() */
bool
timespan_le(TimeSpan *timespan1, TimeSpan *timespan2)
span2 += (timespan2->month * (30.0 * 86400));
return (span1 <= span2);
-} /* timespan_le() */
+} /* timespan_le() */
bool
timespan_ge(TimeSpan *timespan1, TimeSpan *timespan2)
span2 += (timespan2->month * (30.0 * 86400));
return (span1 >= span2);
-} /* timespan_ge() */
+} /* timespan_ge() */
/* timespan_cmp - 3-state comparison for timespan
span2 += (timespan2->month * (30.0 * 86400));
return ((span1 < span2) ? -1 : (span1 > span2) ? 1 : 0);
-} /* timespan_cmp() */
+} /* timespan_cmp() */
/*----------------------------------------------------------
}
return (result);
-} /* datetime_smaller() */
+} /* datetime_smaller() */
DateTime *
datetime_larger(DateTime *datetime1, DateTime *datetime2)
}
return (result);
-} /* datetime_larger() */
+} /* datetime_larger() */
TimeSpan *
result->month = 0;
return (result);
-} /* datetime_mi() */
+} /* datetime_mi() */
/* datetime_pl_span()
}
return (result);
-} /* datetime_pl_span() */
+} /* datetime_pl_span() */
DateTime *
datetime_mi_span(DateTime *datetime, TimeSpan *span)
result = datetime_pl_span(datetime, &tspan);
return (result);
-} /* datetime_mi_span() */
+} /* datetime_mi_span() */
TimeSpan *
result->month = -(timespan->month);
return (result);
-} /* timespan_um() */
+} /* timespan_um() */
TimeSpan *
}
return (result);
-} /* timespan_smaller() */
+} /* timespan_smaller() */
TimeSpan *
timespan_larger(TimeSpan *timespan1, TimeSpan *timespan2)
}
return (result);
-} /* timespan_larger() */
+} /* timespan_larger() */
TimeSpan *
result->time = JROUND(span1->time + span2->time);
return (result);
-} /* timespan_pl() */
+} /* timespan_pl() */
TimeSpan *
timespan_mi(TimeSpan *span1, TimeSpan *span2)
result->time = JROUND(span1->time - span2->time);
return (result);
-} /* timespan_mi() */
+} /* timespan_mi() */
TimeSpan *
timespan_div(TimeSpan *span1, float8 *arg2)
result->time = JROUND(span1->time / *arg2);
return (result);
-} /* timespan_div() */
+} /* timespan_div() */
/* datetime_age()
* Calculate time difference while retaining year/month fields.
}
return (result);
-} /* datetime_age() */
+} /* datetime_age() */
/*----------------------------------------------------------
/* datetime_text()
* Convert datetime to text data type.
*/
-text *
+text *
datetime_text(DateTime *datetime)
{
text *result;
pfree(str);
return (result);
-} /* datetime_text() */
+} /* datetime_text() */
/* text_datetime()
result = datetime_in(dstr);
return (result);
-} /* text_datetime() */
+} /* text_datetime() */
/* timespan_text()
* Convert timespan to text data type.
*/
-text *
+text *
timespan_text(TimeSpan *timespan)
{
text *result;
pfree(str);
return (result);
-} /* timespan_text() */
+} /* timespan_text() */
/* text_timespan()
* Text type may not be null terminated, so copy to temporary string
* then call the standard input routine.
*/
-TimeSpan *
+TimeSpan *
text_timespan(text *str)
{
TimeSpan *result;
result = timespan_in(dstr);
return (result);
-} /* text_timespan() */
+} /* text_timespan() */
/* datetime_trunc()
* Extract specified field from datetime.
}
return (result);
-} /* datetime_trunc() */
+} /* datetime_trunc() */
/* timespan_trunc()
* Extract specified field from timespan.
}
return (result);
-} /* timespan_trunc() */
+} /* timespan_trunc() */
/* datetime_part()
elog(ERROR, "Unable to encode datetime", NULL);
*result = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday)
- - date2j(tm->tm_year, 1, 1) + 1);
+ - date2j(tm->tm_year, 1, 1) + 1);
break;
default:
}
return (result);
-} /* datetime_part() */
+} /* datetime_part() */
/* timespan_part()
}
return (result);
-} /* timespan_part() */
+} /* timespan_part() */
/* datetime_zone()
* Encode datetime type with specified time zone.
*/
-text *
+text *
datetime_zone(text *zone, DateTime *datetime)
{
text *result;
}
return (result);
-} /* datetime_zone() */
+} /* datetime_zone() */
/*****************************************************************************
*/
static datetkn datetktbl[] = {
/* text token lexval */
- {EARLY, RESERV, DTK_EARLY}, /* "-infinity" reserved for "early time" */
- {"acsst", DTZ, 63}, /* Cent. Australia */
- {"acst", TZ, 57}, /* Cent. Australia */
- {DA_D, ADBC, AD}, /* "ad" for years >= 0 */
- {"abstime", IGNORE, 0}, /* "abstime" for pre-v6.1 "Invalid Abstime" */
- {"adt", DTZ, NEG(18)}, /* Atlantic Daylight Time */
- {"aesst", DTZ, 66}, /* E. Australia */
- {"aest", TZ, 60}, /* Australia Eastern Std Time */
- {"ahst", TZ, 60}, /* Alaska-Hawaii Std Time */
- {"allballs", RESERV, DTK_ZULU}, /* 00:00:00 */
- {"am", AMPM, AM},
- {"apr", MONTH, 4},
- {"april", MONTH, 4},
- {"ast", TZ, NEG(24)}, /* Atlantic Std Time (Canada) */
- {"at", IGNORE, 0}, /* "at" (throwaway) */
- {"aug", MONTH, 8},
- {"august", MONTH, 8},
- {"awsst", DTZ, 54}, /* W. Australia */
- {"awst", TZ, 48}, /* W. Australia */
- {DB_C, ADBC, BC}, /* "bc" for years < 0 */
- {"bst", TZ, 6}, /* British Summer Time */
- {"bt", TZ, 18}, /* Baghdad Time */
- {"cadt", DTZ, 63}, /* Central Australian DST */
- {"cast", TZ, 57}, /* Central Australian ST */
- {"cat", TZ, NEG(60)}, /* Central Alaska Time */
- {"cct", TZ, 48}, /* China Coast */
- {"cdt", DTZ, NEG(30)}, /* Central Daylight Time */
- {"cet", TZ, 6}, /* Central European Time */
- {"cetdst", DTZ, 12}, /* Central European Dayl.Time */
- {"cst", TZ, NEG(36)}, /* Central Standard Time */
- {DCURRENT, RESERV, DTK_CURRENT}, /* "current" is always now */
- {"dec", MONTH, 12},
- {"december", MONTH, 12},
- {"dnt", TZ, 6}, /* Dansk Normal Tid */
- {"dow", RESERV, DTK_DOW}, /* day of week */
- {"doy", RESERV, DTK_DOY}, /* day of year */
- {"dst", DTZMOD, 6},
- {"east", TZ, NEG(60)}, /* East Australian Std Time */
- {"edt", DTZ, NEG(24)}, /* Eastern Daylight Time */
- {"eet", TZ, 12}, /* East. Europe, USSR Zone 1 */
- {"eetdst", DTZ, 18}, /* Eastern Europe */
- {EPOCH, RESERV, DTK_EPOCH}, /* "epoch" reserved for system epoch time */
+ {EARLY, RESERV, DTK_EARLY}, /* "-infinity" reserved for "early time" */
+ {"acsst", DTZ, 63}, /* Cent. Australia */
+ {"acst", TZ, 57}, /* Cent. Australia */
+ {DA_D, ADBC, AD}, /* "ad" for years >= 0 */
+ {"abstime", IGNORE, 0}, /* "abstime" for pre-v6.1 "Invalid
+ * Abstime" */
+ {"adt", DTZ, NEG(18)}, /* Atlantic Daylight Time */
+ {"aesst", DTZ, 66}, /* E. Australia */
+ {"aest", TZ, 60}, /* Australia Eastern Std Time */
+ {"ahst", TZ, 60}, /* Alaska-Hawaii Std Time */
+ {"allballs", RESERV, DTK_ZULU}, /* 00:00:00 */
+ {"am", AMPM, AM},
+ {"apr", MONTH, 4},
+ {"april", MONTH, 4},
+ {"ast", TZ, NEG(24)}, /* Atlantic Std Time (Canada) */
+ {"at", IGNORE, 0}, /* "at" (throwaway) */
+ {"aug", MONTH, 8},
+ {"august", MONTH, 8},
+ {"awsst", DTZ, 54}, /* W. Australia */
+ {"awst", TZ, 48}, /* W. Australia */
+ {DB_C, ADBC, BC}, /* "bc" for years < 0 */
+ {"bst", TZ, 6}, /* British Summer Time */
+ {"bt", TZ, 18}, /* Baghdad Time */
+ {"cadt", DTZ, 63}, /* Central Australian DST */
+ {"cast", TZ, 57}, /* Central Australian ST */
+ {"cat", TZ, NEG(60)}, /* Central Alaska Time */
+ {"cct", TZ, 48}, /* China Coast */
+ {"cdt", DTZ, NEG(30)}, /* Central Daylight Time */
+ {"cet", TZ, 6}, /* Central European Time */
+ {"cetdst", DTZ, 12}, /* Central European Dayl.Time */
+ {"cst", TZ, NEG(36)}, /* Central Standard Time */
+ {DCURRENT, RESERV, DTK_CURRENT}, /* "current" is always now */
+ {"dec", MONTH, 12},
+ {"december", MONTH, 12},
+ {"dnt", TZ, 6}, /* Dansk Normal Tid */
+ {"dow", RESERV, DTK_DOW}, /* day of week */
+ {"doy", RESERV, DTK_DOY}, /* day of year */
+ {"dst", DTZMOD, 6},
+ {"east", TZ, NEG(60)}, /* East Australian Std Time */
+ {"edt", DTZ, NEG(24)}, /* Eastern Daylight Time */
+ {"eet", TZ, 12}, /* East. Europe, USSR Zone 1 */
+ {"eetdst", DTZ, 18}, /* Eastern Europe */
+ {EPOCH, RESERV, DTK_EPOCH}, /* "epoch" reserved for system epoch time */
#if USE_AUSTRALIAN_RULES
- {"est", TZ, 60}, /* Australia Eastern Std Time */
+ {"est", TZ, 60}, /* Australia Eastern Std Time */
#else
- {"est", TZ, NEG(30)}, /* Eastern Standard Time */
+ {"est", TZ, NEG(30)}, /* Eastern Standard Time */
#endif
- {"feb", MONTH, 2},
- {"february", MONTH, 2},
- {"fri", DOW, 5},
- {"friday", DOW, 5},
- {"fst", TZ, 6}, /* French Summer Time */
- {"fwt", DTZ, 12}, /* French Winter Time */
- {"gmt", TZ, 0}, /* Greenwish Mean Time */
- {"gst", TZ, 60}, /* Guam Std Time, USSR Zone 9 */
- {"hdt", DTZ, NEG(54)}, /* Hawaii/Alaska */
- {"hmt", DTZ, 18}, /* Hellas ? ? */
- {"hst", TZ, NEG(60)}, /* Hawaii Std Time */
- {"idle", TZ, 72}, /* Intl. Date Line, East */
- {"idlw", TZ, NEG(72)}, /* Intl. Date Line,, est */
- {LATE, RESERV, DTK_LATE}, /* "infinity" reserved for "late time" */
- {INVALID, RESERV, DTK_INVALID}, /* "invalid" reserved for invalid time */
- {"ist", TZ, 12}, /* Israel */
- {"it", TZ, 22}, /* Iran Time */
- {"jan", MONTH, 1},
- {"january", MONTH, 1},
- {"jst", TZ, 54}, /* Japan Std Time,USSR Zone 8 */
- {"jt", TZ, 45}, /* Java Time */
- {"jul", MONTH, 7},
- {"july", MONTH, 7},
- {"jun", MONTH, 6},
- {"june", MONTH, 6},
- {"kst", TZ, 54}, /* Korea Standard Time */
- {"ligt", TZ, 60}, /* From Melbourne, Australia */
- {"mar", MONTH, 3},
- {"march", MONTH, 3},
- {"may", MONTH, 5},
- {"mdt", DTZ, NEG(36)}, /* Mountain Daylight Time */
- {"mest", DTZ, 12}, /* Middle Europe Summer Time */
- {"met", TZ, 6}, /* Middle Europe Time */
- {"metdst", DTZ, 12}, /* Middle Europe Daylight Time */
- {"mewt", TZ, 6}, /* Middle Europe Winter Time */
- {"mez", TZ, 6}, /* Middle Europe Zone */
- {"mon", DOW, 1},
- {"monday", DOW, 1},
- {"mst", TZ, NEG(42)}, /* Mountain Standard Time */
- {"mt", TZ, 51}, /* Moluccas Time */
- {"ndt", DTZ, NEG(15)}, /* Nfld. Daylight Time */
- {"nft", TZ, NEG(21)}, /* Newfoundland Standard Time */
- {"nor", TZ, 6}, /* Norway Standard Time */
- {"nov", MONTH, 11},
- {"november", MONTH, 11},
- {NOW, RESERV, DTK_NOW}, /* current transaction time */
- {"nst", TZ, NEG(21)}, /* Nfld. Standard Time */
- {"nt", TZ, NEG(66)}, /* Nome Time */
- {"nzdt", DTZ, 78}, /* New Zealand Daylight Time */
- {"nzst", TZ, 72}, /* New Zealand Standard Time */
- {"nzt", TZ, 72}, /* New Zealand Time */
- {"oct", MONTH, 10},
- {"october", MONTH, 10},
- {"on", IGNORE, 0}, /* "on" (throwaway) */
- {"pdt", DTZ, NEG(42)}, /* Pacific Daylight Time */
- {"pm", AMPM, PM},
- {"pst", TZ, NEG(48)}, /* Pacific Standard Time */
- {"sadt", DTZ, 63}, /* S. Australian Dayl. Time */
- {"sast", TZ, 57}, /* South Australian Std Time */
- {"sat", DOW, 6},
- {"saturday", DOW, 6},
- {"sep", MONTH, 9},
- {"sept", MONTH, 9},
- {"september", MONTH, 9},
- {"set", TZ, NEG(6)}, /* Seychelles Time ?? */
- {"sst", DTZ, 12}, /* Swedish Summer Time */
- {"sun", DOW, 0},
- {"sunday", DOW, 0},
- {"swt", TZ, 6}, /* Swedish Winter Time */
- {"thu", DOW, 4},
- {"thur", DOW, 4},
- {"thurs", DOW, 4},
- {"thursday", DOW, 4},
- {TODAY, RESERV, DTK_TODAY}, /* midnight */
- {TOMORROW, RESERV, DTK_TOMORROW}, /* tomorrow midnight */
- {"tue", DOW, 2},
- {"tues", DOW, 2},
- {"tuesday", DOW, 2},
- {"undefined", RESERV, DTK_INVALID}, /* "undefined" pre-v6.1 invalid time */
- {"ut", TZ, 0},
- {"utc", TZ, 0},
- {"wadt", DTZ, 48}, /* West Australian DST */
- {"wast", TZ, 42}, /* West Australian Std Time */
- {"wat", TZ, NEG(6)}, /* West Africa Time */
- {"wdt", DTZ, 54}, /* West Australian DST */
- {"wed", DOW, 3},
- {"wednesday", DOW, 3},
- {"weds", DOW, 3},
- {"wet", TZ, 0}, /* Western Europe */
- {"wetdst", DTZ, 6}, /* Western Europe */
- {"wst", TZ, 48}, /* West Australian Std Time */
- {"ydt", DTZ, NEG(48)}, /* Yukon Daylight Time */
- {YESTERDAY, RESERV, DTK_YESTERDAY}, /* yesterday midnight */
- {"yst", TZ, NEG(54)}, /* Yukon Standard Time */
- {"zp4", TZ, NEG(24)}, /* GMT +4 hours. */
- {"zp5", TZ, NEG(30)}, /* GMT +5 hours. */
- {"zp6", TZ, NEG(36)}, /* GMT +6 hours. */
- {"z", RESERV, DTK_ZULU}, /* 00:00:00 */
- {ZULU, RESERV, DTK_ZULU}, /* 00:00:00 */
+ {"feb", MONTH, 2},
+ {"february", MONTH, 2},
+ {"fri", DOW, 5},
+ {"friday", DOW, 5},
+ {"fst", TZ, 6}, /* French Summer Time */
+ {"fwt", DTZ, 12}, /* French Winter Time */
+ {"gmt", TZ, 0}, /* Greenwish Mean Time */
+ {"gst", TZ, 60}, /* Guam Std Time, USSR Zone 9 */
+ {"hdt", DTZ, NEG(54)}, /* Hawaii/Alaska */
+ {"hmt", DTZ, 18}, /* Hellas ? ? */
+ {"hst", TZ, NEG(60)}, /* Hawaii Std Time */
+ {"idle", TZ, 72}, /* Intl. Date Line, East */
+ {"idlw", TZ, NEG(72)}, /* Intl. Date Line,, est */
+ {LATE, RESERV, DTK_LATE}, /* "infinity" reserved for "late time" */
+ {INVALID, RESERV, DTK_INVALID}, /* "invalid" reserved for invalid
+ * time */
+ {"ist", TZ, 12}, /* Israel */
+ {"it", TZ, 22}, /* Iran Time */
+ {"jan", MONTH, 1},
+ {"january", MONTH, 1},
+ {"jst", TZ, 54}, /* Japan Std Time,USSR Zone 8 */
+ {"jt", TZ, 45}, /* Java Time */
+ {"jul", MONTH, 7},
+ {"july", MONTH, 7},
+ {"jun", MONTH, 6},
+ {"june", MONTH, 6},
+ {"kst", TZ, 54}, /* Korea Standard Time */
+ {"ligt", TZ, 60}, /* From Melbourne, Australia */
+ {"mar", MONTH, 3},
+ {"march", MONTH, 3},
+ {"may", MONTH, 5},
+ {"mdt", DTZ, NEG(36)}, /* Mountain Daylight Time */
+ {"mest", DTZ, 12}, /* Middle Europe Summer Time */
+ {"met", TZ, 6}, /* Middle Europe Time */
+ {"metdst", DTZ, 12}, /* Middle Europe Daylight Time */
+ {"mewt", TZ, 6}, /* Middle Europe Winter Time */
+ {"mez", TZ, 6}, /* Middle Europe Zone */
+ {"mon", DOW, 1},
+ {"monday", DOW, 1},
+ {"mst", TZ, NEG(42)}, /* Mountain Standard Time */
+ {"mt", TZ, 51}, /* Moluccas Time */
+ {"ndt", DTZ, NEG(15)}, /* Nfld. Daylight Time */
+ {"nft", TZ, NEG(21)}, /* Newfoundland Standard Time */
+ {"nor", TZ, 6}, /* Norway Standard Time */
+ {"nov", MONTH, 11},
+ {"november", MONTH, 11},
+ {NOW, RESERV, DTK_NOW}, /* current transaction time */
+ {"nst", TZ, NEG(21)}, /* Nfld. Standard Time */
+ {"nt", TZ, NEG(66)}, /* Nome Time */
+ {"nzdt", DTZ, 78}, /* New Zealand Daylight Time */
+ {"nzst", TZ, 72}, /* New Zealand Standard Time */
+ {"nzt", TZ, 72}, /* New Zealand Time */
+ {"oct", MONTH, 10},
+ {"october", MONTH, 10},
+ {"on", IGNORE, 0}, /* "on" (throwaway) */
+ {"pdt", DTZ, NEG(42)}, /* Pacific Daylight Time */
+ {"pm", AMPM, PM},
+ {"pst", TZ, NEG(48)}, /* Pacific Standard Time */
+ {"sadt", DTZ, 63}, /* S. Australian Dayl. Time */
+ {"sast", TZ, 57}, /* South Australian Std Time */
+ {"sat", DOW, 6},
+ {"saturday", DOW, 6},
+ {"sep", MONTH, 9},
+ {"sept", MONTH, 9},
+ {"september", MONTH, 9},
+ {"set", TZ, NEG(6)}, /* Seychelles Time ?? */
+ {"sst", DTZ, 12}, /* Swedish Summer Time */
+ {"sun", DOW, 0},
+ {"sunday", DOW, 0},
+ {"swt", TZ, 6}, /* Swedish Winter Time */
+ {"thu", DOW, 4},
+ {"thur", DOW, 4},
+ {"thurs", DOW, 4},
+ {"thursday", DOW, 4},
+ {TODAY, RESERV, DTK_TODAY}, /* midnight */
+ {TOMORROW, RESERV, DTK_TOMORROW}, /* tomorrow midnight */
+ {"tue", DOW, 2},
+ {"tues", DOW, 2},
+ {"tuesday", DOW, 2},
+ {"undefined", RESERV, DTK_INVALID}, /* "undefined" pre-v6.1 invalid
+ * time */
+ {"ut", TZ, 0},
+ {"utc", TZ, 0},
+ {"wadt", DTZ, 48}, /* West Australian DST */
+ {"wast", TZ, 42}, /* West Australian Std Time */
+ {"wat", TZ, NEG(6)}, /* West Africa Time */
+ {"wdt", DTZ, 54}, /* West Australian DST */
+ {"wed", DOW, 3},
+ {"wednesday", DOW, 3},
+ {"weds", DOW, 3},
+ {"wet", TZ, 0}, /* Western Europe */
+ {"wetdst", DTZ, 6}, /* Western Europe */
+ {"wst", TZ, 48}, /* West Australian Std Time */
+ {"ydt", DTZ, NEG(48)}, /* Yukon Daylight Time */
+ {YESTERDAY, RESERV, DTK_YESTERDAY}, /* yesterday midnight */
+ {"yst", TZ, NEG(54)}, /* Yukon Standard Time */
+ {"zp4", TZ, NEG(24)}, /* GMT +4 hours. */
+ {"zp5", TZ, NEG(30)}, /* GMT +5 hours. */
+ {"zp6", TZ, NEG(36)}, /* GMT +6 hours. */
+ {"z", RESERV, DTK_ZULU}, /* 00:00:00 */
+ {ZULU, RESERV, DTK_ZULU}, /* 00:00:00 */
};
static unsigned int szdatetktbl = sizeof datetktbl / sizeof datetktbl[0];
static datetkn deltatktbl[] = {
/* text token lexval */
- {"@", IGNORE, 0}, /* postgres relative time prefix */
- {DAGO, AGO, 0}, /* "ago" indicates negative time offset */
- {"c", UNITS, DTK_CENTURY}, /* "century" relative time units */
- {"cent", UNITS, DTK_CENTURY}, /* "century" relative time units */
- {"centuries", UNITS, DTK_CENTURY}, /* "centuries" relative time units */
- {DCENTURY, UNITS, DTK_CENTURY}, /* "century" relative time units */
- {"d", UNITS, DTK_DAY}, /* "day" relative time units */
- {DDAY, UNITS, DTK_DAY}, /* "day" relative time units */
- {"days", UNITS, DTK_DAY}, /* "days" relative time units */
- {"dec", UNITS, DTK_DECADE}, /* "decade" relative time units */
- {"decs", UNITS, DTK_DECADE}, /* "decades" relative time units */
- {DDECADE, UNITS, DTK_DECADE}, /* "decade" relative time units */
- {"decades", UNITS, DTK_DECADE}, /* "decades" relative time units */
- {"h", UNITS, DTK_HOUR}, /* "hour" relative time units */
- {DHOUR, UNITS, DTK_HOUR}, /* "hour" relative time units */
- {"hours", UNITS, DTK_HOUR}, /* "hours" relative time units */
- {"hr", UNITS, DTK_HOUR}, /* "hour" relative time units */
- {"hrs", UNITS, DTK_HOUR}, /* "hours" relative time units */
- {INVALID, RESERV, DTK_INVALID}, /* "invalid" reserved for invalid time */
- {"m", UNITS, DTK_MINUTE}, /* "minute" relative time units */
- {"microsecon", UNITS, DTK_MILLISEC}, /* "microsecond" relative time units */
- {"mil", UNITS, DTK_MILLENIUM}, /* "millenium" relative time units */
- {"mils", UNITS, DTK_MILLENIUM}, /* "millenia" relative time units */
- {"millenia", UNITS, DTK_MILLENIUM}, /* "millenia" relative time units */
- {DMILLENIUM, UNITS, DTK_MILLENIUM}, /* "millenium" relative time units */
- {"millisecon", UNITS, DTK_MILLISEC}, /* "millisecond" relative time units */
- {"min", UNITS, DTK_MINUTE}, /* "minute" relative time units */
- {"mins", UNITS, DTK_MINUTE}, /* "minutes" relative time units */
- {"mins", UNITS, DTK_MINUTE}, /* "minutes" relative time units */
- {DMINUTE, UNITS, DTK_MINUTE}, /* "minute" relative time units */
- {"minutes", UNITS, DTK_MINUTE}, /* "minutes" relative time units */
- {"mon", UNITS, DTK_MONTH}, /* "months" relative time units */
- {"mons", UNITS, DTK_MONTH}, /* "months" relative time units */
- {DMONTH, UNITS, DTK_MONTH}, /* "month" relative time units */
- {"months", UNITS, DTK_MONTH}, /* "months" relative time units */
- {"ms", UNITS, DTK_MILLISEC}, /* "millisecond" relative time units */
- {"msec", UNITS, DTK_MILLISEC}, /* "millisecond" relative time units */
- {DMILLISEC, UNITS, DTK_MILLISEC}, /* "millisecond" relative time units */
- {"mseconds", UNITS, DTK_MILLISEC}, /* "milliseconds" relative time units */
- {"msecs", UNITS, DTK_MILLISEC}, /* "milliseconds" relative time units */
- {"qtr", UNITS, DTK_QUARTER}, /* "quarter" relative time units */
- {DQUARTER, UNITS, DTK_QUARTER}, /* "quarter" relative time units */
- {"reltime", IGNORE, 0}, /* "reltime" for pre-v6.1 "Undefined Reltime" */
- {"s", UNITS, DTK_SECOND}, /* "second" relative time units */
- {"sec", UNITS, DTK_SECOND}, /* "second" relative time units */
- {DSECOND, UNITS, DTK_SECOND}, /* "second" relative time units */
- {"seconds", UNITS, DTK_SECOND}, /* "seconds" relative time units */
- {"secs", UNITS, DTK_SECOND}, /* "seconds" relative time units */
- {DTIMEZONE, UNITS, DTK_TZ}, /* "timezone" time offset */
- {"tz", UNITS, DTK_TZ}, /* "timezone" time offset */
- {"undefined", RESERV, DTK_INVALID}, /* "undefined" pre-v6.1 invalid time */
- {"us", UNITS, DTK_MICROSEC}, /* "microsecond" relative time units */
- {"usec", UNITS, DTK_MICROSEC}, /* "microsecond" relative time units */
- {DMICROSEC, UNITS, DTK_MICROSEC}, /* "microsecond" relative time units */
- {"useconds", UNITS, DTK_MICROSEC}, /* "microseconds" relative time units */
- {"usecs", UNITS, DTK_MICROSEC}, /* "microseconds" relative time units */
- {"w", UNITS, DTK_WEEK}, /* "week" relative time units */
- {DWEEK, UNITS, DTK_WEEK}, /* "week" relative time units */
- {"weeks", UNITS, DTK_WEEK}, /* "weeks" relative time units */
- {"y", UNITS, DTK_YEAR}, /* "year" relative time units */
- {DYEAR, UNITS, DTK_YEAR}, /* "year" relative time units */
- {"years", UNITS, DTK_YEAR}, /* "years" relative time units */
- {"yr", UNITS, DTK_YEAR}, /* "year" relative time units */
- {"yrs", UNITS, DTK_YEAR}, /* "years" relative time units */
+ {"@", IGNORE, 0}, /* postgres relative time prefix */
+ {DAGO, AGO, 0}, /* "ago" indicates negative time offset */
+ {"c", UNITS, DTK_CENTURY}, /* "century" relative time units */
+ {"cent", UNITS, DTK_CENTURY}, /* "century" relative time units */
+ {"centuries", UNITS, DTK_CENTURY}, /* "centuries" relative time units */
+ {DCENTURY, UNITS, DTK_CENTURY}, /* "century" relative time units */
+ {"d", UNITS, DTK_DAY}, /* "day" relative time units */
+ {DDAY, UNITS, DTK_DAY}, /* "day" relative time units */
+ {"days", UNITS, DTK_DAY}, /* "days" relative time units */
+ {"dec", UNITS, DTK_DECADE}, /* "decade" relative time units */
+ {"decs", UNITS, DTK_DECADE},/* "decades" relative time units */
+ {DDECADE, UNITS, DTK_DECADE}, /* "decade" relative time units */
+ {"decades", UNITS, DTK_DECADE}, /* "decades" relative time units */
+ {"h", UNITS, DTK_HOUR}, /* "hour" relative time units */
+ {DHOUR, UNITS, DTK_HOUR}, /* "hour" relative time units */
+ {"hours", UNITS, DTK_HOUR}, /* "hours" relative time units */
+ {"hr", UNITS, DTK_HOUR}, /* "hour" relative time units */
+ {"hrs", UNITS, DTK_HOUR}, /* "hours" relative time units */
+ {INVALID, RESERV, DTK_INVALID}, /* "invalid" reserved for invalid
+ * time */
+ {"m", UNITS, DTK_MINUTE}, /* "minute" relative time units */
+ {"microsecon", UNITS, DTK_MILLISEC}, /* "microsecond" relative
+ * time units */
+ {"mil", UNITS, DTK_MILLENIUM}, /* "millenium" relative time units */
+ {"mils", UNITS, DTK_MILLENIUM}, /* "millenia" relative time units */
+ {"millenia", UNITS, DTK_MILLENIUM}, /* "millenia" relative time units */
+ {DMILLENIUM, UNITS, DTK_MILLENIUM}, /* "millenium" relative time units */
+ {"millisecon", UNITS, DTK_MILLISEC}, /* "millisecond" relative
+ * time units */
+ {"min", UNITS, DTK_MINUTE}, /* "minute" relative time units */
+ {"mins", UNITS, DTK_MINUTE},/* "minutes" relative time units */
+ {"mins", UNITS, DTK_MINUTE},/* "minutes" relative time units */
+ {DMINUTE, UNITS, DTK_MINUTE}, /* "minute" relative time units */
+ {"minutes", UNITS, DTK_MINUTE}, /* "minutes" relative time units */
+ {"mon", UNITS, DTK_MONTH}, /* "months" relative time units */
+ {"mons", UNITS, DTK_MONTH}, /* "months" relative time units */
+ {DMONTH, UNITS, DTK_MONTH}, /* "month" relative time units */
+ {"months", UNITS, DTK_MONTH}, /* "months" relative time units */
+ {"ms", UNITS, DTK_MILLISEC},/* "millisecond" relative time units */
+ {"msec", UNITS, DTK_MILLISEC}, /* "millisecond" relative time
+ * units */
+ {DMILLISEC, UNITS, DTK_MILLISEC}, /* "millisecond" relative time
+ * units */
+ {"mseconds", UNITS, DTK_MILLISEC}, /* "milliseconds" relative time
+ * units */
+ {"msecs", UNITS, DTK_MILLISEC}, /* "milliseconds" relative time
+ * units */
+ {"qtr", UNITS, DTK_QUARTER},/* "quarter" relative time units */
+ {DQUARTER, UNITS, DTK_QUARTER}, /* "quarter" relative time units */
+ {"reltime", IGNORE, 0}, /* "reltime" for pre-v6.1 "Undefined
+ * Reltime" */
+ {"s", UNITS, DTK_SECOND}, /* "second" relative time units */
+ {"sec", UNITS, DTK_SECOND}, /* "second" relative time units */
+ {DSECOND, UNITS, DTK_SECOND}, /* "second" relative time units */
+ {"seconds", UNITS, DTK_SECOND}, /* "seconds" relative time units */
+ {"secs", UNITS, DTK_SECOND},/* "seconds" relative time units */
+ {DTIMEZONE, UNITS, DTK_TZ}, /* "timezone" time offset */
+ {"tz", UNITS, DTK_TZ}, /* "timezone" time offset */
+ {"undefined", RESERV, DTK_INVALID}, /* "undefined" pre-v6.1 invalid
+ * time */
+ {"us", UNITS, DTK_MICROSEC},/* "microsecond" relative time units */
+ {"usec", UNITS, DTK_MICROSEC}, /* "microsecond" relative time
+ * units */
+ {DMICROSEC, UNITS, DTK_MICROSEC}, /* "microsecond" relative time
+ * units */
+ {"useconds", UNITS, DTK_MICROSEC}, /* "microseconds" relative time
+ * units */
+ {"usecs", UNITS, DTK_MICROSEC}, /* "microseconds" relative time
+ * units */
+ {"w", UNITS, DTK_WEEK}, /* "week" relative time units */
+ {DWEEK, UNITS, DTK_WEEK}, /* "week" relative time units */
+ {"weeks", UNITS, DTK_WEEK}, /* "weeks" relative time units */
+ {"y", UNITS, DTK_YEAR}, /* "year" relative time units */
+ {DYEAR, UNITS, DTK_YEAR}, /* "year" relative time units */
+ {"years", UNITS, DTK_YEAR}, /* "years" relative time units */
+ {"yr", UNITS, DTK_YEAR}, /* "year" relative time units */
+ {"yrs", UNITS, DTK_YEAR}, /* "years" relative time units */
};
static unsigned int szdeltatktbl = sizeof deltatktbl / sizeof deltatktbl[0];
return ((1461 * (y + 4800 + m12)) / 4 + (367 * (m - 2 - 12 * (m12))) / 12
- (3 * ((y + 4900 + m12) / 100)) / 4 + d - 32075);
-} /* date2j() */
+} /* date2j() */
void
j2date(int jd, int *year, int *month, int *day)
*month = m;
*day = d;
return;
-} /* j2date() */
+} /* j2date() */
static int
j2day(int date)
day = (date + 1) % 7;
return (day);
-} /* j2day() */
+} /* j2day() */
/* datetime2tm()
#endif
return 0;
-} /* datetime2tm() */
+} /* datetime2tm() */
/* tm2datetime()
*result = dt2local(*result, -(*tzp));
return 0;
-} /* tm2datetime() */
+} /* tm2datetime() */
/* timespan2tm()
#endif
return 0;
-} /* timespan2tm() */
+} /* timespan2tm() */
int
tm2timespan(struct tm * tm, double fsec, TimeSpan *span)
#endif
return 0;
-} /* tm2timespan() */
+} /* tm2timespan() */
static DateTime
dt -= tz;
dt = JROUND(dt);
return (dt);
-} /* dt2local() */
+} /* dt2local() */
double
time2t(const int hour, const int min, const double sec)
{
return ((((hour * 60) + min) * 60) + sec);
-} /* time2t() */
+} /* time2t() */
static void
dt2time(DateTime jd, int *hour, int *min, double *sec)
*sec = JROUND(time);
return;
-} /* dt2time() */
+} /* dt2time() */
/*
*lp++ = tolower(*cp++);
}
- /* otherwise, number only and will determine year, month, or day later */
+
+ /*
+ * otherwise, number only and will determine year, month, or
+ * day later
+ */
else
{
ftype[nf] = DTK_NUMBER;
}
}
- /* text? then date string, month, day of week, special, or timezone */
+
+ /*
+ * text? then date string, month, day of week, special, or
+ * timezone
+ */
else if (isalpha(*cp))
{
ftype[nf] = DTK_STRING;
*numfields = nf;
return 0;
-} /* ParseDateTime() */
+} /* ParseDateTime() */
/* DecodeDateTime()
}
return 0;
-} /* DecodeDateTime() */
+} /* DecodeDateTime() */
/* DecodeTimeOnly()
tm->tm_hour = 0;
tm->tm_min = 0;
tm->tm_sec = 0;
- tm->tm_isdst = -1; /* don't know daylight savings time status apriori */
+ tm->tm_isdst = -1; /* don't know daylight savings time status
+ * apriori */
*fsec = 0;
fmask = DTK_DATE_M;
return -1;
return 0;
-} /* DecodeTimeOnly() */
+} /* DecodeTimeOnly() */
/* DecodeDate()
}
return 0;
-} /* DecodeDate() */
+} /* DecodeDate() */
/* DecodeTime()
return -1;
return 0;
-} /* DecodeTime() */
+} /* DecodeTime() */
/* DecodeNumber()
}
return 0;
-} /* DecodeNumber() */
+} /* DecodeNumber() */
/* DecodeNumberField()
}
return 0;
-} /* DecodeNumberField() */
+} /* DecodeNumberField() */
/* DecodeTimezone()
*tzp = -tz;
return (*cp != '\0');
-} /* DecodeTimezone() */
+} /* DecodeTimezone() */
/* DecodeSpecial()
}
return (type);
-} /* DecodeSpecial() */
+} /* DecodeSpecial() */
/* DecodeDateDelta()
* Return 0 if decoded and -1 if problems.
*
* Allow "date" field DTK_DATE since this could be just
- * an unsigned floating point number. - thomas 1997-11-16
+ * an unsigned floating point number. - thomas 1997-11-16
*
* If code is changed to read fields from first to last,
* then use READ_FORWARD-bracketed code to allow sign
#if READ_FORWARD
int is_neg = FALSE;
+
#endif
char *cp;
}
/*
- * read through remaining list backwards to pick up units before values
+ * read through remaining list backwards to pick up units before
+ * values
*/
for (i = nf - 1; i >= ii; i--)
{
break;
case DTK_MILLISEC:
- *fsec += ((val +fval) * 1e-3);
+ *fsec += ((val + fval) * 1e-3);
break;
case DTK_SECOND:
case DTK_WEEK:
tm->tm_mday += val * 7;
if (fval != 0)
- tm->tm_sec += (fval * (7*86400));
+ tm->tm_sec += (fval * (7 * 86400));
tmask = ((fmask & DTK_M(DAY)) ? 0 : DTK_M(DAY));
break;
case DTK_MONTH:
tm->tm_mon += val;
if (fval != 0)
- tm->tm_sec += (fval * (30*86400));
+ tm->tm_sec += (fval * (30 * 86400));
tmask = DTK_M(MONTH);
break;
/* ensure that at least one time field has been found */
return ((fmask != 0) ? 0 : -1);
-} /* DecodeDateDelta() */
+} /* DecodeDateDelta() */
/* DecodeUnits()
}
return (type);
-} /* DecodeUnits() */
+} /* DecodeUnits() */
/* datebsearch()
static datetkn *
datebsearch(char *key, datetkn *base, unsigned int nel)
{
- datetkn *last = base + nel - 1,
+ datetkn *last = base + nel - 1,
*position;
- int result;
+ int result;
while (last >= base)
{
}
return (FALSE);
-} /* EncodeSpecialDateTime() */
+} /* EncodeSpecialDateTime() */
/* EncodeDateOnly()
switch (style)
{
- /* compatible with ISO date formats */
+ /* compatible with ISO date formats */
case USE_ISO_DATES:
if (tm->tm_year > 0)
sprintf(str, "%04d-%02d-%02d",
- tm->tm_year, tm->tm_mon, tm->tm_mday);
+ tm->tm_year, tm->tm_mon, tm->tm_mday);
else
sprintf(str, "%04d-%02d-%02d %s",
- -(tm->tm_year - 1), tm->tm_mon, tm->tm_mday, "BC");
+ -(tm->tm_year - 1), tm->tm_mon, tm->tm_mday, "BC");
break;
- /* compatible with Oracle/Ingres date formats */
+ /* compatible with Oracle/Ingres date formats */
case USE_SQL_DATES:
if (EuroDates)
sprintf(str, "%02d/%02d", tm->tm_mday, tm->tm_mon);
sprintf((str + 5), "/%04d %s", -(tm->tm_year - 1), "BC");
break;
- /* German-style date format */
+ /* German-style date format */
case USE_GERMAN_DATES:
sprintf(str, "%02d.%02d", tm->tm_mday, tm->tm_mon);
if (tm->tm_year > 0)
sprintf((str + 5), ".%04d %s", -(tm->tm_year - 1), "BC");
break;
- /* traditional date-only style for Postgres */
+ /* traditional date-only style for Postgres */
case USE_POSTGRES_DATES:
default:
if (EuroDates)
#endif
return (TRUE);
-} /* EncodeDateOnly() */
+} /* EncodeDateOnly() */
/* EncodeTimeOnly()
#endif
return (TRUE);
-} /* EncodeTimeOnly() */
+} /* EncodeTimeOnly() */
/* EncodeDateTime()
* Encode date and time interpreted as local time.
* Support several date styles:
- * Postgres - day mon hh:mm:ss yyyy tz
- * SQL - mm/dd/yyyy hh:mm:ss.ss tz
- * ISO - yyyy-mm-dd hh:mm:ss+/-tz
- * German - dd.mm/yyyy hh:mm:ss tz
+ * Postgres - day mon hh:mm:ss yyyy tz
+ * SQL - mm/dd/yyyy hh:mm:ss.ss tz
+ * ISO - yyyy-mm-dd hh:mm:ss+/-tz
+ * German - dd.mm/yyyy hh:mm:ss tz
* Variants (affects order of month and day for Postgres and SQL styles):
- * US - mm/dd/yyyy
- * European - dd/mm/yyyy
+ * US - mm/dd/yyyy
+ * European - dd/mm/yyyy
*/
int
EncodeDateTime(struct tm * tm, double fsec, int *tzp, char **tzn, int style, char *str)
switch (style)
{
- /* compatible with ISO date formats */
+ /* compatible with ISO date formats */
case USE_ISO_DATES:
if (tm->tm_year > 0)
{
sprintf(str, "%04d-%02d-%02d %02d:%02d:",
- tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min);
+ tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min);
sprintf((str + 17), ((fsec != 0) ? "%05.2f" : "%02.0f"), sec);
if ((*tzn != NULL) && (tm->tm_isdst >= 0))
{
if (tm->tm_hour || tm->tm_min)
sprintf(str, "%04d-%02d-%02d %02d:%02d %s",
- -(tm->tm_year - 1), tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, "BC");
+ -(tm->tm_year - 1), tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, "BC");
else
sprintf(str, "%04d-%02d-%02d %s",
- -(tm->tm_year - 1), tm->tm_mon, tm->tm_mday, "BC");
+ -(tm->tm_year - 1), tm->tm_mon, tm->tm_mday, "BC");
}
break;
- /* compatible with Oracle/Ingres date formats */
+ /* compatible with Oracle/Ingres date formats */
case USE_SQL_DATES:
if (EuroDates)
sprintf(str, "%02d/%02d", tm->tm_mday, tm->tm_mon);
if (tm->tm_year > 0)
{
sprintf((str + 5), "/%04d %02d:%02d:%05.2f",
- tm->tm_year, tm->tm_hour, tm->tm_min, sec);
+ tm->tm_year, tm->tm_hour, tm->tm_min, sec);
if ((*tzn != NULL) && (tm->tm_isdst >= 0))
{
}
else
sprintf((str + 5), "/%04d %02d:%02d %s",
- -(tm->tm_year - 1), tm->tm_hour, tm->tm_min, "BC");
+ -(tm->tm_year - 1), tm->tm_hour, tm->tm_min, "BC");
break;
- /* German variant on European style */
+ /* German variant on European style */
case USE_GERMAN_DATES:
sprintf(str, "%02d.%02d", tm->tm_mday, tm->tm_mon);
if (tm->tm_year > 0)
{
sprintf((str + 5), ".%04d %02d:%02d:%05.2f",
- tm->tm_year, tm->tm_hour, tm->tm_min, sec);
+ tm->tm_year, tm->tm_hour, tm->tm_min, sec);
if ((*tzn != NULL) && (tm->tm_isdst >= 0))
{
}
else
sprintf((str + 5), ".%04d %02d:%02d %s",
- -(tm->tm_year - 1), tm->tm_hour, tm->tm_min, "BC");
+ -(tm->tm_year - 1), tm->tm_hour, tm->tm_min, "BC");
break;
- /* backward-compatible with traditional Postgres abstime dates */
+ /* backward-compatible with traditional Postgres abstime dates */
case USE_POSTGRES_DATES:
default:
day = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday);
else
{
sprintf((str + 10), " %02d:%02d %04d %s",
- tm->tm_hour, tm->tm_min, -(tm->tm_year - 1), "BC");
+ tm->tm_hour, tm->tm_min, -(tm->tm_year - 1), "BC");
}
break;
}
#endif
return (TRUE);
-} /* EncodeDateTime() */
+} /* EncodeDateTime() */
/* EncodeTimeSpan()
switch (style)
{
- /* compatible with ISO date formats */
+ /* compatible with ISO date formats */
case USE_ISO_DATES:
- break;
+ break;
default:
strcpy(cp, "@");
switch (style)
{
- /* compatible with ISO date formats */
+ /* compatible with ISO date formats */
case USE_ISO_DATES:
if ((tm->tm_hour != 0) || (tm->tm_min != 0))
is_nonzero = TRUE;
#endif
return 0;
-} /* EncodeTimeSpan() */
+} /* EncodeTimeSpan() */
#if defined(linux) && defined(PPC)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/filename.c,v 1.13 1998/01/05 16:39:57 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/filename.c,v 1.14 1998/02/26 04:37:03 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include
#include "utils/builtins.h" /* where function declarations go */
-char *
+char *
filename_in(char *file)
{
char *str;
else
{
len = (p - file) - 1;
- StrNCpy(name, file + 1, len+1);
+ StrNCpy(name, file + 1, len + 1);
}
/* printf("name: %s\n"); */
if ((pw = getpwnam(name)) == NULL)
else
{
len = (p - file) - 1;
- StrNCpy(environment, file + 1, len+1);
+ StrNCpy(environment, file + 1, len + 1);
}
envirp = getenv(environment);
if (envirp)
return (str);
}
-char *
+char *
filename_out(char *s)
{
char *ret;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/float.c,v 1.28 1998/02/02 00:03:54 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/float.c,v 1.29 1998/02/26 04:37:07 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* float4out - converts a float4 number to a string
* using a standard output format
*/
-char *
+char *
float4out(float32 num)
{
char *ascii = (char *) palloc(MAXFLOATWIDTH + 1);
* float8out - converts float8 number to a string
* using a standard output format
*/
-char *
+char *
float8out(float64 num)
{
char *ascii = (char *) palloc(MAXDOUBLEWIDTH + 1);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.30 1998/02/03 15:55:58 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.31 1998/02/26 04:37:08 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*s = cp;
return (TRUE);
-} /* single_decode() */
+} /* single_decode() */
static int
single_encode(float8 x, char *str)
{
sprintf(str, "%.*g", digits8, x);
return (TRUE);
-} /* single_encode() */
+} /* single_encode() */
static int
pair_decode(char *str, float8 *x, float8 *y, char **s)
*ss = s;
return (TRUE);
-} /* path_decode() */
+} /* path_decode() */
static char *
path_encode(bool closed, int npts, Point *pt)
*cp = '\0';
return (result);
-} /* path_encode() */
+} /* path_encode() */
/*-------------------------------------------------------------
* pair_count - count the number of points
}
return (box);
-} /* box_in() */
+} /* box_in() */
/* box_out - convert a box to external form.
*/
return (NULL);
return (path_encode(-1, 2, (Point *) &(box->high)));
-} /* box_out() */
+} /* box_out() */
/* box_construct - fill in a new box.
*result = box->high.x - box->low.x;
return (result);
-} /* box_width() */
+} /* box_width() */
/* box_height - returns the height of the box
#endif
return (result);
-} /* line_construct_pm() */
+} /* line_construct_pm() */
static LINE * /* two points */
#endif
}
return (result);
-} /* line_construct_pp() */
+} /* line_construct_pp() */
/*----------------------------------------------------------
}
return (FPeq(l2->A, l1->A * (l2->B / l1->B)));
-} /* line_parallel() */
+} /* line_parallel() */
#ifdef NOT_USED
bool
}
return (FPeq(((l1->A * l2->B) / (l1->B * l2->A)), -1.0));
-} /* line_perp() */
+} /* line_perp() */
#endif
return (FPeq(line->A, -1.0) && FPzero(line->B));
#endif
return (FPzero(line->B));
-} /* line_vertical() */
+} /* line_vertical() */
static bool
line_horizontal(LINE *line)
return (FPzero(line->m));
#endif
return (FPzero(line->A));
-} /* line_horizontal() */
+} /* line_horizontal() */
#ifdef NOT_USED
bool
printf("line_interpt- lines intersect at (%.*g,%.*g)\n", digits8, x, digits8, y);
#endif
return (result);
-} /* line_interpt() */
+} /* line_interpt() */
/***********************************************************************
path->closed = (!isopen);
return (path);
-} /* path_in() */
+} /* path_in() */
char *
return NULL;
return (path_encode(path->closed, path->npts, (Point *) &(path->p[0])));
-} /* path_out() */
+} /* path_out() */
/*----------------------------------------------------------
return FALSE;
return (path->closed);
-} /* path_isclosed() */
+} /* path_isclosed() */
bool
path_isopen(PATH *path)
return FALSE;
return (!path->closed);
-} /* path_isopen() */
+} /* path_isopen() */
int4
return 0;
return (path->npts);
-} /* path_npoints() */
+} /* path_npoints() */
PATH *
path_close(PATH *path)
result->closed = TRUE;
return (result);
-} /* path_close() */
+} /* path_close() */
PATH *
result->closed = FALSE;
return (result);
-} /* path_open() */
+} /* path_open() */
PATH *
memmove((char *) result, (char *) path, size);
return (result);
-} /* path_copy() */
+} /* path_copy() */
/* path_inter -
/* if we dropped through, no two segs intersected */
return (FALSE);
-} /* path_inter() */
+} /* path_inter() */
/* path_distance()
* This essentially does a cartesian product of the lsegs in the
- * two paths, and finds the min distance between any two lsegs
+ * two paths, and finds the min distance between any two lsegs
*/
double *
path_distance(PATH *p1, PATH *p2)
}
return (min);
-} /* path_distance() */
+} /* path_distance() */
/*----------------------------------------------------------
*result += point_dt(&path->p[i], &path->p[i + 1]);
return (result);
-} /* path_length() */
+} /* path_length() */
#ifdef NOT_USED
result += point_dt(&path->p[i], &path->p[i + 1]);
return (result);
-} /* path_ln() */
+} /* path_ln() */
#endif
point->y = y;
return (point);
-} /* point_in() */
+} /* point_in() */
char *
point_out(Point *pt)
return (NULL);
return (path_encode(-1, 1, pt));
-} /* point_out() */
+} /* point_out() */
static Point *
bool
point_ne(Point *pt1, Point *pt2)
{
- return (! point_eq(pt1, pt2));
+ return (!point_eq(pt1, pt2));
}
/*----------------------------------------------------------
point_dt(Point *pt1, Point *pt2)
{
#ifdef GEODEBUG
-printf("point_dt- segment (%f,%f),(%f,%f) length is %f\n",
- pt1->x, pt1->y, pt2->x, pt2->y, HYPOT(pt1->x - pt2->x, pt1->y - pt2->y));
+ printf("point_dt- segment (%f,%f),(%f,%f) length is %f\n",
+ pt1->x, pt1->y, pt2->x, pt2->y, HYPOT(pt1->x - pt2->x, pt1->y - pt2->y));
#endif
return (HYPOT(pt1->x - pt2->x, pt1->y - pt2->y));
}
#endif
return (lseg);
-} /* lseg_in() */
+} /* lseg_in() */
char *
return (NULL);
return (path_encode(FALSE, 2, (Point *) &(ls->p[0])));
-} /* lseg_out() */
+} /* lseg_out() */
/* lseg_construct -
result = point_distance(&lseg->p[0], &lseg->p[1]);
return (result);
-} /* lseg_length() */
+} /* lseg_length() */
/*----------------------------------------------------------
* Relative position routines.
#endif
return (FPeq(point_sl(&(l1->p[0]), &(l1->p[1])),
point_sl(&(l2->p[0]), &(l2->p[1]))));
-} /* lseg_parallel() */
+} /* lseg_parallel() */
/* lseg_perp()
* Determine if two line segments are perpendicular.
*
* This code did not get the correct answer for
- * '((0,0),(0,1))'::lseg ?-| '((0,0),(1,0))'::lseg
+ * '((0,0),(0,1))'::lseg ?-| '((0,0),(1,0))'::lseg
* So, modified it to check explicitly for slope of vertical line
- * returned by point_sl() and the results seem better.
+ * returned by point_sl() and the results seem better.
* - thomas 1998-01-31
*/
bool
m2 = point_sl(&(l2->p[0]), &(l2->p[1]));
#ifdef GEODEBUG
-printf("lseg_perp- slopes are %g and %g\n", m1, m2);
+ printf("lseg_perp- slopes are %g and %g\n", m1, m2);
#endif
if (FPzero(m1))
- return(FPeq(m2, DBL_MAX));
+ return (FPeq(m2, DBL_MAX));
else if (FPzero(m2))
- return(FPeq(m1, DBL_MAX));
+ return (FPeq(m1, DBL_MAX));
return (FPeq(m1 / m2, -1.0));
-} /* lseg_perp() */
+} /* lseg_perp() */
bool
lseg_vertical(LSEG *lseg)
FPeq(l1->p[1].y, l2->p[1].y) &&
FPeq(l1->p[0].x, l2->p[0].x) &&
FPeq(l1->p[1].y, l2->p[1].y));
-} /* lseg_eq() */
+} /* lseg_eq() */
bool
lseg_ne(LSEG *l1, LSEG *l2)
!FPeq(l1->p[1].y, l2->p[1].y) ||
!FPeq(l1->p[0].x, l2->p[0].x) ||
!FPeq(l1->p[1].y, l2->p[1].y));
-} /* lseg_ne() */
+} /* lseg_ne() */
bool
lseg_lt(LSEG *l1, LSEG *l2)
{
return (FPlt(point_dt(&l1->p[0], &l1->p[1]), point_dt(&l2->p[0], &l2->p[1])));
-} /* lseg_lt() */
+} /* lseg_lt() */
bool
lseg_le(LSEG *l1, LSEG *l2)
{
return (FPle(point_dt(&l1->p[0], &l1->p[1]), point_dt(&l2->p[0], &l2->p[1])));
-} /* lseg_le() */
+} /* lseg_le() */
bool
lseg_gt(LSEG *l1, LSEG *l2)
{
return (FPgt(point_dt(&l1->p[0], &l1->p[1]), point_dt(&l2->p[0], &l2->p[1])));
-} /* lseg_gt() */
+} /* lseg_gt() */
bool
lseg_ge(LSEG *l1, LSEG *l2)
{
return (FPge(point_dt(&l1->p[0], &l1->p[1]), point_dt(&l2->p[0], &l2->p[1])));
-} /* lseg_ge() */
+} /* lseg_ge() */
/*----------------------------------------------------------
pfree(d);
return (result);
-} /* lseg_dt() */
+} /* lseg_dt() */
Point *
result->y = (lseg->p[0].y - lseg->p[1].y) / 2;
return (result);
-} /* lseg_center() */
+} /* lseg_center() */
/* lseg_interpt -
pfree(tmp2);
return (result);
-} /* lseg_interpt() */
+} /* lseg_interpt() */
/***********************************************************************
**
*result = 0;
return (result);
-} /* dist_cpoly() */
+} /* dist_cpoly() */
/*---------------------------------------------------------------------
tmp = line_construct_pm(pt, invm);
result = line_interpt(tmp, line);
return (result);
-} /* close_pl() */
+} /* close_pl() */
/* close_ps()
* Closest point on line segment to specified point.
* Take the closest endpoint if the point is left, right,
- * above, or below the segment, otherwise find the intersection
- * point of the segment and its perpendicular through the point.
+ * above, or below the segment, otherwise find the intersection
+ * point of the segment and its perpendicular through the point.
*
* Some tricky code here, relying on boolean expressions
- * evaluating to only zero or one to use as an array index.
+ * evaluating to only zero or one to use as an array index.
*/
Point *
close_ps(Point *pt, LSEG *lseg)
if (lseg_vertical(lseg))
{
#ifdef GEODEBUG
-printf("close_ps- segment is vertical\n");
+ printf("close_ps- segment is vertical\n");
#endif
result = palloc(sizeof(*result));
result->x = lseg->p[0].x;
else if (lseg_horizontal(lseg))
{
#ifdef GEODEBUG
-printf("close_ps- segment is horizontal\n");
+ printf("close_ps- segment is horizontal\n");
#endif
result = palloc(sizeof(*result));
result->x = pt->x;
tmp = line_construct_pm(pt, invm);
result = interpt_sl(lseg, tmp);
return (result);
-} /* close_ps() */
+} /* close_ps() */
/* close_lseg()
* Closest point to l1 on l2.
if (*(d = dist_ps(&l2->p[1], l1)) < dist)
{
- if (result != NULL) pfree(result);
+ if (result != NULL)
+ pfree(result);
result = close_ps(&l2->p[1], l1);
memcpy(&point, result, sizeof(point));
}
return (result);
-} /* close_lseg() */
+} /* close_lseg() */
/* close_pb()
* Closest point on or in box to specified point.
if (*(d = dist_ps(pt, &seg)) < dist)
{
dist = *d;
- memcpy(&lseg,&seg,sizeof(lseg));
+ memcpy(&lseg, &seg, sizeof(lseg));
}
pfree(d);
if (*(d = dist_ps(pt, &seg)) < dist)
{
dist = *d;
- memcpy(&lseg,&seg,sizeof(lseg));
+ memcpy(&lseg, &seg, sizeof(lseg));
}
pfree(d);
if (*(d = dist_ps(pt, &seg)) < dist)
{
dist = *d;
- memcpy(&lseg,&seg,sizeof(lseg));
+ memcpy(&lseg, &seg, sizeof(lseg));
}
pfree(d);
return (close_ps(pt, &lseg));
-} /* close_pb() */
+} /* close_pb() */
/* close_sl()
* Closest point on line to line segment.
*
* XXX THIS CODE IS WRONG
* The code is actually calculating the point on the line segment
- * which is backwards from the routine naming convention.
+ * which is backwards from the routine naming convention.
* Copied code to new routine close_ls() but haven't fixed this one yet.
* - thomas 1998-01-31
*/
pfree(d1);
pfree(d2);
return (result);
-} /* close_ls() */
+} /* close_ls() */
/* close_sb()
* Closest point on or in box to line segment.
/* OK, we now have the closest line segment on the box boundary */
return (close_lseg(lseg, &bseg));
-} /* close_sb() */
+} /* close_sb() */
Point *
close_lb(LINE *line, BOX *box)
if (FPeq(yh, yl)) /* horizontal seg? */
if (FPge(pt->x, xl) && FPle(pt->x, xh) &&
FPeq(pt->y, yh))
- return (TRUE); /* pt lies on seg */
+ return (TRUE); /* pt lies on seg */
else
continue; /* skip other hz segs */
if (FPlt(yh, pt->y) || /* pt is strictly below seg */
return (above == UNDEF || /* path is horizontal */
inter % 2); /* odd # of intersections */
#endif
-} /* on_ppath() */
+} /* on_ppath() */
bool
return (FALSE);
return (on_pl(&lseg->p[0], line) && on_pl(&lseg->p[1], line));
-} /* on_sl() */
+} /* on_sl() */
bool
on_sb(LSEG *lseg, BOX *box)
return (FALSE);
return (on_pb(&lseg->p[0], box) && on_pb(&lseg->p[1], box));
-} /* on_sb() */
+} /* on_sb() */
/*---------------------------------------------------------------------
* inter_
*
* Segment completely inside box counts as intersection.
* If you want only segments crossing box boundaries,
- * try converting box to path first.
+ * try converting box to path first.
*
* Optimize for non-intersection by checking for box intersection first.
* - thomas 1998-01-30
/* if we dropped through, no two segs intersected */
return (FALSE);
-} /* inter_sb() */
+} /* inter_sb() */
/* inter_lb()
* Do line and box intersect?
* "x0,y0,...,xn,yn"
* also supports the older style "(x1,...,xn,y1,...yn)"
*------------------------------------------------------------------*/
-POLYGON *
+POLYGON *
poly_in(char *str)
{
POLYGON *poly;
make_bound_box(poly);
return (poly);
-} /* poly_in() */
+} /* poly_in() */
/*---------------------------------------------------------------
* poly_out - convert internal POLYGON representation to the
return NULL;
return (path_encode(TRUE, poly->npts, &(poly->p[0])));
-} /* poly_out() */
+} /* poly_out() */
/*-------------------------------------------------------
}
return TRUE;
#endif
-} /* poly_same() */
+} /* poly_same() */
/*-----------------------------------------------------------------
* Determine if polygon A overlaps polygon B by determining if
polya->boundbox.low.x, polya->boundbox.low.y, polya->boundbox.high.x, polya->boundbox.high.y);
#endif
return (FALSE);
-} /* poly_contain() */
+} /* poly_contain() */
/*-----------------------------------------------------------------
poly_contained(POLYGON *polya, POLYGON *polyb)
{
return (poly_contain(polyb, polya));
-} /* poly_contained() */
+} /* poly_contained() */
/* poly_contain_pt()
return (FALSE);
return (point_inside(p, poly->npts, &(poly->p[0])) != 0);
-} /* poly_contain_pt() */
+} /* poly_contain_pt() */
bool
pt_contained_poly(Point *p, POLYGON *poly)
return (FALSE);
return (poly_contain_pt(poly, p));
-} /* pt_contained_poly() */
+} /* pt_contained_poly() */
double *
*result = 0;
return (result);
-} /* poly_distance() */
+} /* poly_distance() */
/***********************************************************************
return (NULL);
return (point_construct(*x, *y));
-} /* point() */
+} /* point() */
Point *
result->y = (p1->y + p2->y);
return (result);
-} /* point_add() */
+} /* point_add() */
Point *
point_sub(Point *p1, Point *p2)
result->y = (p1->y - p2->y);
return (result);
-} /* point_sub() */
+} /* point_sub() */
Point *
point_mul(Point *p1, Point *p2)
result->y = (p1->x * p2->y) + (p1->y * p2->x);
return (result);
-} /* point_mul() */
+} /* point_mul() */
Point *
point_div(Point *p1, Point *p2)
result->y = ((p2->x * p1->y) - (p2->y * p1->x)) / div;
return (result);
-} /* point_div() */
+} /* point_div() */
/***********************************************************************
result = box_construct(p1->x, p2->x, p1->y, p2->y);
return (result);
-} /* box() */
+} /* box() */
BOX *
box_add(BOX *box, Point *p)
(box->high.y + p->y), (box->low.y + p->y));
return (result);
-} /* box_add() */
+} /* box_add() */
BOX *
box_sub(BOX *box, Point *p)
(box->high.y - p->y), (box->low.y - p->y));
return (result);
-} /* box_sub() */
+} /* box_sub() */
BOX *
box_mul(BOX *box, Point *p)
pfree(low);
return (result);
-} /* box_mul() */
+} /* box_mul() */
BOX *
box_div(BOX *box, Point *p)
pfree(low);
return (result);
-} /* box_div() */
+} /* box_div() */
/***********************************************************************
}
return (result);
-} /* path_add() */
+} /* path_add() */
/* path_add_pt()
* Translation operator.
}
return (result);
-} /* path_add_pt() */
+} /* path_add_pt() */
PATH *
path_sub_pt(PATH *path, Point *point)
}
return (result);
-} /* path_sub_pt() */
+} /* path_sub_pt() */
/* path_mul_pt()
}
return (result);
-} /* path_mul_pt() */
+} /* path_mul_pt() */
PATH *
path_div_pt(PATH *path, Point *point)
}
return (result);
-} /* path_div_pt() */
+} /* path_div_pt() */
bool
return (FALSE);
return ((path->closed ? (point_inside(p, path->npts, &(path->p[0])) != 0) : FALSE));
-} /* path_contain_pt() */
+} /* path_contain_pt() */
bool
pt_contained_path(Point *p, PATH *path)
return (FALSE);
return (path_contain_pt(path, p));
-} /* pt_contained_path() */
+} /* pt_contained_path() */
Point *
result = NULL;
return (result);
-} /* path_center() */
+} /* path_center() */
-POLYGON *
+POLYGON *
path_poly(PATH *path)
{
POLYGON *poly;
make_bound_box(poly);
return (poly);
-} /* path_polygon() */
+} /* path_polygon() */
/* upgradepath()
}
return (result);
-} /* upgradepath() */
+} /* upgradepath() */
bool
isoldpath(PATH *path)
return (FALSE);
return (path->npts == (path->p[0].y + 1));
-} /* isoldpath() */
+} /* isoldpath() */
/***********************************************************************
return (FALSE);
return (poly->npts);
-} /* poly_npoints() */
+} /* poly_npoints() */
Point *
}
return (result);
-} /* poly_center() */
+} /* poly_center() */
BOX *
box = box_copy(&poly->boundbox);
return (box);
-} /* poly_box() */
+} /* poly_box() */
/* box_poly()
* Convert a box to a polygon.
*/
-POLYGON *
+POLYGON *
box_poly(BOX *box)
{
POLYGON *poly;
box_fill(&poly->boundbox, box->high.x, box->low.x, box->high.y, box->low.y);
return (poly);
-} /* box_poly() */
+} /* box_poly() */
PATH *
}
return (path);
-} /* poly_path() */
+} /* poly_path() */
/* upgradepoly()
* Old-style: '(x1,x2,...,y1,y2,...)'
* New-style: '(x1,y1,x2,y2,...)'
*/
-POLYGON *
+POLYGON *
upgradepoly(POLYGON *poly)
{
POLYGON *result;
}
return (result);
-} /* upgradepoly() */
+} /* upgradepoly() */
/* revertpoly()
* Reverse effect of upgradepoly().
*/
-POLYGON *
+POLYGON *
revertpoly(POLYGON *poly)
{
POLYGON *result;
}
return (result);
-} /* revertpoly() */
+} /* revertpoly() */
/***********************************************************************
elog(ERROR, "Bad circle external representation '%s'", str);
return (circle);
-} /* circle_in() */
+} /* circle_in() */
/* circle_out - convert a circle to external form.
*/
*cp = '\0';
return (result);
-} /* circle_out() */
+} /* circle_out() */
/*----------------------------------------------------------
return (FPeq(circle1->radius, circle2->radius)
&& FPeq(circle1->center.x, circle2->center.x)
&& FPeq(circle1->center.y, circle2->center.y));
-} /* circle_same() */
+} /* circle_same() */
/* circle_overlap - does circle1 overlap circle2?
*/
circle_eq(CIRCLE *circle1, CIRCLE *circle2)
{
return (FPeq(circle_ar(circle1), circle_ar(circle2)));
-} /* circle_eq() */
+} /* circle_eq() */
bool
circle_ne(CIRCLE *circle1, CIRCLE *circle2)
{
return (!circle_eq(circle1, circle2));
-} /* circle_ne() */
+} /* circle_ne() */
bool
circle_lt(CIRCLE *circle1, CIRCLE *circle2)
{
return (FPlt(circle_ar(circle1), circle_ar(circle2)));
-} /* circle_lt() */
+} /* circle_lt() */
bool
circle_gt(CIRCLE *circle1, CIRCLE *circle2)
{
return (FPgt(circle_ar(circle1), circle_ar(circle2)));
-} /* circle_gt() */
+} /* circle_gt() */
bool
circle_le(CIRCLE *circle1, CIRCLE *circle2)
{
return (FPle(circle_ar(circle1), circle_ar(circle2)));
-} /* circle_le() */
+} /* circle_le() */
bool
circle_ge(CIRCLE *circle1, CIRCLE *circle2)
{
return (FPge(circle_ar(circle1), circle_ar(circle2)));
-} /* circle_ge() */
+} /* circle_ge() */
/*----------------------------------------------------------
memmove((char *) result, (char *) circle, sizeof(CIRCLE));
return (result);
-} /* circle_copy() */
+} /* circle_copy() */
/* circle_add_pt()
result->center.y += point->y;
return (result);
-} /* circle_add_pt() */
+} /* circle_add_pt() */
CIRCLE *
circle_sub_pt(CIRCLE *circle, Point *point)
result->center.y -= point->y;
return (result);
-} /* circle_sub_pt() */
+} /* circle_sub_pt() */
/* circle_mul_pt()
result->radius *= HYPOT(point->x, point->y);
return (result);
-} /* circle_mul_pt() */
+} /* circle_mul_pt() */
CIRCLE *
circle_div_pt(CIRCLE *circle, Point *point)
result->radius /= HYPOT(point->x, point->y);
return (result);
-} /* circle_div_pt() */
+} /* circle_div_pt() */
/* circle_area - returns the area of the circle.
*result = 0;
return (result);
-} /* circle_distance() */
+} /* circle_distance() */
bool
pfree(d);
return (within);
-} /* circle_contain_pt() */
+} /* circle_contain_pt() */
bool
pt_contained_circle(Point *point, CIRCLE *circle)
{
return (circle_contain_pt(circle, point));
-} /* circle_contain_pt() */
+} /* circle_contain_pt() */
/* dist_pc - returns the distance between
*result = 0;
return (result);
-} /* dist_pc() */
+} /* dist_pc() */
/* circle_center - returns the center point of the circle.
}
-BOX *
+BOX *
circle_box(CIRCLE *circle)
{
BOX *box;
box->low.y = circle->center.y - delta;
return (box);
-} /* circle_box() */
+} /* circle_box() */
/* box_circle()
* Convert a box to a circle.
circle->radius = point_dt(&circle->center, &box->high);
return (circle);
-} /* box_circle() */
+} /* box_circle() */
-POLYGON *
+POLYGON *
circle_poly(int npts, CIRCLE *circle)
{
POLYGON *poly;
elog(ERROR, "Unable to convert polygon to circle", NULL);
return (circle);
-} /* poly_circle() */
+} /* poly_circle() */
/***********************************************************************
return 1;
}
return 0;
-} /* point_inside() */
+} /* point_inside() */
/* lseg_crossing()
return (HIT_IT);
return (FPgt((sgn * z), 0) ? 0 : 2 * sgn);
}
-} /* lseg_crossing() */
+} /* lseg_crossing() */
static bool
}
return (FALSE);
-} /* plist_same() */
+} /* plist_same() */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.14 1998/02/11 19:12:37 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.15 1998/02/26 04:37:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
int16 *
int28in(char *shs)
{
- int16 (*result)[];
+ int16 (*result)[];
int nums;
if (shs == NULL)
char *
int28out(int16 (*shs)[])
{
- int num;
- int16 *sp;
- char *rp;
+ int num;
+ int16 *sp;
+ char *rp;
char *result;
if (shs == NULL)
int44in(char *input_string)
{
int32 *foo = (int32 *) palloc(4 * sizeof(int32));
- int i = 0;
+ int i = 0;
i = sscanf(input_string,
"%d, %d, %d, %d",
text *
int2_text(int16 arg1)
{
- text *result;
+ text *result;
- int len;
- char *str;
+ int len;
+ char *str;
str = int2out(arg1);
len = (strlen(str) + VARHDRSZ);
pfree(str);
- return(result);
-} /* int2_text() */
+ return (result);
+} /* int2_text() */
int16
text_int2(text *string)
{
- int16 result;
+ int16 result;
- int len;
- char *str;
+ int len;
+ char *str;
len = (VARSIZE(string) - VARHDRSZ);
- str = palloc(len+1);
+ str = palloc(len + 1);
memmove(str, VARDATA(string), len);
- *(str+len) = '\0';
+ *(str + len) = '\0';
result = int2in(str);
pfree(str);
-
- return(result);
-} /* text_int2() */
+
+ return (result);
+} /* text_int2() */
text *
int4_text(int32 arg1)
{
- text *result;
+ text *result;
- int len;
- char *str;
+ int len;
+ char *str;
str = int4out(arg1);
len = (strlen(str) + VARHDRSZ);
pfree(str);
- return(result);
-} /* int4_text() */
+ return (result);
+} /* int4_text() */
int32
text_int4(text *string)
{
- int32 result;
+ int32 result;
- int len;
- char *str;
+ int len;
+ char *str;
len = (VARSIZE(string) - VARHDRSZ);
- str = palloc(len+1);
+ str = palloc(len + 1);
memmove(str, VARDATA(string), len);
- *(str+len) = '\0';
+ *(str + len) = '\0';
result = int4in(str);
pfree(str);
-
- return(result);
-} /* text_int4() */
+
+ return (result);
+} /* text_int4() */
/*
/* be sure sterm is null-terminated */
sterm = (char *) palloc(charlen + 1);
- StrNCpy(sterm, s, charlen+1);
+ StrNCpy(sterm, s, charlen + 1);
/*
* p is a text = varlena, not a string so we have to make a string
}
-/* $Revision: 1.11 $
+/* $Revision: 1.12 $
** "like.c" A first attempt at a LIKE operator for Postgres95.
**
** Originally written by Rich $alz, mirror!rs, Wed Nov 26 19:03:17 EST 1986.
static int
DoMatch(char *text, char *p)
{
- int matched;
+ int matched;
for (; *p; text ++, p++)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/nabstime.c,v 1.41 1998/02/02 01:28:12 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/nabstime.c,v 1.42 1998/02/26 04:37:12 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#endif
return ((AbsoluteTime) now);
-} /* GetCurrentAbsoluteTime() */
+} /* GetCurrentAbsoluteTime() */
void
abstime2tm(GetCurrentTransactionStartTime(), &tz, tm, NULL);
return;
-} /* GetCurrentTime() */
+} /* GetCurrentTime() */
void
#endif
return;
-} /* abstime2tm() */
+} /* abstime2tm() */
/* tm2abstime()
return (INVALID_ABSTIME);
return (sec);
-} /* tm2abstime() */
+} /* tm2abstime() */
/* nabstimein()
};
return result;
-} /* nabstimein() */
+} /* nabstimein() */
/* nabstimeout()
* Given an AbsoluteTime return the English text version of the date
*/
-char *
+char *
nabstimeout(AbsoluteTime time)
{
char *result;
strcpy(result, buf);
return (result);
-} /* nabstimeout() */
+} /* nabstimeout() */
/*
{
return ((abstime != INVALID_ABSTIME)
&& (abstime != NOSTART_ABSTIME) && (abstime != NOEND_ABSTIME));
-} /* abstime_finite() */
+} /* abstime_finite() */
/*
};
return (result);
-} /* datetime_abstime() */
+} /* datetime_abstime() */
/* abstime_datetime()
* Convert abstime to datetime.
};
return (result);
-} /* abstime_datetime() */
+} /* abstime_datetime() */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/name.c,v 1.10 1997/10/25 01:10:40 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/name.c,v 1.11 1998/02/26 04:37:13 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* nameout - converts internal reprsentation to "..."
*/
-char *
+char *
nameout(NameData *s)
{
if (s == NULL)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/numutils.c,v 1.22 1998/02/11 19:12:39 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/numutils.c,v 1.23 1998/02/26 04:37:14 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#else
auto int expon;
auto int sign;
- int avail = 0;
- char *a = NULL;
- char *p = NULL;
+ int avail = 0;
+ char *a = NULL;
+ char *p = NULL;
char mode;
int lowercase;
int prec;
*a = 0;
avail = a - ascii;
return (avail);
-#endif
+#endif
}
#endif
int
atof1(char *str, double *val)
{
- char *p;
+ char *p;
double v;
double fact;
int minus;
- char c;
+ char c;
int expon;
- int gotmant;
+ int gotmant;
v = 0.0;
p = str;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/oid.c,v 1.14 1998/02/11 19:12:41 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/oid.c,v 1.15 1998/02/26 04:37:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* Note:
* Fills any nonexistent digits with NULL oids.
*/
-Oid *
+Oid *
oid8in(char *oidString)
{
- Oid (*result)[];
+ Oid (*result)[];
int nums;
if (oidString == NULL)
char *
oid8out(Oid (*oidArray)[])
{
- int num;
- Oid *sp;
- char *rp;
+ int num;
+ Oid *sp;
+ char *rp;
char *result;
if (oidArray == NULL)
text *
oid_text(Oid oid)
{
- text *result;
+ text *result;
- int len;
- char *str;
+ int len;
+ char *str;
str = oidout(oid);
len = (strlen(str) + VARHDRSZ);
result = palloc(len);
VARSIZE(result) = len;
- memmove(VARDATA(result), str, (len-VARHDRSZ));
+ memmove(VARDATA(result), str, (len - VARHDRSZ));
pfree(str);
- return(result);
-} /* oid_text() */
+ return (result);
+} /* oid_text() */
Oid
text_oid(text *string)
{
- Oid result;
+ Oid result;
- int len;
- char *str;
+ int len;
+ char *str;
- len = (VARSIZE(string) - VARHDRSZ);
+ len = (VARSIZE(string) - VARHDRSZ);
- str = palloc(len+1);
+ str = palloc(len + 1);
memmove(str, VARDATA(string), len);
- *(str+len) = '\0';
+ *(str + len) = '\0';
result = oidin(str);
pfree(str);
- return(result);
-} /* oid_text() */
+ return (result);
+} /* oid_text() */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/oidint2.c,v 1.4 1997/09/08 21:48:34 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/oidint2.c,v 1.5 1998/02/26 04:37:17 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return (oi);
}
-char *
+char *
oidint2out(OidInt2 o)
{
char *r;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/oidint4.c,v 1.4 1997/09/08 21:48:35 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/oidint4.c,v 1.5 1998/02/26 04:37:17 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return (oi);
}
-char *
+char *
oidint4out(OidInt4 o)
{
char *r;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/oidname.c,v 1.11 1998/01/05 16:40:10 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/oidname.c,v 1.12 1998/02/26 04:37:18 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return oc;
}
-char *
+char *
oidnameout(OidName oidname)
{
char buf[30 + NAMEDATALEN]; /* oidname length + oid length +
/*
* Edmund Mergl
*
- * $Id: oracle_compat.c,v 1.11 1998/01/13 03:49:51 scrappy Exp $
+ * $Id: oracle_compat.c,v 1.12 1998/02/26 04:37:19 momjian Exp $
*
*/
*
********************************************************************/
-text *
+text *
lower(text *string)
{
text *ret;
*
********************************************************************/
-text *
+text *
upper(text *string)
{
text *ret;
*
********************************************************************/
-text *
+text *
initcap(text *string)
{
text *ret;
*
********************************************************************/
-text *
+text *
lpad(text *string1, int4 len, text *string2)
{
text *ret;
*
********************************************************************/
-text *
+text *
rpad(text *string1, int4 len, text *string2)
{
text *ret;
*
********************************************************************/
-text *
+text *
btrim(text *string, text *set)
{
text *ret;
memcpy(VARDATA(ret), ptr, m);
return ret;
-} /* btrim() */
+} /* btrim() */
/********************************************************************
*
********************************************************************/
-text *
+text *
ltrim(text *string, text *set)
{
text *ret;
*
********************************************************************/
-text *
+text *
rtrim(text *string, text *set)
{
text *ret;
*
********************************************************************/
-text *
+text *
substr(text *string, int4 m, int4 n)
{
text *ret;
*
********************************************************************/
-text *
+text *
translate(text *string, char from, char to)
{
text *ret;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/regexp.c,v 1.13 1998/01/05 16:40:11 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/regexp.c,v 1.14 1998/02/26 04:37:20 momjian Exp $
*
* Alistair Crooks added the code for the regex caching
* agc - cached the regular expressions used - there's a good chance
/* be sure sterm is null-terminated */
sterm = (char *) palloc(charlen + 1);
- StrNCpy(sterm, s, charlen+1);
+ StrNCpy(sterm, s, charlen + 1);
result = RE_compile_and_execute(p, sterm, cflags);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.14 1998/02/11 19:12:43 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.15 1998/02/26 04:37:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* regprocout - converts proid to "proname"
*/
-char *
+char *
regprocout(RegProcedure proid)
{
Relation proc;
/*
* int8typeout - converts int8 type oids to "typname" list
*/
-text *
+text *
oid8types(Oid (*oidArray)[])
{
Relation type;
HeapTuple typetup;
text *result;
ScanKeyData key;
- int num;
- Oid *sp;
+ int num;
+ Oid *sp;
if (oidArray == NULL)
{
- result = (text *) palloc(VARHDRSZ);
+ result = (text *) palloc(VARHDRSZ);
VARSIZE(result) = 0;
return (result);
}
- result = (text *) palloc(NAMEDATALEN * 8 + 8 + VARHDRSZ);
- *VARDATA(result) = '\0';
+ result = (text *) palloc(NAMEDATALEN * 8 + 8 + VARHDRSZ);
+ *VARDATA(result) = '\0';
type = heap_openr(TypeRelationName);
if (!RelationIsValid(type))
{
(AttrNumber) ObjectIdAttributeNumber,
(RegProcedure) F_INT4EQ,
(Datum) *sp);
-
+
typescan = heap_beginscan(type, 0, false, 1, &key);
if (!HeapScanIsValid(typescan))
{
{
char *s;
bool isnull;
-
+
s = (char *) heap_getattr(typetup, 1,
- RelationGetTupleDescriptor(type), &isnull);
+ RelationGetTupleDescriptor(type), &isnull);
if (!isnull)
{
- StrNCpy(VARDATA(result)+strlen(VARDATA(result)),s,16);
- strcat(VARDATA(result)," ");
+ StrNCpy(VARDATA(result) + strlen(VARDATA(result)), s, 16);
+ strcat(VARDATA(result), " ");
}
else
elog(FATAL, "int8typeout: null procedure %d", *sp);
- /* FALLTHROUGH */
+ /* FALLTHROUGH */
}
heap_endscan(typescan);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.17 1998/02/11 19:12:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.18 1998/02/26 04:37:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
char **high,
char **low)
{
- Relation rdesc;
+ Relation rdesc;
HeapScanDesc sdesc;
static ScanKeyData key[3] = {
{0, Anum_pg_statistic_starelid, F_OIDEQ, {0, 0, F_OIDEQ}},
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/tid.c,v 1.4 1997/09/08 02:31:03 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/tid.c,v 1.5 1998/02/26 04:37:22 momjian Exp $
*
* NOTES
* input routine largely stolen from boxin().
* tidout
* ----------------------------------------------------------------
*/
-char *
+char *
tidout(ItemPointer itemPtr)
{
BlockNumber blockNumber;
EncodeDateTime(tm, fsec, &tz, &tzn, USE_ISO_DATES, buf);
break;
}
-
+
result = palloc(strlen(buf) + 1);
strcpy(result, buf);
return result;
-} /* timestamp_out() */
+} /* timestamp_out() */
time_t
now(void)
bool
timestampeq(time_t t1, time_t t2)
{
- return(abstimeeq(t1,t2));
+ return (abstimeeq(t1, t2));
}
bool
timestampne(time_t t1, time_t t2)
{
- return(abstimene(t1,t2));
+ return (abstimene(t1, t2));
}
bool
timestamplt(time_t t1, time_t t2)
{
- return(abstimelt(t1,t2));
+ return (abstimelt(t1, t2));
}
bool
timestampgt(time_t t1, time_t t2)
{
- return(abstimegt(t1,t2));
+ return (abstimegt(t1, t2));
}
bool
timestample(time_t t1, time_t t2)
{
- return(abstimele(t1,t2));
+ return (abstimele(t1, t2));
}
bool
timestampge(time_t t1, time_t t2)
{
- return(abstimege(t1,t2));
+ return (abstimege(t1, t2));
}
-DateTime *
+DateTime *
timestamp_datetime(time_t timestamp)
{
- return(abstime_datetime((AbsoluteTime) timestamp));
-} /* timestamp_datetime() */
+ return (abstime_datetime((AbsoluteTime) timestamp));
+} /* timestamp_datetime() */
time_t
datetime_timestamp(DateTime *datetime)
{
- return((AbsoluteTime) datetime_abstime(datetime));
-} /* datetime_timestamp() */
+ return ((AbsoluteTime) datetime_abstime(datetime));
+} /* datetime_timestamp() */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/varchar.c,v 1.28 1998/02/24 15:19:44 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/varchar.c,v 1.29 1998/02/26 04:37:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/builtins.h"
#ifdef CYR_RECODE
-char *convertstr(char *,int,int);
+char *convertstr(char *, int, int);
+
#endif
/*
}
#ifdef CYR_RECODE
- convertstr(result + VARHDRSZ,len,0);
+ convertstr(result + VARHDRSZ, len, 0);
#endif
/* blank pad the string if necessary */
{
len = VARSIZE(s) - VARHDRSZ;
result = (char *) palloc(len + 1);
- StrNCpy(result, VARDATA(s), len+1); /* these are blank-padded */
+ StrNCpy(result, VARDATA(s), len + 1); /* these are blank-padded */
}
#ifdef CYR_RECODE
- convertstr(result,len,1);
+ convertstr(result, len, 1);
#endif
return (result);
len = strlen(s) + VARHDRSZ;
if (atttypmod != -1 && len > atttypmod)
- len = atttypmod; /* clip the string at max length */
+ len = atttypmod; /* clip the string at max length */
if (len > 4096)
elog(ERROR, "varcharin: length of char() must be less than 4096");
strncpy(VARDATA(result), s, len - VARHDRSZ);
#ifdef CYR_RECODE
- convertstr(result + VARHDRSZ,len,0);
+ convertstr(result + VARHDRSZ, len, 0);
#endif
return (result);
{
len = VARSIZE(s) - VARHDRSZ;
result = (char *) palloc(len + 1);
- StrNCpy(result, VARDATA(s), len+1);
+ StrNCpy(result, VARDATA(s), len + 1);
}
#ifdef CYR_RECODE
- convertstr(result,len,1);
+ convertstr(result, len, 1);
#endif
return (result);
if (!PointerIsValid(arg))
elog(ERROR, "Bad (null) char() external representation", NULL);
- return(bcTruelen(arg));
+ return (bcTruelen(arg));
}
bool
if (!PointerIsValid(arg))
elog(ERROR, "Bad (null) varchar() external representation", NULL);
- return(VARSIZE(arg) - VARHDRSZ);
+ return (VARSIZE(arg) - VARHDRSZ);
}
bool
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.30 1998/02/24 15:19:45 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.31 1998/02/26 04:37:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
memmove(VARDATA(result), inputText, len - VARHDRSZ);
#ifdef CYR_RECODE
- convertstr(VARDATA(result),len-VARHDRSZ,0);
+ convertstr(VARDATA(result), len - VARHDRSZ, 0);
#endif
return (result);
result[len] = '\0';
#ifdef CYR_RECODE
- convertstr(result,len,1);
+ convertstr(result, len, 1);
#endif
return (result);
/*
* textlen -
* returns the actual length of a text*
- * (which is less than the VARSIZE of the text*)
+ * (which is less than the VARSIZE of the text*)
*/
int32
textlen(text *t)
{
if (!PointerIsValid(t))
- elog(ERROR,"Null input to textlen");
+ elog(ERROR, "Null input to textlen");
return (VARSIZE(t) - VARHDRSZ);
-} /* textlen() */
+} /* textlen() */
/*
* textcat -
VARSIZE(result) = len;
return (result);
-} /* textcat() */
+} /* textcat() */
/*
* text_substr()
* - thomas 1997-12-31
*
* Input:
- * - string
- * - starting position (is one-based)
- * - string length
+ * - string
+ * - starting position (is one-based)
+ * - string length
*
* If the starting position is zero or less, then return the entire string.
* XXX Note that this may not be the right behavior:
- * if we are calculating the starting position we might want it to start at one.
+ * if we are calculating the starting position we might want it to start at one.
* If the length is less than zero, return the remaining string.
*
* Note that the arguments operate on octet length,
- * so not aware of multi-byte character sets.
+ * so not aware of multi-byte character sets.
*/
text *
text_substr(text *string, int32 m, int32 n)
else
{
m--;
- if (((m+n) > len) || (n < 0))
- n = (len-m);
+ if (((m + n) > len) || (n < 0))
+ n = (len - m);
}
ret = (text *) palloc(VARHDRSZ + n);
VARSIZE(ret) = VARHDRSZ + n;
- memcpy(VARDATA(ret), VARDATA(string)+m, n);
+ memcpy(VARDATA(ret), VARDATA(string) + m, n);
return ret;
-} /* text_substr() */
+} /* text_substr() */
/*
* textpos -
p1++;
};
return (pos);
-} /* textpos() */
+} /* textpos() */
/*
* texteq - returns 1 iff arguments are equal
if (*a1p++ != *a2p++)
return ((bool) 0);
return ((bool) 1);
-} /* texteq() */
+} /* texteq() */
bool
textne(text *arg1, text *arg2)
#endif
return (result);
-} /* text_lt() */
+} /* text_lt() */
/* text_le()
* Comparison function for text strings.
#endif
return (result);
-} /* text_le() */
+} /* text_le() */
bool
text_gt(text *arg1, text *arg2)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.23 1998/02/23 17:43:19 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.24 1998/02/26 04:37:27 momjian Exp $
*
* Notes:
* XXX This needs to use exception.h to handle recovery when
HeapTuple (*iScanfuncP) ())
{
CatCache *cp;
- int i;
+ int i;
MemoryContext oldcxt;
char *indname;
elt;
elt = DLGetSucc(elt))
{
- bool res;
-
+ bool res;
+
ct = (CatCTup *) DLE_VAL(elt);
/* ----------------
* see if the cached tuple matches our key.
* ----------------
*/
HeapKeyTest(ct->ct_tup,
- cache->cc_tupdesc,
- cache->cc_nkeys,
- cache->cc_skey,
- res);
+ cache->cc_tupdesc,
+ cache->cc_nkeys,
+ cache->cc_skey,
+ res);
if (res)
break;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/Attic/fcache.c,v 1.10 1998/01/15 19:45:29 pgsql Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/Attic/fcache.c,v 1.11 1998/02/26 04:37:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
- if (retval->language != SQLlanguageId) {
+ if (retval->language != SQLlanguageId)
+ {
fmgr_info(foid, &(retval->func));
retval->nargs = retval->func.fn_nargs;
- } else {
+ }
+ else
+ {
retval->func.fn_addr = (func_ptr) NULL;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.12 1998/02/10 16:03:51 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.13 1998/02/26 04:37:30 momjian Exp $
*
* NOTES
* Eventually, the index information should go through here, too.
* return the "attname" field from the attribute relation.
*
*/
-char *
+char *
get_attname(Oid relid, AttrNumber attnum)
{
FormData_pg_attribute att_tup;
* return the "atttypmod" field from the attribute relation.
*
*/
-int16
+int16
get_atttypmod(Oid relid, AttrNumber attnum)
{
FormData_pg_attribute att_tup;
*
* Note: return the struct so that it gets copied.
*/
-char *
+char *
get_opname(Oid opno)
{
FormData_pg_operator optup;
* Returns the name of a given relation.
*
*/
-char *
+char *
get_rel_name(Oid relid)
{
FormData_pg_class reltup;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.36 1998/02/23 17:43:25 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.37 1998/02/26 04:37:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static HeapTuple scan_pg_rel_seq(RelationBuildDescInfo buildinfo);
static HeapTuple scan_pg_rel_ind(RelationBuildDescInfo buildinfo);
static Relation AllocateRelationDesc(u_int natts, Form_pg_class relp);
-static void RelationBuildTupleDesc(RelationBuildDescInfo buildinfo,
+static void
+RelationBuildTupleDesc(RelationBuildDescInfo buildinfo,
Relation relation, u_int natts);
-static void build_tupdesc_seq(RelationBuildDescInfo buildinfo,
+static void
+build_tupdesc_seq(RelationBuildDescInfo buildinfo,
Relation relation, u_int natts);
-static void build_tupdesc_ind(RelationBuildDescInfo buildinfo,
+static void
+build_tupdesc_ind(RelationBuildDescInfo buildinfo,
Relation relation, u_int natts);
static Relation RelationBuildDesc(RelationBuildDescInfo buildinfo);
static void IndexedAccessMethodInitialize(Relation relation);
Anum_pg_rewrite_ev_qual, pg_rewrite_tupdesc,
&isnull);
- ruleaction = PointerGetDatum (textout((struct varlena *) DatumGetPointer (ruleaction)));
- rule_evqual_string = PointerGetDatum (textout((struct varlena *) DatumGetPointer (rule_evqual_string)));
+ ruleaction = PointerGetDatum(textout((struct varlena *) DatumGetPointer(ruleaction)));
+ rule_evqual_string = PointerGetDatum(textout((struct varlena *) DatumGetPointer(rule_evqual_string)));
- rule->actions = (List *) stringToNode(DatumGetPointer (ruleaction));
- rule->qual = (Node *) stringToNode(DatumGetPointer (rule_evqual_string));
+ rule->actions = (List *) stringToNode(DatumGetPointer(ruleaction));
+ rule->qual = (Node *) stringToNode(DatumGetPointer(rule_evqual_string));
rules[numlocks++] = rule;
if (numlocks == maxlocks)
for (i = 0; i < am->amstrategies; i++)
fmgr_info(SMD(i).sk_procedure,
&(SMD(i).sk_func));
- SMD(i).sk_nargs = SMD(i).sk_func.fn_nargs;
+ SMD(i).sk_nargs = SMD(i).sk_func.fn_nargs;
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/syscache.c,v 1.15 1998/02/25 13:07:50 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/syscache.c,v 1.16 1998/02/26 04:37:33 momjian Exp $
*
* NOTES
* These routines allow the parser/planner/executor to perform
#include "utils/syscache.h"
#include "catalog/indexing.h"
-typedef HeapTuple(*ScanFunc) ();
+typedef HeapTuple (*ScanFunc) ();
/* ----------------
* Warning: cacheinfo[] below is changed, then be sure and
0,
0,
0},
- offsetof(TypeTupleFormData, typalign) + sizeof(char),
+ offsetof(TypeTupleFormData, typalign) +sizeof(char),
TypeNameIndex,
TypeNameIndexScan},
{TypeRelationName, /* TYPOID */
sizeof(FormData_pg_listener),
NULL,
(ScanFunc) NULL},
- {ShadowRelationName, /* USENAME */
+ {ShadowRelationName, /* USENAME */
1,
{Anum_pg_shadow_usename,
0,
sizeof(FormData_pg_shadow),
NULL,
(ScanFunc) NULL},
- {ShadowRelationName, /* USESYSID */
+ {ShadowRelationName, /* USESYSID */
1,
{Anum_pg_shadow_usesysid,
0,
* XXX The tuple that is returned is NOT supposed to be pfree'd!
*/
HeapTuple
-SearchSysCacheTuple(int cacheId, /* cache selection code */
+SearchSysCacheTuple(int cacheId,/* cache selection code */
Datum key1,
Datum key2,
Datum key3,
Datum key4)
{
- HeapTuple tp;
+ HeapTuple tp;
if (cacheId < 0 || cacheId >= SysCacheSize)
{
*
* [callers all assume this returns a (struct varlena *). -ay 10/94]
*/
-void *
+void *
SearchSysCacheGetAttribute(int cacheId,
AttrNumber attributeNumber,
Datum key1,
* [identical to get_typdefault, expecting a (struct varlena *) as ret val.
* some day, either of the functions should be removed -ay 10/94]
*/
-void *
+void *
TypeDefaultRetrieve(Oid typId)
{
HeapTuple typeTuple;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.26 1998/02/11 19:12:50 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.27 1998/02/26 04:37:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
va_list ap;
char buf[ELOG_MAXLEN],
line[ELOG_MAXLEN];
- char *bp;
+ char *bp;
const char *cp;
extern int errno,
sys_nerr;
pq_putstr(line);
pq_flush();
}
- if (Pfout == NULL) {
- /* There is no socket. One explanation for this is we are running
- as the Postmaster. So we'll write the message to stderr.
- */
+ if (Pfout == NULL)
+ {
+
+ /*
+ * There is no socket. One explanation for this is we are running
+ * as the Postmaster. So we'll write the message to stderr.
+ */
fputs(line, stderr);
}
#endif /* !PG_STANDALONE */
ProcReleaseSpins(NULL); /* get rid of spinlocks we hold */
if (!InError)
{
- kill(MyProcPid, 1); /* abort to traffic cop */
+ kill(MyProcPid, 1); /* abort to traffic cop */
pause();
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/error/Attic/exc.c,v 1.19 1998/02/11 19:12:52 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/error/Attic/exc.c,v 1.20 1998/02/26 04:37:35 momjian Exp $
*
* NOTE
* XXX this code needs improvement--check for state violations and
ExcData data,
ExcMessage message)
{
- ExcFrame *efp;
+ ExcFrame *efp;
efp = ExcCurFrameP;
if (efp == NULL)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/error/Attic/format.c,v 1.5 1997/09/08 02:31:32 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/error/Attic/format.c,v 1.6 1998/02/26 04:37:36 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* form
* ----------------
*/
-char *
+char *
form(const char *fmt,...)
{
va_list args;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.14 1998/02/11 19:12:55 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.15 1998/02/26 04:37:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "commands/trigger.h"
-static char *
-fmgr_pl(char *arg0, ...)
+static char *
+fmgr_pl(char *arg0,...)
{
- va_list pvar;
- FmgrValues values;
- bool isNull = false;
- int i;
+ va_list pvar;
+ FmgrValues values;
+ bool isNull = false;
+ int i;
memset(&values, 0, sizeof(values));
- if (fmgr_pl_finfo->fn_nargs > 0) {
+ if (fmgr_pl_finfo->fn_nargs > 0)
+ {
values.data[0] = arg0;
- if (fmgr_pl_finfo->fn_nargs > 1) {
+ if (fmgr_pl_finfo->fn_nargs > 1)
+ {
va_start(pvar, arg0);
- for (i = 1; i < fmgr_pl_finfo->fn_nargs; i++) {
+ for (i = 1; i < fmgr_pl_finfo->fn_nargs; i++)
+ {
values.data[i] = va_arg(pvar, char *);
}
va_end(pvar);
/* Call the PL handler */
CurrentTriggerData = NULL;
return (*(fmgr_pl_finfo->fn_plhandler)) (fmgr_pl_finfo,
- &values,
- &isNull);
-}
+ &values,
+ &isNull);
+}
-char *
+char *
fmgr_c(FmgrInfo *finfo,
- FmgrValues * values,
- bool * isNull)
-{
- char *returnValue = (char *) NULL;
- int n_arguments = finfo->fn_nargs;
- func_ptr user_fn = fmgr_faddr(finfo);
-
-
+ FmgrValues *values,
+ bool *isNull)
+{
+ char *returnValue = (char *) NULL;
+ int n_arguments = finfo->fn_nargs;
+ func_ptr user_fn = fmgr_faddr(finfo);
+
+
if (user_fn == (func_ptr) NULL)
{
}
/*
- * If finfo contains a PL handler for this function,
- * call that instead.
+ * If finfo contains a PL handler for this function, call that
+ * instead.
*/
- if (finfo->fn_plhandler != NULL) {
- return (*(finfo->fn_plhandler))(finfo, values, isNull);
+ if (finfo->fn_plhandler != NULL)
+ {
+ return (*(finfo->fn_plhandler)) (finfo, values, isNull);
}
switch (n_arguments)
switch (language)
{
case INTERNALlanguageId:
- finfo->fn_addr =
- fmgr_lookupByName(procedureStruct->proname.data);
+ finfo->fn_addr =
+ fmgr_lookupByName(procedureStruct->proname.data);
if (!finfo->fn_addr)
elog(ERROR, "fmgr_info: function %s: not in internal table",
- procedureStruct->proname.data);
+ procedureStruct->proname.data);
break;
case ClanguageId:
finfo->fn_addr = fmgr_dynamic(procedureId, &(finfo->fn_nargs));
{
FmgrInfo plfinfo;
- fmgr_info(((Form_pg_language)GETSTRUCT(languageTuple))->lanplcallfoid, &plfinfo);
+ fmgr_info(((Form_pg_language) GETSTRUCT(languageTuple))->lanplcallfoid, &plfinfo);
finfo->fn_addr = (func_ptr) fmgr_pl;
finfo->fn_plhandler = plfinfo.fn_addr;
finfo->fn_nargs = procedureStruct->pronargs;
* Returns the return value of the invoked function if succesful,
* 0 if unsuccessful.
*/
-char *
+char *
fmgr(Oid procedureId,...)
{
va_list pvar;
* funcinfo, n_arguments, args...
*/
#ifdef NOT_USED
-char *
-fmgr_ptr(FmgrInfo *finfo, ...)
+char *
+fmgr_ptr(FmgrInfo *finfo,...)
{
va_list pvar;
int i;
FmgrValues values;
bool isNull = false;
- local_finfo->fn_addr = finfo->fn_addr;
+ local_finfo->fn_addr = finfo->fn_addr;
local_finfo->fn_plhandler = finfo->fn_plhandler;
local_finfo->fn_oid = finfo->fn_oid;
* function pointer field to FuncIndexInfo, it will be replace by calls
* to fmgr_c().
*/
-char *
-fmgr_array_args(Oid procedureId, int nargs, char *args[], bool * isNull)
+char *
+fmgr_array_args(Oid procedureId, int nargs, char *args[], bool *isNull)
{
FmgrInfo finfo;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/hash/dynahash.c,v 1.12 1998/02/11 19:13:02 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/hash/dynahash.c,v 1.13 1998/02/26 04:37:49 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/************************** CREATE ROUTINES **********************/
-HTAB *
+HTAB *
hash_create(int nelem, HASHCTL *info, int flags)
{
- HHDR *hctl;
+ HHDR *hctl;
HTAB *hashp;
init_htab(HTAB *hashp, int nelem)
{
SEG_OFFSET *segp;
- int nbuckets;
- int nsegs;
+ int nbuckets;
+ int nsegs;
int l2;
HHDR *hctl;
if (hashp != NULL)
{
- SEG_OFFSET segNum;
+ SEG_OFFSET segNum;
SEGMENT segp;
int nsegs = hashp->hctl->nsegs;
int j;
* foundPtr is TRUE if we found an element in the table
* (FALSE if we entered one).
*/
-long *
+long *
hash_search(HTAB *hashp,
char *keyPtr,
HASHACTION action, /* HASH_FIND / HASH_ENTER / HASH_REMOVE
long segment_num;
long segment_ndx;
SEGMENT segp;
- ELEMENT *curr;
+ ELEMENT *curr;
HHDR *hctl;
BUCKET_INDEX currIndex;
BUCKET_INDEX *prevIndexPtr;
* return TRUE in the end.
*
*/
-long *
+long *
hash_seq(HTAB *hashp)
{
static uint32 curBucket = 0;
static int
dir_realloc(HTAB *hashp)
{
- char *p;
+ char *p;
char **p_ptr;
long old_dirsize;
long new_dirsize;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/hash/hashfn.c,v 1.6 1998/02/11 19:13:06 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/hash/hashfn.c,v 1.7 1998/02/26 04:37:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
long
tag_hash(int *key, int keysize)
{
- long h = 0;
+ long h = 0;
/*
* Convert tag to integer; Use four byte chunks in a "jump table" to
long
disk_hash(char *key)
{
- int n = 0;
- char *str = key;
- int len = strlen(key);
- int loop;
+ int n = 0;
+ char *str = key;
+ int len = strlen(key);
+ int loop;
#define HASHC n = *str++ + 65599 * n
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/init/globals.c,v 1.20 1998/02/25 13:08:00 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/init/globals.c,v 1.21 1998/02/26 04:37:56 momjian Exp $
*
* NOTES
* Globals used all over the place should be declared here and not
#include "libpq/pqcomm.h"
#include "catalog/catname.h"
-ProtocolVersion FrontendProtocol = PG_PROTOCOL_LATEST;
+ProtocolVersion FrontendProtocol = PG_PROTOCOL_LATEST;
int Portfd = -1;
int Noversion = 0;
int Quiet = 1;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/init/miscinit.c,v 1.11 1998/02/25 13:08:09 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/init/miscinit.c,v 1.12 1998/02/26 04:38:06 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#ifdef CYR_RECODE
unsigned char RecodeForwTable[128];
unsigned char RecodeBackTable[128];
+
#endif
* Returns path to database.
*
*/
-char *
+char *
GetDatabasePath()
{
return strdup(DatabasePath);
* GetDatabaseName --
* Returns name of database.
*/
-char *
+char *
GetDatabaseName()
{
return strdup(DatabaseName);
}
#ifdef CYR_RECODE
-#define MAX_TOKEN 80
+#define MAX_TOKEN 80
/* Some standard C libraries, including GNU, have an isblank() function.
Others, including Solaris, do not. So we have our own.
while (c != '\n' && c != EOF);
}
-void SetCharSet()
+void
+SetCharSet()
{
- FILE *file;
- char *p,c,eof=false;
- char *map_file;
- char buf[MAX_TOKEN];
- int i;
- unsigned char FromChar,ToChar;
-
- for(i=0; i<128; i++)
- {
- RecodeForwTable[i] = i+128;
- RecodeBackTable[i] = i+128;
- }
-
- p = getenv("PG_RECODETABLE");
- if (p && *p != '\0')
- {
- map_file = (char *) malloc((strlen(DataDir) +
- strlen(p)+2)*sizeof(char));
- sprintf(map_file, "%s/%s", DataDir, p);
- file = fopen(map_file, "r");
- if (file == NULL)
- return;
- eof=false;
- while (!eof)
- {
- c = getc(file);
- ungetc(c, file);
- if (c == EOF)
- eof = true;
- else
- {
- if (c == '#')
- read_through_eol(file);
- else
- {
- /* Read the FromChar */
- next_token(file, buf, sizeof(buf));
- if (buf[0] != '\0')
- {
- FromChar = strtoul(buf,0,0);
- /* Read the ToChar */
- next_token(file, buf, sizeof(buf));
- if (buf[0] != '\0')
- {
- ToChar = strtoul(buf,0,0);
- RecodeForwTable[FromChar-128] = ToChar;
- RecodeBackTable[ToChar-128] = FromChar;
- }
- read_through_eol(file);
- }
- }
- }
- }
- fclose(file);
- free(map_file);
- }
+ FILE *file;
+ char *p,
+ c,
+ eof = false;
+ char *map_file;
+ char buf[MAX_TOKEN];
+ int i;
+ unsigned char FromChar,
+ ToChar;
+
+ for (i = 0; i < 128; i++)
+ {
+ RecodeForwTable[i] = i + 128;
+ RecodeBackTable[i] = i + 128;
+ }
+
+ p = getenv("PG_RECODETABLE");
+ if (p && *p != '\0')
+ {
+ map_file = (char *) malloc((strlen(DataDir) +
+ strlen(p) + 2) * sizeof(char));
+ sprintf(map_file, "%s/%s", DataDir, p);
+ file = fopen(map_file, "r");
+ if (file == NULL)
+ return;
+ eof = false;
+ while (!eof)
+ {
+ c = getc(file);
+ ungetc(c, file);
+ if (c == EOF)
+ eof = true;
+ else
+ {
+ if (c == '#')
+ read_through_eol(file);
+ else
+ {
+ /* Read the FromChar */
+ next_token(file, buf, sizeof(buf));
+ if (buf[0] != '\0')
+ {
+ FromChar = strtoul(buf, 0, 0);
+ /* Read the ToChar */
+ next_token(file, buf, sizeof(buf));
+ if (buf[0] != '\0')
+ {
+ ToChar = strtoul(buf, 0, 0);
+ RecodeForwTable[FromChar - 128] = ToChar;
+ RecodeBackTable[ToChar - 128] = FromChar;
+ }
+ read_through_eol(file);
+ }
+ }
+ }
+ }
+ fclose(file);
+ free(map_file);
+ }
}
-char* convertstr(unsigned char *buff,int len,int dest)
+char *
+convertstr(unsigned char *buff, int len, int dest)
{
- int i;
- char *ch=buff;
- for (i = 0; i < len; i++,buff++)
- {
- if (*buff >127)
- if (dest)
- *buff = RecodeForwTable[*buff-128];
- else
- *buff = RecodeBackTable[*buff-128];
- }
- return ch;
+ int i;
+ char *ch = buff;
+
+ for (i = 0; i < len; i++, buff++)
+ {
+ if (*buff > 127)
+ if (dest)
+ *buff = RecodeForwTable[*buff - 128];
+ else
+ *buff = RecodeBackTable[*buff - 128];
+ }
+ return ch;
}
+
#endif
/* ----------------
* in pg_proc.h). Define GetPgUserName() as a macro - tgl 97/04/26
* ----------------
*/
-char *
+char *
getpgusername()
{
return UserName;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/init/postinit.c,v 1.24 1998/02/23 18:43:06 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/init/postinit.c,v 1.25 1998/02/26 04:38:12 momjian Exp $
*
* NOTES
* InitPostgres() is the function called from PostgresMain
#include "storage/bufmgr.h"
#include "access/transam.h" /* XXX dependency problem */
#include "utils/syscache.h"
-#include "storage/bufpage.h" /* for page layout, for InitMyDatabaseInfo() */
+#include "storage/bufpage.h" /* for page layout, for
+ * InitMyDatabaseInfo() */
#include "storage/sinval.h"
#include "storage/sinvaladt.h"
#include "storage/lmgr.h"
{
Oid owner;
char *path,
- myPath[MAXPGPATH+1];
+ myPath[MAXPGPATH + 1];
SetDatabaseName(name);
GetRawDatabaseInfo(name, &owner, &MyDatabaseId, myPath);
SetDatabasePath(path);
return;
-} /* InitMyDatabaseInfo() */
+} /* InitMyDatabaseInfo() */
/*
ValidatePgVersion(DataDir, &reason);
if (reason != NULL)
sprintf(errormsg,
- "InitPostgres could not validate that the database"
- " system version is compatible with this level of"
- " Postgres.\n\tYou may need to run initdb to create"
- " a new database system.\n\t%s", reason);
+ "InitPostgres could not validate that the database"
+ " system version is compatible with this level of"
+ " Postgres.\n\tYou may need to run initdb to create"
+ " a new database system.\n\t%s", reason);
}
if (errormsg[0] != '\0')
elog(FATAL, errormsg);
/* Above does not return */
-} /* VerifySystemDatabase() */
+} /* VerifySystemDatabase() */
static void
if ((fd = open(myPath, O_RDONLY, 0)) == -1)
sprintf(errormsg,
- "Database '%s' does not exist."
+ "Database '%s' does not exist."
"\n\tWe know this because the directory '%s' does not exist."
- "\n\tYou can create a database with the SQL command"
- " CREATE DATABASE.\n\tTo see what databases exist,"
- " look at the subdirectories of '%s/base/'.",
- name, myPath, DataDir);
+ "\n\tYou can create a database with the SQL command"
+ " CREATE DATABASE.\n\tTo see what databases exist,"
+ " look at the subdirectories of '%s/base/'.",
+ name, myPath, DataDir);
else
{
close(fd);
ValidatePgVersion(myPath, &reason);
if (reason != NULL)
sprintf(errormsg,
- "InitPostgres could not validate that the database"
- " version is compatible with this level of Postgres"
- "\n\teven though the database system as a whole"
- " appears to be at a compatible level."
- "\n\tYou may need to recreate the database with SQL"
- " commands DROP DATABASE and CREATE DATABASE."
- "\n\t%s", reason);
+ "InitPostgres could not validate that the database"
+ " version is compatible with this level of Postgres"
+ "\n\teven though the database system as a whole"
+ " appears to be at a compatible level."
+ "\n\tYou may need to recreate the database with SQL"
+ " commands DROP DATABASE and CREATE DATABASE."
+ "\n\t%s", reason);
else
{
+
/*
* The directories and PG_VERSION files are in order.
*/
- int rc; /* return code from some function we call */
+ int rc; /* return code from some function we call */
#ifdef FILEDEBUG
-printf("Try changing directory for database %s to %s\n", name, myPath);
+ printf("Try changing directory for database %s to %s\n", name, myPath);
#endif
rc = chdir(myPath);
if (rc < 0)
sprintf(errormsg,
- "InitPostgres unable to change "
- "current directory to '%s', errno = %s (%d).",
- myPath, strerror(errno), errno);
+ "InitPostgres unable to change "
+ "current directory to '%s', errno = %s (%d).",
+ myPath, strerror(errno), errno);
else
errormsg[0] = '\0';
}
if (errormsg[0] != '\0')
elog(FATAL, errormsg);
/* Above does not return */
-} /* VerifyMyDatabase() */
+} /* VerifyMyDatabase() */
/* --------------------------------
static void
InitCommunication()
{
- char *postid; /* value of environment variable */
- char *postport; /* value of environment variable */
- char *ipc_key; /* value of environemnt variable */
+ char *postid; /* value of environment variable */
+ char *postport; /* value of environment variable */
+ char *ipc_key; /* value of environemnt variable */
IPCKey key = 0;
/* ----------------
}
- ipc_key = getenv("IPC_KEY");
- if (!PointerIsValid(ipc_key)) {
- key = -1;
- } else {
- key = atoi(ipc_key);
- Assert(MyBackendTag >= 0);
- }
-
+ ipc_key = getenv("IPC_KEY");
+ if (!PointerIsValid(ipc_key))
+ {
+ key = -1;
+ }
+ else
+ {
+ key = atoi(ipc_key);
+ Assert(MyBackendTag >= 0);
+ }
+
postport = getenv("POSTPORT");
if (PointerIsValid(postport))
* To enable emulation, run the following shell commands (in addition
* to enabling this goto)
*
- * % setenv POSTID 1
- * % setenv POSTPORT 4321
- * % setenv IPC_KEY 4321000
- * % postmaster &
- * % kill -9 %1
+ * % setenv POSTID 1 % setenv POSTPORT 4321 % setenv IPC_KEY 4321000
+ * % postmaster & % kill -9 %1
*
* Upon doing this, Postmaster will have allocated the shared memory
* resources that Postgres will attach to if you enable
/*
* ********************************
+ *
* code after this point assumes we are in the proper directory!
*
- * So, how do we implement alternate locations for databases?
- * There are two possible locations for tables and we need to look
- * in DataDir/pg_database to find the true location of an
- * individual database. We can brute-force it as done in
- * InitMyDatabaseInfo(), or we can be patient and wait until we
- * open pg_database gracefully. Will try that, but may not work...
- * - thomas 1997-11-01
- * ********************************
+ * So, how do we implement alternate locations for databases? There are
+ * two possible locations for tables and we need to look in
+ * DataDir/pg_database to find the true location of an individual
+ * database. We can brute-force it as done in InitMyDatabaseInfo(), or
+ * we can be patient and wait until we open pg_database gracefully.
+ * Will try that, but may not work... - thomas 1997-11-01 ********************************
+ *
*/
- /* Does not touch files (?) - thomas 1997-11-01 */
+ /* Does not touch files (?) - thomas 1997-11-01 */
smgrinit();
/* ----------------
* after initdb is done. -mer 15 June 1992
*/
RelationInitialize(); /* pre-allocated reldescs created here */
- InitializeTransactionSystem(); /* pg_log,etc init/crash recovery here */
+ InitializeTransactionSystem(); /* pg_log,etc init/crash recovery
+ * here */
LockDisable(false);
/* ----------------
* initialize the access methods.
- * Does not touch files (?) - thomas 1997-11-01
+ * Does not touch files (?) - thomas 1997-11-01
* ----------------
*/
initam();
* ----------------
*/
zerocaches();
- /* Does not touch files since all routines are builtins (?)
- * - thomas 1997-11-01
+
+ /*
+ * Does not touch files since all routines are builtins (?) - thomas
+ * 1997-11-01
*/
InitCatalogCache();
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/misc/Attic/database.c,v 1.6 1998/01/31 04:39:07 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/misc/Attic/database.c,v 1.7 1998/02/26 04:38:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
Oid dbowner,
dbid;
- char dbpath[MAXPGPATH+1];
+ char dbpath[MAXPGPATH + 1];
text *dbtext;
Relation dbrel;
- HeapTuple dbtup;
- HeapTuple tup;
- Buffer buf;
+ HeapTuple dbtup;
+ HeapTuple tup;
+ Buffer buf;
HeapScanDesc scan;
ScanKeyData scanKey;
dbrel = heap_openr(DatabaseRelationName);
if (!RelationIsValid(dbrel))
- elog(FATAL,"GetDatabaseInfo: cannot open relation \"%-.*s\"",
- DatabaseRelationName);
+ elog(FATAL, "GetDatabaseInfo: cannot open relation \"%-.*s\"",
+ DatabaseRelationName);
ScanKeyEntryInitialize(&scanKey, 0, Anum_pg_database_datname,
- NameEqualRegProcedure, NameGetDatum(name));
+ NameEqualRegProcedure, NameGetDatum(name));
scan = heap_beginscan(dbrel, 0, false, 1, &scanKey);
if (!HeapScanIsValid(scan))
if (!HeapTupleIsValid(dbtup))
{
- elog(NOTICE,"GetDatabaseInfo: %s entry not found %s",
- DatabaseRelationName,name);
+ elog(NOTICE, "GetDatabaseInfo: %s entry not found %s",
+ DatabaseRelationName, name);
return TRUE;
}
dbowner = (Oid) heap_getattr(dbtup,
- Anum_pg_database_datdba,
- RelationGetTupleDescriptor(dbrel),
- (char *) NULL);
+ Anum_pg_database_datdba,
+ RelationGetTupleDescriptor(dbrel),
+ (char *) NULL);
dbid = dbtup->t_oid;
-
+
dbtext = (text *) heap_getattr(dbtup,
- Anum_pg_database_datpath,
- RelationGetTupleDescriptor(dbrel),
- (char *) NULL);
+ Anum_pg_database_datpath,
+ RelationGetTupleDescriptor(dbrel),
+ (char *) NULL);
- memcpy(dbpath, VARDATA(dbtext), (VARSIZE(dbtext)-VARHDRSZ));
- *(dbpath+(VARSIZE(dbtext)-VARHDRSZ)) = '\0';
+ memcpy(dbpath, VARDATA(dbtext), (VARSIZE(dbtext) - VARHDRSZ));
+ *(dbpath + (VARSIZE(dbtext) - VARHDRSZ)) = '\0';
heap_close(dbrel);
owner = palloc(sizeof(Oid));
*owner = dbowner;
- path = palloc(strlen(dbpath)+1);
+ path = palloc(strlen(dbpath) + 1);
strcpy(path, dbpath);
return FALSE;
-} /* GetDatabaseInfo() */
+} /* GetDatabaseInfo() */
char *
ExpandDatabasePath(char *dbpath)
{
char *path;
char *cp;
- char buf[MAXPGPATH+1];
+ char buf[MAXPGPATH + 1];
/* leading path delimiter? then already absolute path */
if (*dbpath == SEP_CHAR)
{
cp = strrchr(dbpath, SEP_CHAR);
- strncpy(buf,dbpath,(cp-dbpath));
- sprintf(&buf[cp-dbpath], "%cbase%c%s", SEP_CHAR, SEP_CHAR, (cp+1));
+ strncpy(buf, dbpath, (cp - dbpath));
+ sprintf(&buf[cp - dbpath], "%cbase%c%s", SEP_CHAR, SEP_CHAR, (cp + 1));
}
/* path delimiter somewhere? then has leading environment variable */
else if (strchr(dbpath, SEP_CHAR) != NULL)
{
cp = strchr(dbpath, SEP_CHAR);
- strncpy(buf,dbpath,(cp-dbpath));
- buf[cp-dbpath] = '\0';
+ strncpy(buf, dbpath, (cp - dbpath));
+ buf[cp - dbpath] = '\0';
path = getenv(buf);
- /* problem getting environment variable? let calling routine handle it */
+
+ /*
+ * problem getting environment variable? let calling routine
+ * handle it
+ */
if (path == NULL)
return path;
- sprintf(buf, "%s%cbase%c%s", path, SEP_CHAR, SEP_CHAR, (cp+1));
+ sprintf(buf, "%s%cbase%c%s", path, SEP_CHAR, SEP_CHAR, (cp + 1));
}
/* no path delimiter? then add the default path prefixes */
else
sprintf(buf, "%s%cbase%c%s", DataDir, SEP_CHAR, SEP_CHAR, dbpath);
}
- path = palloc(strlen(buf)+1);
- strcpy(path,buf);
+ path = palloc(strlen(buf) + 1);
+ strcpy(path, buf);
return path;
-} /* ExpandDatabasePath() */
+} /* ExpandDatabasePath() */
/* --------------------------------
{
*db_id = tup->t_oid;
strncpy(path, VARDATA(&(tup_db->datpath)),
- (VARSIZE(&(tup_db->datpath))-VARHDRSZ));
- *(path+VARSIZE(&(tup_db->datpath))-VARHDRSZ) = '\0';
+ (VARSIZE(&(tup_db->datpath)) - VARHDRSZ));
+ *(path + VARSIZE(&(tup_db->datpath)) - VARHDRSZ) = '\0';
goto done;
}
done:
close(dbfd);
pfree(pg);
-} /* GetRawDatabaseInfo() */
+} /* GetRawDatabaseInfo() */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/mcxt.c,v 1.6 1997/09/08 21:49:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/mcxt.c,v 1.7 1998/02/26 04:38:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* BadArgumentsErr if firstTime is true for subsequent calls.
*/
#ifdef NOT_USED
-char *
+char *
MemoryContextGetName(MemoryContext context)
{
AssertState(MemoryContextEnabled);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/Attic/palloc.c,v 1.5 1997/09/08 02:32:17 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/Attic/palloc.c,v 1.6 1998/02/26 04:38:22 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* NonallocatedPointer if pointer was not returned by palloc or repalloc
* or may have been subsequently freed.
*/
-void *
+void *
palloc(Size size)
{
#ifdef PALLOC_IS_MALLOC
* NonallocatedPointer if pointer was not returned by palloc or repalloc
* or may have been freed already.
*/
-void *
+void *
repalloc(void *pointer, Size size)
{
#ifdef PALLOC_IS_MALLOC
/* pstrdup
allocates space for and copies a string
just like strdup except it uses palloc instead of malloc */
-char *
+char *
pstrdup(char *string)
{
char *nstr;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/portalmem.c,v 1.9 1997/09/18 20:22:36 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/portalmem.c,v 1.10 1998/02/26 04:38:23 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* BadState if called when disabled.
* BadArg if portal is invalid.
*/
-EState *
+EState *
PortalGetState(Portal portal)
{
AssertState(PortalManagerEnabled);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/lselect.c,v 1.12 1998/02/11 19:13:37 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/lselect.c,v 1.13 1998/02/26 04:38:25 momjian Exp $
*
*-------------------------------------------------------------------------
*/
else
*treep = lmerge(tp->lt_left, tp->lt_right, context);
- pfree (tp);
+ pfree(tp);
return (tup);
}
int
tuplecmp(HeapTuple ltup, HeapTuple rtup, LeftistContext context)
{
- Datum lattr,
+ Datum lattr,
rattr;
int nkey = 0;
int result = 0;
if (context->scanKeys[nkey].sk_flags & SK_COMMUTE)
{
if (!(result =
- (long) (*fmgr_faddr(&context->scanKeys[nkey].sk_func)) (rattr, lattr)))
+ (long) (*fmgr_faddr(&context->scanKeys[nkey].sk_func)) (rattr, lattr)))
result =
-(long) (*fmgr_faddr(&context->scanKeys[nkey].sk_func)) (lattr, rattr);
}
else if (!(result =
- (long) (*fmgr_faddr(&context->scanKeys[nkey].sk_func)) (lattr, rattr)))
+ (long) (*fmgr_faddr(&context->scanKeys[nkey].sk_func)) (lattr, rattr)))
result =
-(long) (*fmgr_faddr(&context->scanKeys[nkey].sk_func)) (rattr, lattr);
nkey++;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/psort.c,v 1.38 1998/02/23 06:27:39 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/psort.c,v 1.39 1998/02/26 04:38:29 momjian Exp $
*
* NOTES
* Sorts the first relation into the second relation.
#include "utils/psort.h"
#include "utils/rel.h"
-static bool createfirstrun(Sort * node);
-static bool createrun(Sort * node, FILE * file);
-static void destroytape(FILE * file);
-static void dumptuples(FILE * file, Sort * node);
+static bool createfirstrun(Sort *node);
+static bool createrun(Sort *node, FILE *file);
+static void destroytape(FILE *file);
+static void dumptuples(FILE *file, Sort *node);
static FILE *gettape(void);
-static void initialrun(Sort * node);
-static void inittapes(Sort * node);
-static void merge(Sort * node, struct tape * dest);
-static FILE *mergeruns(Sort * node);
+static void initialrun(Sort *node);
+static void inittapes(Sort *node);
+static void merge(Sort *node, struct tape * dest);
+static FILE *mergeruns(Sort *node);
static HeapTuple tuplecopy(HeapTuple tup);
-static int _psort_cmp (HeapTuple *ltup, HeapTuple *rtup);
+static int _psort_cmp(HeapTuple *ltup, HeapTuple *rtup);
#define TEMPDIR "./"
-/*
+/*
* tlenzero used to delimit runs; both vars below must have
* the same size as HeapTuple->t_len
*/
static unsigned int tlenzero = 0;
static unsigned int tlendummy;
-static TupleDesc PsortTupDesc;
-static ScanKey PsortKeys; /* used by _psort_cmp */
-static int PsortNkeys;
+static TupleDesc PsortTupDesc;
+static ScanKey PsortKeys; /* used by _psort_cmp */
+static int PsortNkeys;
/*
* old psort global variables
* Allocates and initializes sort node's psort state.
*/
bool
-psort_begin(Sort * node, int nkeys, ScanKey key)
+psort_begin(Sort *node, int nkeys, ScanKey key)
{
node->psortstate = (struct Psortstate *) palloc(sizeof(struct Psortstate));
* number of allocated tapes
*/
static void
-inittapes(Sort * node)
+inittapes(Sort *node)
{
- int i;
+ int i;
struct tape *tp;
Assert(node != (Sort *) NULL);
#define USEMEM(NODE,AMT) PS(node)->treeContext.sortMem -= (AMT)
#define FREEMEM(NODE,AMT) PS(node)->treeContext.sortMem += (AMT)
-#define LACKMEM(NODE) (PS(node)->treeContext.sortMem <= BLCKSZ) /* not accurate */
+#define LACKMEM(NODE) (PS(node)->treeContext.sortMem <= BLCKSZ) /* not accurate */
#define TRACEMEM(FUNC)
#define TRACEOUT(FUNC, TUP)
* Also, perhaps allocate tapes when needed. Split into 2 funcs.
*/
static void
-initialrun(Sort * node)
+initialrun(Sort *node)
{
/* struct tuple *tup; */
struct tape *tp;
if (createfirstrun(node))
{
- Assert (PS(node)->using_tape_files);
+ Assert(PS(node)->using_tape_files);
extrapasses = 0;
}
- else /* all tuples fetched */
+ else
+/* all tuples fetched */
{
- if ( !PS(node)->using_tape_files ) /* empty or sorted in memory */
+ if (!PS(node)->using_tape_files) /* empty or sorted in
+ * memory */
return;
- /*
+
+ /*
* if PS(node)->Tuples == NULL then we have single (sorted) run
- * which can be used as result grab file! So, we may avoid
+ * which can be used as result grab file! So, we may avoid
* mergeruns - it will just copy this run to new file.
*/
- if ( PS(node)->Tuples == NULL )
+ if (PS(node)->Tuples == NULL)
{
PS(node)->psort_grab_file = PS(node)->Tape->tp_file;
- rewind (PS(node)->psort_grab_file);
+ rewind(PS(node)->psort_grab_file);
return;
}
extrapasses = 2;
}
/*
- * createfirstrun - tries to sort tuples in memory using qsort
+ * createfirstrun - tries to sort tuples in memory using qsort
* until LACKMEM; if not enough memory then switches
* to tape method
*
static bool
createfirstrun(Sort *node)
{
- HeapTuple tup;
- bool foundeor = false;
- HeapTuple *memtuples;
- int t_last = -1;
- int t_free = 1000;
- TupleTableSlot *cr_slot;
+ HeapTuple tup;
+ bool foundeor = false;
+ HeapTuple *memtuples;
+ int t_last = -1;
+ int t_free = 1000;
+ TupleTableSlot *cr_slot;
Assert(node != (Sort *) NULL);
Assert(PS(node) != (Psortstate *) NULL);
Assert(PS(node)->memtuples == NULL);
Assert(PS(node)->tupcount == 0);
if (LACKMEM(node))
- elog (FATAL, "psort: LACKMEM in createfirstrun");
-
+ elog(FATAL, "psort: LACKMEM in createfirstrun");
+
memtuples = palloc(t_free * sizeof(HeapTuple));
-
+
for (;;)
{
- if ( LACKMEM (node) )
+ if (LACKMEM(node))
break;
-
+
/*
* About to call ExecProcNode, it can mess up the state if it
* eventually calls another Sort node. So must stow it away here
foundeor = true;
break;
}
-
+
tup = tuplecopy(cr_slot->val);
ExecClearTuple(cr_slot);
IncrProcessed();
USEMEM(node, tup->t_len);
TRACEMEM(createfirstrun);
- if ( t_free <= 0 )
+ if (t_free <= 0)
{
- t_free = 1000;
- memtuples = repalloc (memtuples,
- (t_last + t_free + 1) * sizeof (HeapTuple));
+ t_free = 1000;
+ memtuples = repalloc(memtuples,
+ (t_last + t_free + 1) * sizeof(HeapTuple));
}
t_last++;
t_free--;
memtuples[t_last] = tup;
}
-
- if ( t_last < 0 ) /* empty */
+
+ if (t_last < 0) /* empty */
{
- Assert (foundeor);
- pfree (memtuples);
+ Assert(foundeor);
+ pfree(memtuples);
return (false);
}
t_last++;
PsortTupDesc = PS(node)->treeContext.tupDesc;
PsortKeys = PS(node)->treeContext.scanKeys;
PsortNkeys = PS(node)->treeContext.nKeys;
- qsort (memtuples, t_last, sizeof (HeapTuple),
- (int (*)(const void *,const void *))_psort_cmp);
-
- if ( LACKMEM (node) ) /* in-memory sort is impossible */
+ qsort(memtuples, t_last, sizeof(HeapTuple),
+ (int (*) (const void *, const void *)) _psort_cmp);
+
+ if (LACKMEM(node)) /* in-memory sort is impossible */
{
- int t;
-
- Assert (!foundeor);
+ int t;
+
+ Assert(!foundeor);
inittapes(node);
/* put tuples into leftist tree for createrun */
- for (t = t_last - 1 ; t >= 0; t--)
+ for (t = t_last - 1; t >= 0; t--)
puttuple(&PS(node)->Tuples, memtuples[t], 0, &PS(node)->treeContext);
- pfree (memtuples);
- foundeor = !createrun (node, PS(node)->Tape->tp_file);
+ pfree(memtuples);
+ foundeor = !createrun(node, PS(node)->Tape->tp_file);
}
else
{
- Assert (foundeor);
+ Assert(foundeor);
PS(node)->memtuples = memtuples;
}
-
+
return (!foundeor);
}
* Tuples contains the tuples for the following run upon exit
*/
static bool
-createrun(Sort * node, FILE * file)
+createrun(Sort *node, FILE *file)
{
HeapTuple lasttuple;
HeapTuple tup;
- TupleTableSlot *cr_slot;
- HeapTuple *memtuples;
- int t_last = -1;
- int t_free = 1000;
- bool foundeor = false;
- short junk;
+ TupleTableSlot *cr_slot;
+ HeapTuple *memtuples;
+ int t_last = -1;
+ int t_free = 1000;
+ bool foundeor = false;
+ short junk;
Assert(node != (Sort *) NULL);
Assert(PS(node) != (Psortstate *) NULL);
- Assert (PS(node)->using_tape_files);
+ Assert(PS(node)->using_tape_files);
lasttuple = NULL;
memtuples = palloc(t_free * sizeof(HeapTuple));
-
+
for (;;)
{
while (LACKMEM(node) && PS(node)->Tuples != NULL)
TRACEMEM(createrun);
}
lasttuple = gettuple(&PS(node)->Tuples, &junk,
- &PS(node)->treeContext);
+ &PS(node)->treeContext);
PUTTUP(node, lasttuple, file);
TRACEOUT(createrun, lasttuple);
}
-
+
if (LACKMEM(node))
break;
-
+
/*
* About to call ExecProcNode, it can mess up the state if it
* eventually calls another Sort node. So must stow it away here
if (lasttuple != NULL && tuplecmp(tup, lasttuple,
&PS(node)->treeContext))
{
- if ( t_free <= 0 )
+ if (t_free <= 0)
{
- t_free = 1000;
- memtuples = repalloc (memtuples,
- (t_last + t_free + 1) * sizeof (HeapTuple));
+ t_free = 1000;
+ memtuples = repalloc(memtuples,
+ (t_last + t_free + 1) * sizeof(HeapTuple));
}
t_last++;
t_free--;
}
dumptuples(file, node);
ENDRUN(file); /* delimit the end of the run */
-
+
t_last++;
/* put tuples for the next run into leftist tree */
- if ( t_last >= 1 )
+ if (t_last >= 1)
{
- int t;
-
+ int t;
+
PsortTupDesc = PS(node)->treeContext.tupDesc;
PsortKeys = PS(node)->treeContext.scanKeys;
PsortNkeys = PS(node)->treeContext.nKeys;
- qsort (memtuples, t_last, sizeof (HeapTuple),
- (int (*)(const void *,const void *))_psort_cmp);
- for (t = t_last - 1 ; t >= 0; t--)
+ qsort(memtuples, t_last, sizeof(HeapTuple),
+ (int (*) (const void *, const void *)) _psort_cmp);
+ for (t = t_last - 1; t >= 0; t--)
puttuple(&PS(node)->Tuples, memtuples[t], 0, &PS(node)->treeContext);
}
-
- pfree (memtuples);
+
+ pfree(memtuples);
return (!foundeor);
}
* file of tuples in order
*/
static FILE *
-mergeruns(Sort * node)
+mergeruns(Sort *node)
{
struct tape *tp;
* (polyphase merge Alg.D(D5)--Knuth, Vol.3, p271)
*/
static void
-merge(Sort * node, struct tape * dest)
+merge(Sort *node, struct tape * dest)
{
- HeapTuple tup;
+ HeapTuple tup;
struct tape *lasttp; /* (TAPE[P]) */
struct tape *tp;
struct leftist *tuples;
- FILE *destfile;
- int times; /* runs left to merge */
- int outdummy; /* complete dummy runs */
- short fromtape;
- unsigned int tuplen;
+ FILE *destfile;
+ int times; /* runs left to merge */
+ int outdummy; /* complete dummy runs */
+ short fromtape;
+ unsigned int tuplen;
Assert(node != (Sort *) NULL);
Assert(PS(node) != (Psortstate *) NULL);
* dumptuples - stores all the tuples in tree into file
*/
static void
-dumptuples(FILE * file, Sort * node)
+dumptuples(FILE *file, Sort *node)
{
struct leftist *tp;
struct leftist *newp;
LeftistContext context = &PS(node)->treeContext;
HeapTuple tup;
- Assert (PS(node)->using_tape_files);
+ Assert(PS(node)->using_tape_files);
tp = *treep;
while (tp != NULL)
* a NULL indicating the last tuple has been processed.
*/
HeapTuple
-psort_grabtuple(Sort * node, bool * should_free)
+psort_grabtuple(Sort *node, bool *should_free)
{
HeapTuple tup;
if (PS(node)->using_tape_files == true)
{
- unsigned int tuplen;
-
+ unsigned int tuplen;
+
*should_free = true;
- if (ScanDirectionIsForward (node->plan.state->es_direction))
+ if (ScanDirectionIsForward(node->plan.state->es_direction))
{
if (PS(node)->all_fetched)
return NULL;
GETTUP(node, tup, tuplen, PS(node)->psort_grab_file);
/* Update current merged sort file position */
- PS(node)->psort_current += tuplen + sizeof (tlendummy);
+ PS(node)->psort_current += tuplen + sizeof(tlendummy);
return tup;
}
else
}
}
/* Backward */
- if (PS(node)->psort_current <= sizeof (tlendummy))
+ if (PS(node)->psort_current <= sizeof(tlendummy))
return NULL;
- /*
- * if all tuples are fetched already then we return last tuple,
+
+ /*
+ * if all tuples are fetched already then we return last tuple,
* else - tuple before last returned.
*/
if (PS(node)->all_fetched)
{
- /* psort_current is pointing to the zero tuplen at the end of file */
- fseek(PS(node)->psort_grab_file,
- PS(node)->psort_current - sizeof (tlendummy), SEEK_SET);
+
+ /*
+ * psort_current is pointing to the zero tuplen at the end of
+ * file
+ */
+ fseek(PS(node)->psort_grab_file,
+ PS(node)->psort_current - sizeof(tlendummy), SEEK_SET);
GETLEN(tuplen, PS(node)->psort_grab_file);
if (PS(node)->psort_current < tuplen)
- elog (FATAL, "psort_grabtuple: too big last tuple len in backward scan");
+ elog(FATAL, "psort_grabtuple: too big last tuple len in backward scan");
PS(node)->all_fetched = false;
}
else
{
/* move to position of end tlen of prev tuple */
- PS(node)->psort_current -= sizeof (tlendummy);
+ PS(node)->psort_current -= sizeof(tlendummy);
fseek(PS(node)->psort_grab_file, PS(node)->psort_current, SEEK_SET);
- GETLEN(tuplen, PS(node)->psort_grab_file); /* get tlen of prev tuple */
+ GETLEN(tuplen, PS(node)->psort_grab_file); /* get tlen of prev
+ * tuple */
if (tuplen == 0)
- elog (FATAL, "psort_grabtuple: tuplen is 0 in backward scan");
- if (PS(node)->psort_current <= tuplen + sizeof (tlendummy))
- { /* prev tuple should be first one */
+ elog(FATAL, "psort_grabtuple: tuplen is 0 in backward scan");
+ if (PS(node)->psort_current <= tuplen + sizeof(tlendummy))
+ { /* prev tuple should be first one */
if (PS(node)->psort_current != tuplen)
- elog (FATAL, "psort_grabtuple: first tuple expected in backward scan");
+ elog(FATAL, "psort_grabtuple: first tuple expected in backward scan");
PS(node)->psort_current = 0;
fseek(PS(node)->psort_grab_file, PS(node)->psort_current, SEEK_SET);
return NULL;
}
- /*
- * Get position of prev tuple. This tuple becomes current tuple
- * now and we have to return previous one.
+
+ /*
+ * Get position of prev tuple. This tuple becomes current
+ * tuple now and we have to return previous one.
*/
PS(node)->psort_current -= tuplen;
/* move to position of end tlen of prev tuple */
- fseek(PS(node)->psort_grab_file,
- PS(node)->psort_current - sizeof (tlendummy), SEEK_SET);
+ fseek(PS(node)->psort_grab_file,
+ PS(node)->psort_current - sizeof(tlendummy), SEEK_SET);
GETLEN(tuplen, PS(node)->psort_grab_file);
- if (PS(node)->psort_current < tuplen + sizeof (tlendummy))
- elog (FATAL, "psort_grabtuple: too big tuple len in backward scan");
+ if (PS(node)->psort_current < tuplen + sizeof(tlendummy))
+ elog(FATAL, "psort_grabtuple: too big tuple len in backward scan");
}
- /*
- * move to prev (or last) tuple start position + sizeof(t_len)
+
+ /*
+ * move to prev (or last) tuple start position + sizeof(t_len)
*/
fseek(PS(node)->psort_grab_file,
- PS(node)->psort_current - tuplen, SEEK_SET);
+ PS(node)->psort_current - tuplen, SEEK_SET);
tup = (HeapTuple) palloc((unsigned) tuplen);
SETTUPLEN(tup, tuplen);
GETTUP(node, tup, tuplen, PS(node)->psort_grab_file);
- return tup; /* file position is equal to psort_current */
+ return tup; /* file position is equal to psort_current */
}
else
{
*should_free = false;
- if (ScanDirectionIsForward (node->plan.state->es_direction))
+ if (ScanDirectionIsForward(node->plan.state->es_direction))
{
if (PS(node)->psort_current < PS(node)->tupcount)
return (PS(node)->memtuples[PS(node)->psort_current++]);
/* Backward */
if (PS(node)->psort_current <= 0)
return NULL;
- /*
- * if all tuples are fetched already then we return last tuple,
+
+ /*
+ * if all tuples are fetched already then we return last tuple,
* else - tuple before last returned.
*/
- if (PS(node)->all_fetched)
+ if (PS(node)->all_fetched)
PS(node)->all_fetched = false;
else
{
- PS(node)->psort_current--; /* last returned tuple */
+ PS(node)->psort_current--; /* last returned tuple */
if (PS(node)->psort_current <= 0)
return NULL;
}
* psort_markpos - saves current position in the merged sort file
*/
void
-psort_markpos(Sort * node)
+psort_markpos(Sort *node)
{
Assert(node != (Sort *) NULL);
Assert(PS(node) != (Psortstate *) NULL);
* last saved position
*/
void
-psort_restorepos(Sort * node)
+psort_restorepos(Sort *node)
{
Assert(node != (Sort *) NULL);
Assert(PS(node) != (Psortstate *) NULL);
* called unless psort_grabtuple has returned a NULL.
*/
void
-psort_end(Sort * node)
+psort_end(Sort *node)
{
struct tape *tp;
if (!node->cleaned)
{
+
/*
* I'm changing this because if we are sorting a relation with no
* tuples, psortstate is NULL.
}
void
-psort_rescan (Sort *node)
+psort_rescan(Sort *node)
{
+
/*
* If subnode is to be rescanned then free our previous results
*/
- if (((Plan*) node)->lefttree->chgParam != NULL)
+ if (((Plan *) node)->lefttree->chgParam != NULL)
{
- psort_end (node);
+ psort_end(node);
node->cleaned = false;
}
else if (PS(node) != (Psortstate *) NULL)
PS(node)->psort_current = 0;
PS(node)->psort_saved = 0;
if (PS(node)->using_tape_files == true)
- rewind (PS(node)->psort_grab_file);
+ rewind(PS(node)->psort_grab_file);
}
}
*/
#ifdef NOT_USED
static void
-resettape(FILE * file)
+resettape(FILE *file)
{
struct tapelst *tp;
- int fd;
+ int fd;
Assert(PointerIsValid(file));
* Exits instead of returning status, if given invalid tape.
*/
static void
-destroytape(FILE * file)
+destroytape(FILE *file)
{
struct tapelst *tp,
*tq;
- int fd;
+ int fd;
if ((tp = Tapes) == NULL)
elog(FATAL, "destroytape: tape not found");
}
static int
-_psort_cmp (HeapTuple *ltup, HeapTuple *rtup)
+_psort_cmp(HeapTuple *ltup, HeapTuple *rtup)
{
- Datum lattr, rattr;
- int nkey;
- int result = 0;
- bool isnull1, isnull2;
-
- for (nkey = 0; nkey < PsortNkeys && !result; nkey++ )
- {
+ Datum lattr,
+ rattr;
+ int nkey;
+ int result = 0;
+ bool isnull1,
+ isnull2;
+
+ for (nkey = 0; nkey < PsortNkeys && !result; nkey++)
+ {
lattr = heap_getattr(*ltup,
- PsortKeys[nkey].sk_attno,
- PsortTupDesc,
- &isnull1);
+ PsortKeys[nkey].sk_attno,
+ PsortTupDesc,
+ &isnull1);
rattr = heap_getattr(*rtup,
- PsortKeys[nkey].sk_attno,
- PsortTupDesc,
- &isnull2);
- if ( isnull1 )
+ PsortKeys[nkey].sk_attno,
+ PsortTupDesc,
+ &isnull2);
+ if (isnull1)
{
- if ( !isnull2 )
+ if (!isnull2)
result = 1;
}
- else if ( isnull2 )
- result = -1;
-
+ else if (isnull2)
+ result = -1;
+
else if (PsortKeys[nkey].sk_flags & SK_COMMUTE)
{
- if (!(result = -(long) (*fmgr_faddr(&PsortKeys[nkey].sk_func)) (rattr, lattr)))
- result = (long) (*fmgr_faddr(&PsortKeys[nkey].sk_func)) (lattr, rattr);
+ if (!(result = -(long) (*fmgr_faddr(&PsortKeys[nkey].sk_func)) (rattr, lattr)))
+ result = (long) (*fmgr_faddr(&PsortKeys[nkey].sk_func)) (lattr, rattr);
}
else if (!(result = -(long) (*fmgr_faddr(&PsortKeys[nkey].sk_func)) (lattr, rattr)))
- result = (long) (*fmgr_faddr(&PsortKeys[nkey].sk_func)) (rattr, lattr);
- }
- return (result);
+ result = (long) (*fmgr_faddr(&PsortKeys[nkey].sk_func)) (rattr, lattr);
+ }
+ return (result);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/time/tqual.c,v 1.13 1997/11/26 03:54:18 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/time/tqual.c,v 1.14 1998/02/26 04:38:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (!(tuple->t_infomask & HEAP_XMIN_COMMITTED))
{
- if (tuple->t_infomask & HEAP_XMIN_INVALID) /* xid invalid or aborted */
+ if (tuple->t_infomask & HEAP_XMIN_INVALID) /* xid invalid or
+ * aborted */
return (false);
-
+
if (TransactionIdIsCurrentTransactionId(tuple->t_xmin))
{
if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
if (!TransactionIdDidCommit(tuple->t_xmin))
{
if (TransactionIdDidAbort(tuple->t_xmin))
- tuple->t_infomask |= HEAP_XMIN_INVALID; /* aborted */
+ tuple->t_infomask |= HEAP_XMIN_INVALID; /* aborted */
return (false);
}
if (!PostgresIsInitialized)
return ((bool) (TransactionIdIsValid(tuple->t_xmin) &&
- !TransactionIdIsValid(tuple->t_xmax)));
+ !TransactionIdIsValid(tuple->t_xmax)));
if (!(tuple->t_infomask & HEAP_XMIN_COMMITTED))
{
- if (tuple->t_infomask & HEAP_XMIN_INVALID) /* xid invalid or aborted */
+ if (tuple->t_infomask & HEAP_XMIN_INVALID) /* xid invalid or
+ * aborted */
return (false);
if (TransactionIdIsCurrentTransactionId(tuple->t_xmin))
{
if (CommandIdGEScanCommandId(tuple->t_cmin))
- return (false); /* inserted after scan started */
+ return (false); /* inserted after scan started */
if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
return (true);
if (CommandIdGEScanCommandId(tuple->t_cmax))
return (true); /* deleted after scan started */
else
- return (false); /* deleted before scan started */
+ return (false); /* deleted before scan started */
}
/*
if (!TransactionIdDidCommit(tuple->t_xmin))
{
if (TransactionIdDidAbort(tuple->t_xmin))
- tuple->t_infomask |= HEAP_XMIN_INVALID; /* aborted */
+ tuple->t_infomask |= HEAP_XMIN_INVALID; /* aborted */
return (false);
}
if (TransactionIdIsCurrentTransactionId(tuple->t_xmax))
{
if (CommandIdGEScanCommandId(tuple->t_cmax))
- return (true); /* deleted after scan started */
+ return (true); /* deleted after scan started */
else
- return (false); /* deleted before scan started */
+ return (false); /* deleted before scan started */
}
if (!TransactionIdDidCommit(tuple->t_xmax))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/pg_dump/common.c,v 1.19 1997/11/21 19:02:50 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/bin/pg_dump/common.c,v 1.20 1998/02/26 04:38:41 momjian Exp $
*
*
* NOTE: should hash this, but just do linear search for now
*/
-char *
+char *
findTypeByOid(TypeInfo *tinfo, int numTypes, const char *oid)
{
int i;
* NOTE: should hash this, but just do linear search for now
*
*/
-char *
+char *
findOprByOid(OprInfo *oprinfo, int numOprs, const char *oid)
{
int i;
static char id[MAXQUERYLEN];
for (cp = rawid; *cp != '\0'; cp++)
- if (! (islower(*cp) || isdigit(*cp) || (*cp == '_'))) break;
+ if (!(islower(*cp) || isdigit(*cp) || (*cp == '_')))
+ break;
- if (*cp != '\0') {
+ if (*cp != '\0')
+ {
strcpy(id, "\"");
strcat(id, rawid);
strcat(id, "\"");
cp = id;
- } else {
+ }
+ else
+ {
cp = rawid;
}
- return(cp);
-} /* fmtId() */
+ return (cp);
+} /* fmtId() */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_dump.c,v 1.63 1998/02/18 15:33:37 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_dump.c,v 1.64 1998/02/26 04:38:54 momjian Exp $
*
*
*
*
- * - Added support for password authentication
+ * - Added support for password authentication
*-------------------------------------------------------------------------
*/
#include "pg_dump.h"
static void dumpSequence(FILE *fout, TableInfo tbinfo);
-static void dumpTriggers(FILE *fout, const char *tablename,
- TableInfo *tblinfo, int numTables);
+static void
+dumpTriggers(FILE *fout, const char *tablename,
+ TableInfo *tblinfo, int numTables);
static char *checkForQuote(const char *s);
static void clearTableInfo(TableInfo *, int);
static void
static char *AddAcl(char *s, const char *add);
static char *GetPrivledges(char *s);
-static ACL *ParseACL(const char *acls,int *count);
+static ACL *ParseACL(const char *acls, int *count);
extern char *optarg;
extern int optind,
fprintf(stderr,
"\t -d \t\t dump data as proper insert strings\n");
fprintf(stderr,
- "\t -D \t\t dump data as inserts with attribute names\n");
+ "\t -D \t\t dump data as inserts with attribute names\n");
fprintf(stderr,
"\t -f filename \t\t script output filename\n");
fprintf(stderr,
if (g_verbose)
fprintf(stderr, "%s dumping out the contents of %s of %d tables %s\n",
g_comment_start, all_only, numTables, g_comment_end);
-
+
/* Dump SEQUENCEs first (if dataOnly) */
if (dataOnly)
{
{
if (g_verbose)
fprintf(stderr, "%s dumping out schema of sequence %s %s\n",
- g_comment_start, tblinfo[i].relname, g_comment_end);
+ g_comment_start, tblinfo[i].relname, g_comment_end);
fprintf(fout, "\\connect - %s\n", tblinfo[i].usename);
dumpSequence(fout, tblinfo[i]);
}
/* Skip VIEW relations */
if (isViewRule(tblinfo[i].relname))
continue;
-
- if (tblinfo[i].sequence) /* already dumped */
+
+ if (tblinfo[i].sequence)/* already dumped */
continue;
if (!onlytable || (!strcmp(classname, onlytable)))
const char *dbname = NULL;
const char *pghost = NULL;
const char *pgport = NULL;
- char *tablename = NULL;
+ char *tablename = NULL;
int oids = 0,
acls = 0;
TableInfo *tblinfo;
int numTables;
- char connect_string[512] = "";
- char tmp_string[128];
- char username[64];
- char password[64];
- int use_password = 0;
+ char connect_string[512] = "";
+ char tmp_string[128];
+ char username[64];
+ char password[64];
+ int use_password = 0;
g_verbose = false;
break;
case 't': /* Dump data for this table only */
{
- int i;
+ int i;
tablename = strdup(optarg);
for (i = 0; tablename[i]; i++)
exit(2);
}
- /*g_conn = PQsetdb(pghost, pgport, NULL, NULL, dbname);*/
- if (pghost != NULL) {
- sprintf(tmp_string, "host=%s ", pghost);
- strcat(connect_string, tmp_string);
+ /* g_conn = PQsetdb(pghost, pgport, NULL, NULL, dbname); */
+ if (pghost != NULL)
+ {
+ sprintf(tmp_string, "host=%s ", pghost);
+ strcat(connect_string, tmp_string);
}
- if (pgport != NULL) {
- sprintf(tmp_string, "port=%s ", pgport);
- strcat(connect_string, tmp_string);
+ if (pgport != NULL)
+ {
+ sprintf(tmp_string, "port=%s ", pgport);
+ strcat(connect_string, tmp_string);
}
- if (dbname != NULL) {
- sprintf(tmp_string, "dbname=%s ", dbname);
- strcat(connect_string, tmp_string);
+ if (dbname != NULL)
+ {
+ sprintf(tmp_string, "dbname=%s ", dbname);
+ strcat(connect_string, tmp_string);
}
- if (use_password) {
- prompt_for_password(username, password);
- strcat(connect_string, "authtype=password ");
- sprintf(tmp_string, "user=%s ", username);
- strcat(connect_string, tmp_string);
- sprintf(tmp_string, "password=%s ", password);
- strcat(connect_string, tmp_string);
- bzero(tmp_string, sizeof(tmp_string));
- bzero(password, sizeof(password));
+ if (use_password)
+ {
+ prompt_for_password(username, password);
+ strcat(connect_string, "authtype=password ");
+ sprintf(tmp_string, "user=%s ", username);
+ strcat(connect_string, tmp_string);
+ sprintf(tmp_string, "password=%s ", password);
+ strcat(connect_string, tmp_string);
+ bzero(tmp_string, sizeof(tmp_string));
+ bzero(password, sizeof(password));
}
g_conn = PQconnectdb(connect_string);
bzero(connect_string, sizeof(connect_string));
dumpClasses(tblinfo, numTables, g_fout, tablename, oids);
}
- if (!dataOnly) /* dump indexes and triggers at the end for performance */
+ if (!dataOnly) /* dump indexes and triggers at the end
+ * for performance */
{
dumpSchemaIdx(g_fout, tablename, tblinfo, numTables);
dumpTriggers(g_fout, tablename, tblinfo, numTables);
PQclear(res);
sprintf(query,
- "SELECT pg_class.oid, relname, relkind, relacl, usename, "
- "relchecks, reltriggers "
+ "SELECT pg_class.oid, relname, relkind, relacl, usename, "
+ "relchecks, reltriggers "
"from pg_class, pg_user "
"where relowner = usesysid and "
"(relkind = 'r' or relkind = 'S') and relname !~ '^pg_' "
tblinfo[i].usename = strdup(PQgetvalue(res, i, i_usename));
tblinfo[i].ncheck = atoi(PQgetvalue(res, i, i_relchecks));
tblinfo[i].ntrig = atoi(PQgetvalue(res, i, i_reltriggers));
-
+
/* Get CHECK constraints */
if (tblinfo[i].ncheck > 0)
{
PGresult *res2;
- int i_rcname, i_rcsrc;
+ int i_rcname,
+ i_rcsrc;
int ntups2;
int i2;
-
+
if (g_verbose)
fprintf(stderr, "%s finding CHECK constraints for relation: %s %s\n",
g_comment_start,
tblinfo[i].relname,
g_comment_end);
-
+
sprintf(query, "SELECT rcname, rcsrc from pg_relcheck "
"where rcrelid = '%s'::oid ",
tblinfo[i].oid);
res2 = PQexec(g_conn, query);
if (!res2 ||
- PQresultStatus(res2) != PGRES_TUPLES_OK)
+ PQresultStatus(res2) != PGRES_TUPLES_OK)
{
fprintf(stderr, "getTables(): SELECT (for CHECK) failed\n");
exit_nicely(g_conn);
if (ntups2 != tblinfo[i].ncheck)
{
fprintf(stderr, "getTables(): relation %s: %d CHECKs were expected, but got %d\n",
- tblinfo[i].relname, tblinfo[i].ncheck, ntups2);
+ tblinfo[i].relname, tblinfo[i].ncheck, ntups2);
exit_nicely(g_conn);
}
i_rcname = PQfnumber(res2, "rcname");
i_rcsrc = PQfnumber(res2, "rcsrc");
- tblinfo[i].check_expr = (char **) malloc (ntups2 * sizeof (char *));
+ tblinfo[i].check_expr = (char **) malloc(ntups2 * sizeof(char *));
for (i2 = 0; i2 < ntups2; i2++)
{
- char *name = PQgetvalue(res2, i2, i_rcname);
- char *expr = PQgetvalue(res2, i2, i_rcsrc);
-
+ char *name = PQgetvalue(res2, i2, i_rcname);
+ char *expr = PQgetvalue(res2, i2, i_rcsrc);
+
query[0] = 0;
- if ( name[0] != '$' )
- sprintf (query, "CONSTRAINT %s ", name);
- sprintf (query, "%sCHECK %s", query, expr);
- tblinfo[i].check_expr[i2] = strdup (query);
+ if (name[0] != '$')
+ sprintf(query, "CONSTRAINT %s ", name);
+ sprintf(query, "%sCHECK %s", query, expr);
+ tblinfo[i].check_expr[i2] = strdup(query);
}
PQclear(res2);
}
else
tblinfo[i].check_expr = NULL;
-
+
/* Get Triggers */
if (tblinfo[i].ntrig > 0)
{
PGresult *res2;
- int i_tgname, i_tgfoid, i_tgtype, i_tgnargs, i_tgargs;
+ int i_tgname,
+ i_tgfoid,
+ i_tgtype,
+ i_tgnargs,
+ i_tgargs;
int ntups2;
int i2;
-
+
if (g_verbose)
fprintf(stderr, "%s finding Triggers for relation: %s %s\n",
g_comment_start,
tblinfo[i].relname,
g_comment_end);
-
+
sprintf(query, "SELECT tgname, tgfoid, tgtype, tgnargs, tgargs "
"from pg_trigger "
"where tgrelid = '%s'::oid ",
tblinfo[i].oid);
res2 = PQexec(g_conn, query);
if (!res2 ||
- PQresultStatus(res2) != PGRES_TUPLES_OK)
+ PQresultStatus(res2) != PGRES_TUPLES_OK)
{
fprintf(stderr, "getTables(): SELECT (for TRIGGER) failed\n");
exit_nicely(g_conn);
if (ntups2 != tblinfo[i].ntrig)
{
fprintf(stderr, "getTables(): relation %s: %d Triggers were expected, but got %d\n",
- tblinfo[i].relname, tblinfo[i].ntrig, ntups2);
+ tblinfo[i].relname, tblinfo[i].ntrig, ntups2);
exit_nicely(g_conn);
}
i_tgname = PQfnumber(res2, "tgname");
i_tgtype = PQfnumber(res2, "tgtype");
i_tgnargs = PQfnumber(res2, "tgnargs");
i_tgargs = PQfnumber(res2, "tgargs");
- tblinfo[i].triggers = (char **) malloc (ntups2 * sizeof (char *));
+ tblinfo[i].triggers = (char **) malloc(ntups2 * sizeof(char *));
for (i2 = 0, query[0] = 0; i2 < ntups2; i2++)
{
- char *tgfunc = PQgetvalue(res2, i2, i_tgfoid);
- int2 tgtype = atoi(PQgetvalue(res2, i2, i_tgtype));
- int tgnargs = atoi(PQgetvalue(res2, i2, i_tgnargs));
- char *tgargs = PQgetvalue(res2, i2, i_tgargs);
- char *p;
- char farg[MAXQUERYLEN];
- int findx;
-
+ char *tgfunc = PQgetvalue(res2, i2, i_tgfoid);
+ int2 tgtype = atoi(PQgetvalue(res2, i2, i_tgtype));
+ int tgnargs = atoi(PQgetvalue(res2, i2, i_tgnargs));
+ char *tgargs = PQgetvalue(res2, i2, i_tgargs);
+ char *p;
+ char farg[MAXQUERYLEN];
+ int findx;
+
for (findx = 0; findx < numFuncs; findx++)
{
if (strcmp(finfo[findx].oid, tgfunc) == 0 &&
- finfo[findx].lang == ClanguageId &&
- finfo[findx].nargs == 0 &&
+ finfo[findx].lang == ClanguageId &&
+ finfo[findx].nargs == 0 &&
strcmp(finfo[findx].prorettype, "0") == 0)
break;
}
if (findx == numFuncs)
{
fprintf(stderr, "getTables(): relation %s: cannot find function with oid %s for trigger %s\n",
- tblinfo[i].relname, tgfunc, PQgetvalue(res2, i2, i_tgname));
+ tblinfo[i].relname, tgfunc, PQgetvalue(res2, i2, i_tgname));
exit_nicely(g_conn);
}
tgfunc = finfo[findx].proname;
- sprintf (query, "CREATE TRIGGER %s ", PQgetvalue(res2, i2, i_tgname));
+ sprintf(query, "CREATE TRIGGER %s ", PQgetvalue(res2, i2, i_tgname));
/* Trigger type */
findx = 0;
if (TRIGGER_FOR_BEFORE(tgtype))
- strcat (query, "BEFORE");
+ strcat(query, "BEFORE");
else
- strcat (query, "AFTER");
+ strcat(query, "AFTER");
if (TRIGGER_FOR_INSERT(tgtype))
{
- strcat (query, " INSERT");
+ strcat(query, " INSERT");
findx++;
}
if (TRIGGER_FOR_DELETE(tgtype))
{
if (findx > 0)
- strcat (query, " OR DELETE");
+ strcat(query, " OR DELETE");
else
- strcat (query, " DELETE");
+ strcat(query, " DELETE");
findx++;
}
if (TRIGGER_FOR_UPDATE(tgtype))
if (findx > 0)
- strcat (query, " OR UPDATE");
+ strcat(query, " OR UPDATE");
else
- strcat (query, " UPDATE");
- sprintf (query, "%s ON %s FOR EACH ROW EXECUTE PROCEDURE %s (",
- query, tblinfo[i].relname, tgfunc);
+ strcat(query, " UPDATE");
+ sprintf(query, "%s ON %s FOR EACH ROW EXECUTE PROCEDURE %s (",
+ query, tblinfo[i].relname, tgfunc);
for (findx = 0; findx < tgnargs; findx++)
{
- char *s, *d;
-
- for (p = tgargs; ; )
+ char *s,
+ *d;
+
+ for (p = tgargs;;)
{
- p = strchr (p, '\\');
+ p = strchr(p, '\\');
if (p == NULL)
{
fprintf(stderr, "getTables(): relation %s: bad argument string (%s) for trigger %s\n",
- tblinfo[i].relname,
- PQgetvalue(res2, i2, i_tgargs),
- PQgetvalue(res2, i2, i_tgname));
+ tblinfo[i].relname,
+ PQgetvalue(res2, i2, i_tgargs),
+ PQgetvalue(res2, i2, i_tgname));
exit_nicely(g_conn);
}
p++;
p++;
continue;
}
- if ( p[0] == '0' && p[1] == '0' && p[2] == '0')
+ if (p[0] == '0' && p[1] == '0' && p[2] == '0')
break;
}
p--;
- for (s = tgargs, d = &(farg[0]); s < p; )
+ for (s = tgargs, d = &(farg[0]); s < p;)
{
if (*s == '\'')
*d++ = '\\';
*d++ = *s++;
}
*d = 0;
- sprintf (query, "%s'%s'%s", query, farg,
- (findx < tgnargs - 1) ? ", " : "");
+ sprintf(query, "%s'%s'%s", query, farg,
+ (findx < tgnargs - 1) ? ", " : "");
tgargs = p + 4;
}
- strcat (query, ");\n");
- tblinfo[i].triggers[i2] = strdup (query);
+ strcat(query, ");\n");
+ tblinfo[i].triggers[i2] = strdup(query);
}
PQclear(res2);
}
if (PQgetvalue(res, j, i_atthasdef)[0] == 't')
{
PGresult *res2;
-
+
if (g_verbose)
fprintf(stderr, "%s finding DEFAULT expression for attr: %s %s\n",
g_comment_start,
tblinfo[i].attnames[j],
g_comment_end);
-
+
sprintf(q, "SELECT adsrc from pg_attrdef "
"where adrelid = '%s'::oid and adnum = %d ",
tblinfo[i].oid, j + 1);
res2 = PQexec(g_conn, q);
if (!res2 ||
- PQresultStatus(res2) != PGRES_TUPLES_OK)
+ PQresultStatus(res2) != PGRES_TUPLES_OK)
{
fprintf(stderr, "getTableAttrs(): SELECT (for DEFAULT) failed\n");
exit_nicely(g_conn);
(finfo[i].retset) ? " SETOF " : "",
fmtId(findTypeByOid(tinfo, numTypes, finfo[i].prorettype)),
(finfo[i].lang == INTERNALlanguageId) ? finfo[i].prosrc :
- (finfo[i].lang == ClanguageId) ? finfo[i].probin :
- (finfo[i].lang == SQLlanguageId) ? finfo[i].prosrc : "unknown",
+ (finfo[i].lang == ClanguageId) ? finfo[i].probin :
+ (finfo[i].lang == SQLlanguageId) ? finfo[i].prosrc : "unknown",
(finfo[i].lang == INTERNALlanguageId) ? "INTERNAL" :
- (finfo[i].lang == ClanguageId) ? "C" :
- (finfo[i].lang == SQLlanguageId) ? "SQL" : "unknown");
+ (finfo[i].lang == ClanguageId) ? "C" :
+ (finfo[i].lang == SQLlanguageId) ? "SQL" : "unknown");
fputs(q, fout);
strcmp(oprinfo[i].oprkind, "b") == 0)
{
sprintf(leftarg, ", LEFTARG = %s ",
- fmtId(findTypeByOid(tinfo, numTypes, oprinfo[i].oprleft)));
+ fmtId(findTypeByOid(tinfo, numTypes, oprinfo[i].oprleft)));
}
if (strcmp(oprinfo[i].oprkind, "l") == 0 ||
strcmp(oprinfo[i].oprkind, "b") == 0)
{
sprintf(rightarg, ", RIGHTARG = %s ",
- fmtId(findTypeByOid(tinfo, numTypes, oprinfo[i].oprright)));
+ fmtId(findTypeByOid(tinfo, numTypes, oprinfo[i].oprright)));
}
if (strcmp(oprinfo[i].oprcom, "0") == 0)
commutator[0] = '\0';
/* skip all the builtin oids */
if (atoi(agginfo[i].oid) < g_last_builtin_oid)
continue;
-
+
sprintf(basetype,
"BASETYPE = %s, ",
- fmtId(findTypeByOid(tinfo, numTypes, agginfo[i].aggbasetype)));
+ fmtId(findTypeByOid(tinfo, numTypes, agginfo[i].aggbasetype)));
if (strcmp(agginfo[i].aggtransfn1, "-") == 0)
sfunc1[0] = '\0';
sprintf(sfunc2,
"SFUNC2 = %s, STYPE2 = %s",
agginfo[i].aggtransfn2,
- fmtId(findTypeByOid(tinfo, numTypes, agginfo[i].aggtranstype2)));
+ fmtId(findTypeByOid(tinfo, numTypes, agginfo[i].aggtranstype2)));
if (agginfo[i].agginitval2)
sprintf(sfunc2, "%s, INITCOND2 = '%s'",
sfunc2, agginfo[i].agginitval2);
static char *
AddAcl(char *s, const char *add)
{
- char *t;
+ char *t;
- if (s == (char *)NULL)
+ if (s == (char *) NULL)
return (strdup(add));
- t=(char *)calloc((strlen(s) + strlen(add)+1),sizeof(char));
- sprintf(t,"%s,%s",s,add);
+ t = (char *) calloc((strlen(s) + strlen(add) + 1), sizeof(char));
+ sprintf(t, "%s,%s", s, add);
- return(t);
+ return (t);
}
+
/*
* This will take a string of 'arwR' and return a
* comma delimited string of SELECT,INSERT,UPDATE,DELETE,RULE
static char *
GetPrivledges(char *s)
{
- char *acls=NULL;
+ char *acls = NULL;
- /*Grant All == arwR */
- /* INSERT == ar */
- /* UPDATE/DELETE == rw */
- /* SELECT == r */
- /* RULE == R */
+ /* Grant All == arwR */
+ /* INSERT == ar */
+ /* UPDATE/DELETE == rw */
+ /* SELECT == r */
+ /* RULE == R */
- if (strstr(s,"arwR"))
- return(strdup("ALL"));
+ if (strstr(s, "arwR"))
+ return (strdup("ALL"));
- if (strstr(s,"ar"))
- acls=AddAcl(acls,"INSERT");
+ if (strstr(s, "ar"))
+ acls = AddAcl(acls, "INSERT");
- if (strstr(s,"rw"))
- acls=AddAcl(acls,"UPDATE,DELETE");
- else
- if (strchr(s,'r'))
- acls=AddAcl(acls,"SELECT");
+ if (strstr(s, "rw"))
+ acls = AddAcl(acls, "UPDATE,DELETE");
+ else if (strchr(s, 'r'))
+ acls = AddAcl(acls, "SELECT");
- if (strchr(s,'R'))
- acls=AddAcl(acls,"RULES");
+ if (strchr(s, 'R'))
+ acls = AddAcl(acls, "RULES");
- return(acls);
+ return (acls);
}
+
/* This will parse the acl string of TableInfo
* into a two deminsional aray:
- * user | Privledges
+ * user | Privledges
* So to reset the acls I need to grant these priviledges
* to user
*/
static ACL *
-ParseACL(const char *acls,int *count)
+ParseACL(const char *acls, int *count)
{
- ACL *ParsedAcl=NULL;
- int i,
- len,
- NumAcls=1, /*There is always public*/
- AclLen=0;
- char *s=NULL,
- *user=NULL,
- *priv=NULL,
- *tok;
-
- AclLen=strlen(acls);
-
- if (AclLen == 0) {
- *count=0;
+ ACL *ParsedAcl = NULL;
+ int i,
+ len,
+ NumAcls = 1, /* There is always public */
+ AclLen = 0;
+ char *s = NULL,
+ *user = NULL,
+ *priv = NULL,
+ *tok;
+
+ AclLen = strlen(acls);
+
+ if (AclLen == 0)
+ {
+ *count = 0;
return (ACL *) NULL;
}
+ for (i = 0; i < AclLen; i++)
if (acls[i] == ',')
NumAcls++;
- ParsedAcl=(ACL *)calloc(AclLen,sizeof(ACL));
- if (!ParsedAcl) {
- fprintf(stderr,"Could not allocate space for ACLS!\n");
+ ParsedAcl = (ACL *) calloc(AclLen, sizeof(ACL));
+ if (!ParsedAcl)
+ {
+ fprintf(stderr, "Could not allocate space for ACLS!\n");
exit_nicely(g_conn);
}
- s=strdup(acls);
-
- /* Setup up public*/
- ParsedAcl[0].user=strdup("Public");
- tok=strtok(s,",");
- ParsedAcl[0].privledges=GetPrivledges(strchr(tok,'='));
-
- /*Do the rest of the users*/
- i=1;
- while ((i < NumAcls) && ((tok=strtok(NULL,",")) != (char *)NULL)) {
- /*User name is string up to = in tok*/
- len=strchr(tok,'=') - tok -1 ;
- user=(char*)calloc(len+1,sizeof(char));
- strncpy(user,tok+1,len);
- if (user[len-1] == '\"')
- user[len-1]=(char)NULL;
- priv=GetPrivledges(tok+len+2);
- ParsedAcl[i].user=user;
- ParsedAcl[i].privledges=priv;
+ s = strdup(acls);
+
+ /* Setup up public */
+ ParsedAcl[0].user = strdup("Public");
+ tok = strtok(s, ",");
+ ParsedAcl[0].privledges = GetPrivledges(strchr(tok, '='));
+
+ /* Do the rest of the users */
+ i = 1;
+ while ((i < NumAcls) && ((tok = strtok(NULL, ",")) != (char *) NULL))
+ {
+ /* User name is string up to = in tok */
+ len = strchr(tok, '=') - tok - 1;
+ user = (char *) calloc(len + 1, sizeof(char));
+ strncpy(user, tok + 1, len);
+ if (user[len - 1] == '\"')
+ user[len - 1] = (char) NULL;
+ priv = GetPrivledges(tok + len + 2);
+ ParsedAcl[i].user = user;
+ ParsedAcl[i].privledges = priv;
i++;
}
- *count=NumAcls;
+ *count = NumAcls;
return (ParsedAcl);
}
+
/*
* dumpTables:
* write out to fout all the user-define tables
char **parentRels; /* list of names of parent relations */
int numParents;
int actual_atts; /* number of attrs in this CREATE statment */
- ACL *ACLlist;
-
+ ACL *ACLlist;
+
/* First - dump SEQUENCEs */
for (i = 0; i < numTables; i++)
{
dumpSequence(fout, tblinfo[i]);
}
}
-
+
for (i = 0; i < numTables; i++)
{
- if (tblinfo[i].sequence) /* already dumped */
+ if (tblinfo[i].sequence)/* already dumped */
continue;
if (!tablename || (!strcmp(tblinfo[i].relname, tablename)))
sprintf(q, "%s(%d)",
q,
- tblinfo[i].atttypmod[j]-VARHDRSZ);
+ tblinfo[i].atttypmod[j] - VARHDRSZ);
actual_atts++;
}
else if (!strcmp(tblinfo[i].typnames[j], "varchar"))
sprintf(q, "%s(%d)",
q,
- tblinfo[i].atttypmod[j]-VARHDRSZ);
+ tblinfo[i].atttypmod[j] - VARHDRSZ);
actual_atts++;
}
else
}
strcat(q, ";\n");
fputs(q, fout);
-
- if (acls) {
+
+ if (acls)
+ {
ACLlist = ParseACL(tblinfo[i].relacl, &l);
- if (ACLlist == (ACL *)NULL)
+ if (ACLlist == (ACL *) NULL)
if (l == 0)
continue;
- else {
- fprintf(stderr,"Could not parse ACL list for %s...Exiting!\n",
- tblinfo[i].relname);
+ else
+ {
+ fprintf(stderr, "Could not parse ACL list for %s...Exiting!\n",
+ tblinfo[i].relname);
exit_nicely(g_conn);
- }
+ }
/* Revoke Default permissions for PUBLIC */
fprintf(fout,
- "REVOKE ALL on %s from PUBLIC;\n",
+ "REVOKE ALL on %s from PUBLIC;\n",
tblinfo[i].relname);
- for(k = 0; k < l; k++) {
- if (ACLlist[k].privledges != (char *)NULL)
+ for (k = 0; k < l; k++)
+ {
+ if (ACLlist[k].privledges != (char *) NULL)
fprintf(fout,
"GRANT %s on %s to %s;\n",
ACLlist[k].privledges, tblinfo[i].relname,
}
-static void
-dumpTriggers(FILE *fout, const char *tablename,
- TableInfo *tblinfo, int numTables)
+static void
+dumpTriggers(FILE *fout, const char *tablename,
+ TableInfo *tblinfo, int numTables)
{
- int i, j;
-
+ int i,
+ j;
+
if (g_verbose)
fprintf(stderr, "%s dumping out triggers %s\n",
g_comment_start, g_comment_end);
-
+
for (i = 0; i < numTables; i++)
{
if (tablename && strcmp(tblinfo[i].relname, tablename))
}
}
}
-
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_dump.h,v 1.29 1998/01/16 23:20:43 momjian Exp $
+ * $Id: pg_dump.h,v 1.30 1998/02/26 04:39:01 momjian Exp $
*
*
*
* Matthew C. Aycock 12/02/97
*/
-typedef struct _AclType {
- char *user;
- char *privledges;
+typedef struct _AclType
+{
+ char *user;
+ char *privledges;
} ACL;
TableInfo *tbinfo, int numTables, const char *tablename);
extern const char *
-fmtId(const char *identifier);
+ fmtId(const char *identifier);
/* largest query string size */
#define MAXQUERYLEN 5000
#include
#include
#if defined(HAVE_STRING_H)
-# include
+#include
#else
-# include
+#include
#endif
#include
#include
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/psql/Attic/psql.c,v 1.135 1998/02/25 14:50:36 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/bin/psql/Attic/psql.c,v 1.136 1998/02/26 04:39:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#ifdef TIOCGWINSZ
struct winsize screen_size;
+
#else
struct winsize
{
int ws_row;
int ws_col;
} screen_size;
+
#endif
/* declarations for functions in this file */
static void
handleCopyIn(PGresult *res, const bool mustprompt,
FILE *copystream);
-static int tableList(PsqlSettings *pset, bool deep_tablelist,
- char info_type, bool system_tables);
+static int
+tableList(PsqlSettings *pset, bool deep_tablelist,
+ char info_type, bool system_tables);
static int tableDesc(PsqlSettings *pset, char *table, FILE *fout);
static int objectDescription(PsqlSettings *pset, char *object, FILE *fout);
static int rightsList(PsqlSettings *pset);
else
fout = stdout;
- /* if you add/remove a line here, change the row test above */
+ /* if you add/remove a line here, change the row test above */
fprintf(fout, " \\? -- help\n");
fprintf(fout, " \\a -- toggle field-alignment (currenty %s)\n", on(pset->opt.align));
fprintf(fout, " \\C [] -- set html3 caption (currently '%s')\n", pset->opt.caption ? pset->opt.caption : "");
*/
int
tableList(PsqlSettings *pset, bool deep_tablelist, char info_type,
- bool system_tables)
+ bool system_tables)
{
char listbuf[512];
int nColumns;
#ifdef TIOCGWINSZ
}
#endif
-
+
listbuf[0] = '\0';
strcat(listbuf, "SELECT usename, relname, relkind, relhasrules ");
strcat(listbuf, "FROM pg_class, pg_user ");
{
/* Display the information */
- fprintf(fout,"\nDatabase = %s\n", PQdb(pset->db));
- fprintf(fout," +------------------+----------------------------------+----------+\n");
- fprintf(fout," | Owner | Relation | Type |\n");
- fprintf(fout," +------------------+----------------------------------+----------+\n");
+ fprintf(fout, "\nDatabase = %s\n", PQdb(pset->db));
+ fprintf(fout, " +------------------+----------------------------------+----------+\n");
+ fprintf(fout, " | Owner | Relation | Type |\n");
+ fprintf(fout, " +------------------+----------------------------------+----------+\n");
/* next, print out the instances */
for (i = 0; i < PQntuples(res); i++)
{
- fprintf(fout," | %-16.16s", PQgetvalue(res, i, 0));
- fprintf(fout," | %-32.32s | ", PQgetvalue(res, i, 1));
+ fprintf(fout, " | %-16.16s", PQgetvalue(res, i, 0));
+ fprintf(fout, " | %-32.32s | ", PQgetvalue(res, i, 1));
rk = PQgetvalue(res, i, 2);
rr = PQgetvalue(res, i, 3);
if (strcmp(rk, "r") == 0)
- fprintf(fout,"%-8.8s |", (rr[0] == 't') ? "view?" : "table");
+ fprintf(fout, "%-8.8s |", (rr[0] == 't') ? "view?" : "table");
else if (strcmp(rk, "i") == 0)
- fprintf(fout,"%-8.8s |", "index");
+ fprintf(fout, "%-8.8s |", "index");
else
- fprintf(fout,"%-8.8s |", "sequence");
- fprintf(fout,"\n");
+ fprintf(fout, "%-8.8s |", "sequence");
+ fprintf(fout, "\n");
}
- fprintf(fout," +------------------+----------------------------------+----------+\n");
+ fprintf(fout, " +------------------+----------------------------------+----------+\n");
PQclear(res);
}
if (usePipe)
/* Display the information */
- fprintf(fout,"\nDatabase = %s\n", PQdb(pset->db));
- fprintf(fout," +------------------+----------------------------------------------------+\n");
- fprintf(fout," | Relation | Grant/Revoke Permissions |\n");
- fprintf(fout," +------------------+----------------------------------------------------+\n");
+ fprintf(fout, "\nDatabase = %s\n", PQdb(pset->db));
+ fprintf(fout, " +------------------+----------------------------------------------------+\n");
+ fprintf(fout, " | Relation | Grant/Revoke Permissions |\n");
+ fprintf(fout, " +------------------+----------------------------------------------------+\n");
/* next, print out the instances */
for (i = 0; i < PQntuples(res); i++)
{
- fprintf(fout," | %-16.16s", PQgetvalue(res, i, 0));
- fprintf(fout," | %-50.50s | ", PQgetvalue(res, i, 1));
- fprintf(fout,"\n");
+ fprintf(fout, " | %-16.16s", PQgetvalue(res, i, 0));
+ fprintf(fout, " | %-50.50s | ", PQgetvalue(res, i, 1));
+ fprintf(fout, "\n");
}
- fprintf(fout," +------------------+----------------------------------------------------+\n");
+ fprintf(fout, " +------------------+----------------------------------------------------+\n");
PQclear(res);
if (usePipe)
{
char *rnotnull;
char *rhasdef;
int i;
- int attlen, atttypmod;
- PGresult *res, *res2;
+ int attlen,
+ atttypmod;
+ PGresult *res,
+ *res2;
int usePipe = 0;
char *pagerenv;
#ifdef TIOCGWINSZ
}
#endif
-
+
/* Build the query */
- /* if the table name is surrounded by double-quotes, then don't convert case */
+ /*
+ * if the table name is surrounded by double-quotes, then don't
+ * convert case
+ */
if (*table == '"')
{
table++;
- if (*(table+strlen(table)-1) == '"')
- *(table+strlen(table)-1) = '\0';
+ if (*(table + strlen(table) - 1) == '"')
+ *(table + strlen(table) - 1) = '\0';
}
else
{
else
fout = stdout;
}
+
/*
- * Display the information
+ * Display the information
*/
- fprintf(fout,"\nTable = %s\n", table);
- fprintf(fout,"+----------------------------------+----------------------------------+-------+\n");
- fprintf(fout,"| Field | Type | Length|\n");
- fprintf(fout,"+----------------------------------+----------------------------------+-------+\n");
+ fprintf(fout, "\nTable = %s\n", table);
+ fprintf(fout, "+----------------------------------+----------------------------------+-------+\n");
+ fprintf(fout, "| Field | Type | Length|\n");
+ fprintf(fout, "+----------------------------------+----------------------------------+-------+\n");
/* next, print out the instances */
for (i = 0; i < PQntuples(res); i++)
{
- char type_str[33];
-
- fprintf(fout,"| %-32.32s | ", PQgetvalue(res, i, 1));
+ char type_str[33];
+
+ fprintf(fout, "| %-32.32s | ", PQgetvalue(res, i, 1));
rtype = PQgetvalue(res, i, 2);
attlen = atoi(PQgetvalue(res, i, 3));
atttypmod = atoi(PQgetvalue(res, i, 4));
strncat(type_str, "[]", 32 - strlen(type_str));
type_str[32] = '\0';
}
-
+
if (rnotnull[0] == 't')
{
- strncat(type_str," not null", 32 - strlen(type_str));
+ strncat(type_str, " not null", 32 - strlen(type_str));
type_str[32] = '\0';
}
if (rhasdef[0] == 't')
strcat(descbuf, PQgetvalue(res, i, 0));
if (!(res2 = PSQLexec(pset, descbuf)))
return -1;
- strcat(type_str," default ");
- strncat(type_str, PQgetvalue(res2, 0, 0), 32-strlen(type_str));
+ strcat(type_str, " default ");
+ strncat(type_str, PQgetvalue(res2, 0, 0), 32 - strlen(type_str));
type_str[32] = '\0';
}
- fprintf(fout,"%-32.32s |", type_str);
+ fprintf(fout, "%-32.32s |", type_str);
if (strcmp(rtype, "text") == 0)
- fprintf(fout,"%6s |", "var");
+ fprintf(fout, "%6s |", "var");
else if (strcmp(rtype, "bpchar") == 0 ||
strcmp(rtype, "varchar") == 0)
- fprintf(fout,"%6i |", atttypmod != -1 ? atttypmod - VARHDRSZ : 0);
+ fprintf(fout, "%6i |", atttypmod != -1 ? atttypmod - VARHDRSZ : 0);
else
{
if (attlen > 0)
- fprintf(fout,"%6i |", attlen);
+ fprintf(fout, "%6i |", attlen);
else
- fprintf(fout,"%6s |", "var");
+ fprintf(fout, "%6s |", "var");
}
- fprintf(fout,"\n");
+ fprintf(fout, "\n");
}
- fprintf(fout,"+----------------------------------+----------------------------------+-------+\n");
+ fprintf(fout, "+----------------------------------+----------------------------------+-------+\n");
PQclear(res);
if (usePipe)
{
#ifdef TIOCGWINSZ
}
#endif
-
+
/* Build the query */
while (isspace(*object))
object++;
-
- /* if the object name is surrounded by double-quotes, then don't convert case */
+
+ /*
+ * if the object name is surrounded by double-quotes, then don't
+ * convert case
+ */
if (*object == '"')
{
object++;
- if (*(object+strlen(object)-1) == '"')
- *(object+strlen(object)-1) = '\0';
+ if (*(object + strlen(object) - 1) == '"')
+ *(object + strlen(object) - 1) = '\0';
}
else
{
}
descbuf[0] = '\0';
- if (strchr(object,'.') != NULL)
+ if (strchr(object, '.') != NULL)
{
- char table[NAMEDATALEN],column[NAMEDATALEN];
+ char table[NAMEDATALEN],
+ column[NAMEDATALEN];
- StrNCpy(table,object,
- ((strchr(object,'.')-object+1) < NAMEDATALEN) ?
- (strchr(object,'.')-object+1) : NAMEDATALEN);
- StrNCpy(column,strchr(object,'.')+1,NAMEDATALEN);
+ StrNCpy(table, object,
+ ((strchr(object, '.') - object + 1) < NAMEDATALEN) ?
+ (strchr(object, '.') - object + 1) : NAMEDATALEN);
+ StrNCpy(column, strchr(object, '.') + 1, NAMEDATALEN);
strcat(descbuf, "SELECT DISTINCT description ");
strcat(descbuf, "FROM pg_class, pg_attribute, pg_description ");
strcat(descbuf, "WHERE pg_class.relname = '");
strcat(descbuf, "pg_attribute.attname = '");
strcat(descbuf, column);
strcat(descbuf, "' and ");
- strcat(descbuf, " pg_attribute.oid = pg_description.objoid " );
+ strcat(descbuf, " pg_attribute.oid = pg_description.objoid ");
if (!(res = PSQLexec(pset, descbuf)))
return -1;
}
else
- {
+ {
strcat(descbuf, "SELECT DISTINCT description ");
strcat(descbuf, "FROM pg_class, pg_description ");
strcat(descbuf, "WHERE pg_class.relname = '");
strcat(descbuf, object);
- strcat(descbuf, "'" );
- strcat(descbuf, " and pg_class.oid = pg_description.objoid " );
+ strcat(descbuf, "'");
+ strcat(descbuf, " and pg_class.oid = pg_description.objoid ");
if (!(res = PSQLexec(pset, descbuf)))
return -1;
else if (PQntuples(res) <= 0)
strcat(descbuf, "WHERE pg_type.typname = '");
strcat(descbuf, object);
strcat(descbuf, "' and ");
- strcat(descbuf, " pg_type.oid = pg_description.objoid " );
+ strcat(descbuf, " pg_type.oid = pg_description.objoid ");
if (!(res = PSQLexec(pset, descbuf)))
return -1;
else if (PQntuples(res) <= 0)
strcat(descbuf, "FROM pg_proc, pg_description ");
strcat(descbuf, "WHERE pg_proc.proname = '");
strcat(descbuf, object);
- strcat(descbuf, "'" );
- strcat(descbuf, " and pg_proc.oid = pg_description.objoid " );
+ strcat(descbuf, "'");
+ strcat(descbuf, " and pg_proc.oid = pg_description.objoid ");
if (!(res = PSQLexec(pset, descbuf)))
return -1;
else if (PQntuples(res) <= 0)
strcat(descbuf, "FROM pg_operator, pg_description ");
strcat(descbuf, "WHERE pg_operator.oprname = '");
strcat(descbuf, object);
- strcat(descbuf, "'" );
+ strcat(descbuf, "'");
/* operator descriptions are attached to the proc */
- strcat(descbuf, " and RegprocToOid(pg_operator.oprcode) = pg_description.objoid " );
+ strcat(descbuf, " and RegprocToOid(pg_operator.oprcode) = pg_description.objoid ");
if (!(res = PSQLexec(pset, descbuf)))
return -1;
else if (PQntuples(res) <= 0)
strcat(descbuf, "FROM pg_aggregate, pg_description ");
strcat(descbuf, "WHERE pg_aggregate.aggname = '");
strcat(descbuf, object);
- strcat(descbuf, "'" );
- strcat(descbuf, " and pg_aggregate.oid = pg_description.objoid " );
+ strcat(descbuf, "'");
+ strcat(descbuf, " and pg_aggregate.oid = pg_description.objoid ");
if (!(res = PSQLexec(pset, descbuf)))
return -1;
}
else
fout = stdout;
}
+
/*
* * Display the information
*/
- fprintf(fout,"\nObject = %s\n", object);
+ fprintf(fout, "\nObject = %s\n", object);
/* next, print out the instances */
for (i = 0; i < PQntuples(res); i++)
- fprintf(fout,"%s\n",PQgetvalue(res, i, 0));
+ fprintf(fout, "%s\n", PQgetvalue(res, i, 0));
PQclear(res);
if (usePipe)
dbparam = PQdb(olddb);
pset->db = PQsetdb(PQhost(olddb), PQport(olddb),
- NULL, NULL, dbparam);
+ NULL, NULL, dbparam);
if (!pset->quiet)
{
if (!new_user)
int status = CMD_SKIP_LINE;
char *optarg;
bool success;
+
/*
* Pointer inside the string to the argument of the slash
* command, assuming it is a one-character slash command. If it's not
}
}
break;
- case 'd': /* \d describe database information */
+ case 'd': /* \d describe database information */
if (strncmp(cmd, "da", 2) == 0)
{
- /* aggregates */
- SendQuery(&success, pset,"\
+ /* aggregates */
+ SendQuery(&success, pset, "\
SELECT a.aggname AS aggname, \
t.typname AS typname, \
obj_description(a.oid) as description \
FROM pg_aggregate a, pg_type t \
WHERE a.aggbasetype = t.oid \
ORDER BY aggname, typname;",
- false, false, 0);
- SendQuery(&success, pset,"\
+ false, false, 0);
+ SendQuery(&success, pset, "\
SELECT a.aggname AS aggname, \
'all types' as all_types, \
obj_description(a.oid) as description \
FROM pg_aggregate a \
WHERE a.aggbasetype = 0 \
ORDER BY aggname;",
- false, false, 0);
+ false, false, 0);
}
else if (strncmp(cmd, "dd", 2) == 0)
- /* descriptions */
- objectDescription(pset, optarg+1, NULL);
+ /* descriptions */
+ objectDescription(pset, optarg + 1, NULL);
else if (strncmp(cmd, "df", 2) == 0)
{
- /* functions/procedures */
- /* we skip in/out funcs by excluding functions that take
- some arguments, but have no types defined for those arguments */
- SendQuery(&success, pset,"\
+ /* functions/procedures */
+
+ /*
+ * we skip in/out funcs by excluding functions that take
+ * some arguments, but have no types defined for those
+ * arguments
+ */
+ SendQuery(&success, pset, "\
SELECT t.typname as return_type, \
p.proname as function, \
substr(oid8types(p.proargtypes),1,20) as arguments, \
(pronargs = 0 or oid8types(p.proargtypes) != '') and \
t.typname != 'bool' \
ORDER BY return_type, function;",
- false, false, 0);
- SendQuery(&success, pset,"\
+ false, false, 0);
+ SendQuery(&success, pset, "\
SELECT t.typname as rtns, \
p.proname as function, \
oid8types(p.proargtypes) as arguments, \
(pronargs = 0 or oid8types(p.proargtypes) != '') and \
t.typname = 'bool' \
ORDER BY rtns, function;",
- false, false, 0);
+ false, false, 0);
}
else if (strncmp(cmd, "di", 2) == 0)
- /* only indices */
+ /* only indices */
tableList(pset, false, 'i', false);
else if (strncmp(cmd, "do", 2) == 0)
{
- /* operators */
- SendQuery(&success, pset,"\
+ /* operators */
+ SendQuery(&success, pset, "\
SELECT o.oprname AS op, \
t0.typname AS result, \
t1.typname AS left_type, \
o.oprleft = t1.oid AND \
o.oprright = t2.oid \
ORDER BY op, result, left_type, right_type;",
- false, false, 0);
- SendQuery(&success, pset,"\
+ false, false, 0);
+ SendQuery(&success, pset, "\
SELECT o.oprname AS left_unary, \
t0.typname AS return_type, \
t1.typname AS operand, \
o.oprkind = 'l' AND \
o.oprright = t1.oid \
ORDER BY left_unary, return_type, operand;",
- false, false, 0);
- SendQuery(&success, pset,"\
+ false, false, 0);
+ SendQuery(&success, pset, "\
SELECT o.oprname AS right_unary, \
t0.typname AS return_type, \
t1.typname AS operand, \
o.oprkind = 'r' AND \
o.oprleft = t1.oid \
ORDER BY right_unary, return_type, operand;",
- false, false, 0);
+ false, false, 0);
}
else if (strncmp(cmd, "ds", 2) == 0)
- /* only sequences */
+ /* only sequences */
tableList(pset, false, 'S', false);
else if (strncmp(cmd, "dS", 2) == 0)
- /* system tables */
+ /* system tables */
tableList(pset, false, 'b', true);
else if (strncmp(cmd, "dt", 2) == 0)
- /* only tables */
+ /* only tables */
tableList(pset, false, 't', false);
else if (strncmp(cmd, "dT", 2) == 0)
- /* types */
- SendQuery(&success, pset,"\
+ /* types */
+ SendQuery(&success, pset, "\
SELECT typname AS type, \
obj_description(oid) as description \
FROM pg_type \
WHERE typrelid = 0 AND \
typname !~ '^_.*' \
ORDER BY type;",
- false, false, 0);
+ false, false, 0);
else if (!optarg)
- /* show tables, sequences and indices */
+ /* show tables, sequences and indices */
tableList(pset, false, 'b', false);
else if (strcmp(optarg, "*") == 0)
{ /* show everything */
tableList(pset, true, 'b', false);
}
else if (strncmp(cmd, "d ", 2) == 0)
- /* describe the specified table */
+ /* describe the specified table */
tableDesc(pset, optarg, NULL);
else
slashUsage(pset);
-
+
break;
case 'e': /* edit */
{
}
free(cmd);
return status;
-} /* HandleSlashCmds() */
+} /* HandleSlashCmds() */
/* MainLoop()
* Main processing loop for reading lines of input
/* We've reached the end of our command input. */
bool success;
bool in_quote;
- bool was_bslash; /* backslash */
+ bool was_bslash; /* backslash */
int paren_level;
char *query_start;
if (query_alloced == false)
{
- if((query = malloc(MAX_QUERY_BUFFER)) == NULL) {
-
+ if ((query = malloc(MAX_QUERY_BUFFER)) == NULL)
+ {
+
perror("Memory Allocation Failed");
- } else {
+ }
+ else
+ {
query_alloced = true;
}
}
*/
if (line == NULL || (!interactive && *line == '\0'))
- { /* No more input. Time to quit, or \i done */
+ { /* No more input. Time to quit, or \i
+ * done */
if (!pset->quiet)
printf("EOF\n");/* Goes on prompt line */
eof = true;
}
line[i] = hold_char;
query_start = line + i;
- break; /* handle command */
+ break; /* handle command */
/* start an extended comment? */
}
if (was_bslash)
was_bslash = false;
- else if (i > 0 && line[i-1] == '\\')
+ else if (i > 0 && line[i - 1] == '\\')
was_bslash = true;
/* inside a quote? */
if (in_quote && (line[i] != '\'' || was_bslash))
{
- /* do nothing */;
+ /* do nothing */ ;
}
- else if (xcomment != NULL) /*inside an extended comment?*/
+ else if (xcomment != NULL) /* inside an extended
+ * comment? */
{
if (line[i] == '*' && line[i + 1] == '/')
{
i++;
}
}
- /* possible backslash command? */
+ /* possible backslash command? */
else if (line[i] == '/' && line[i + 1] == '*')
{
xcomment = line + i;
i++;
}
- /* single-line comment? truncate line */
+ /* single-line comment? truncate line */
else if ((line[i] == '-' && line[i + 1] == '-') ||
(line[i] == '/' && line[i + 1] == '/'))
{
/* print comment at top of query */
if (pset->singleStep)
fprintf(stdout, "%s\n", line + i);
- line[i] = '\0'; /* remove comment */
+ line[i] = '\0'; /* remove comment */
break;
}
else if (line[i] == '\'')
{
in_quote ^= 1;
}
- /* semi-colon? then send query now */
+ /* semi-colon? then send query now */
else if (!paren_level && line[i] == ';')
{
char hold_char = line[i + 1];
successResult &= success;
line[i + 1] = hold_char;
query_start = line + i + 1;
- /* sometimes, people do ';\g', don't execute twice */
+ /* sometimes, people do ';\g', don't execute twice */
if (*query_start && /* keeps us from going off the end */
*query_start == '\\' &&
- *(query_start+1) == 'g')
+ *(query_start + 1) == 'g')
query_start += 2;
querySent = true;
}
free(query);
return successResult;
-} /* MainLoop() */
+} /* MainLoop() */
int
main(int argc, char **argv)
char *singleQuery = NULL;
bool listDatabases = 0;
- int successResult = 1;
+ int successResult = 1;
bool singleSlashCmd = 0;
- int c;
+ int c;
- char *home = NULL; /* Used to store $HOME */
+ char *home = NULL; /* Used to store $HOME */
MemSet(&settings, 0, sizeof settings);
settings.opt.align = 1;
/*
* 20.06.97 ACRM See if we've got a /etc/psqlrc or .psqlrc file
*/
- if(!access("/etc/psqlrc",R_OK))
+ if (!access("/etc/psqlrc", R_OK))
HandleSlashCmds(&settings, "\\i /etc/psqlrc", "");
- if((home = getenv("HOME"))!=NULL) {
- char *psqlrc = NULL,
- *line = NULL;
+ if ((home = getenv("HOME")) != NULL)
+ {
+ char *psqlrc = NULL,
+ *line = NULL;
- if((psqlrc = (char *)malloc(strlen(home) + 10))!=NULL) {
+ if ((psqlrc = (char *) malloc(strlen(home) + 10)) != NULL)
+ {
sprintf(psqlrc, "%s/.psqlrc", home);
- if(!access(psqlrc, R_OK)) {
- if((line = (char *)malloc(strlen(psqlrc) + 5))!=NULL) {
+ if (!access(psqlrc, R_OK))
+ {
+ if ((line = (char *) malloc(strlen(psqlrc) + 5)) != NULL)
+ {
sprintf(line, "\\i %s", psqlrc);
HandleSlashCmds(&settings, line, "");
free(line);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/psql/stringutils.c,v 1.12 1997/09/08 02:33:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/bin/psql/stringutils.c,v 1.13 1998/02/26 04:39:13 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#endif
-char *
+char *
rightTrim(char *s)
{
char *sEnd;
# This is exeption from previous rule!
HostCharset 192.168.2.4 win
+#
+# Example PostgreSQL charsets control file.
+#
+# Should be placed in $PG_DATA directory.
+#
+# On the fly recoding charsets, based on client's IP address.
+# For example: koi8-u (koi) <-> cp1251 (win) <-> cp866 (alt)
+#
+
+# Base charset for backend
+# Most Unices use koi8-r(u) as base charset. But Solaris
+# use iso8859-5 and some networkless workstations use cp866.
+BaseCharset koi
+
+# There are recode table definitions from base charset to
+# other. Table names are relative to $PG_DATA directory.
+# Tables are taken from Russian Apache .
+RecodeTable koi alt koi-alt.tab
+RecodeTable koi win koi-win.tab
+RecodeTable koi iso koi-iso.tab
+RecodeTable koi koi koi-koi.tab
+RecodeTable alt win othertabs/alt-win.tab
+RecodeTable alt koi othertabs/alt-koi.tab
+RecodeTable iso koi othertabs/iso-koi.tab
+
+# Local loopback
+HostCharset 127.0.0.1 koi
+
+# Yet another Unix (maybe ;)
+HostCharset 192.168.0.1 koi
+
+# There are Windows on 192.168.1.64 through 192.168.1.95
+HostCharset 192.168.1.64/27 win
+
+# There are cp866 (alt) systems on 192.168.2.3 through
+# 192.168.2.7 (exept 192.168.2.4 - see below)
+HostCharset 192.168.2.3-192.168.2.7 alt
+
+# This is exeption from previous rule!
+HostCharset 192.168.2.4 win
+#
+# Example PostgreSQL charsets control file.
+#
+# Should be placed in $PG_DATA directory.
+#
+# On the fly recoding charsets, based on client's IP address.
+# For example: koi8-u (koi) <-> cp1251 (win) <-> cp866 (alt)
+#
+
+# Base charset for backend
+# Most Unices use koi8-r(u) as base charset. But Solaris
+# use iso8859-5 and some networkless workstations use cp866.
+BaseCharset koi
+
+# There are recode table definitions from base charset to
+# other. Table names are relative to $PG_DATA directory.
+# Tables are taken from Russian Apache .
+RecodeTable koi alt koi-alt.tab
+RecodeTable koi win koi-win.tab
+RecodeTable koi iso koi-iso.tab
+RecodeTable koi koi koi-koi.tab
+RecodeTable alt win othertabs/alt-win.tab
+RecodeTable alt koi othertabs/alt-koi.tab
+RecodeTable iso koi othertabs/iso-koi.tab
+
+# Local loopback
+HostCharset 127.0.0.1 koi
+
+# Yet another Unix (maybe ;)
+HostCharset 192.168.0.1 koi
+
+# There are Windows on 192.168.1.64 through 192.168.1.95
+HostCharset 192.168.1.64/27 win
+
+# There are cp866 (alt) systems on 192.168.2.3 through
+# 192.168.2.7 (exept 192.168.2.4 - see below)
+HostCharset 192.168.2.3-192.168.2.7 alt
+
+# This is exeption from previous rule!
+HostCharset 192.168.2.4 win
253 153
254 151
255 154
+# Line with '#' at the begin is comment
+# table file may contain number of line as you wana
+# first - code of symbol, second translate code of symbol
+# codes may be in two forms: decimal and hex
+# examples:
+# 192 225
+# 0x81 226
+# 226 0x81
+# 0x90 0xfe
+#
+163 241
+164 243
+166 249
+167 245
+173 173
+179 240
+180 242
+182 248
+183 244
+189 189
+192 238
+193 160
+194 161
+195 230
+196 164
+197 165
+198 228
+199 163
+200 229
+201 168
+202 169
+203 170
+204 171
+205 172
+206 173
+207 174
+208 175
+209 239
+210 224
+211 225
+212 226
+213 227
+214 166
+215 162
+216 236
+217 235
+218 167
+219 232
+220 237
+221 233
+222 231
+223 234
+224 158
+225 128
+226 129
+227 150
+228 132
+229 133
+230 148
+231 131
+232 149
+233 136
+234 137
+235 138
+236 139
+237 140
+238 141
+239 142
+240 143
+241 159
+242 144
+243 145
+244 146
+245 147
+246 134
+247 130
+248 156
+249 155
+250 135
+251 152
+252 157
+253 153
+254 151
+255 154
+# Line with '#' at the begin is comment
+# table file may contain number of line as you wana
+# first - code of symbol, second translate code of symbol
+# codes may be in two forms: decimal and hex
+# examples:
+# 192 225
+# 0x81 226
+# 226 0x81
+# 0x90 0xfe
+#
+163 241
+164 243
+166 249
+167 245
+173 173
+179 240
+180 242
+182 248
+183 244
+189 189
+192 238
+193 160
+194 161
+195 230
+196 164
+197 165
+198 228
+199 163
+200 229
+201 168
+202 169
+203 170
+204 171
+205 172
+206 173
+207 174
+208 175
+209 239
+210 224
+211 225
+212 226
+213 227
+214 166
+215 162
+216 236
+217 235
+218 167
+219 232
+220 237
+221 233
+222 231
+223 234
+224 158
+225 128
+226 129
+227 150
+228 132
+229 133
+230 148
+231 131
+232 149
+233 136
+234 137
+235 138
+236 139
+237 140
+238 141
+239 142
+240 143
+241 159
+242 144
+243 145
+244 146
+245 147
+246 134
+247 130
+248 156
+249 155
+250 135
+251 152
+252 157
+253 153
+254 151
+255 154
253 0xc9
254 0xc7
255 0xca
+# Line with '#' at the begin is comment
+# table file may contain number of line as you wana
+# first - code of symbol, second translate code of symbol
+# codes may be in two forms: decimal and hex
+# examples:
+# 192 225
+# 0x81 226
+# 226 0x81
+# 0x90 0xfe
+#
+192 0xee
+193 0xd0
+194 0xd1
+195 0xe6
+196 0xd4
+197 0xd5
+198 0xe4
+199 0xd3
+200 0xe5
+201 0xd8
+202 0xd9
+203 0xda
+204 0xdb
+205 0xdc
+206 0xdd
+207 0xde
+208 0xdf
+209 0xef
+210 0xe0
+211 0xe1
+212 0xe2
+213 0xe3
+214 0xd6
+215 0xd2
+216 0xec
+217 0xeb
+218 0xd7
+219 0xe8
+220 0xed
+221 0xe9
+222 0xe7
+223 0xea
+224 0xce
+225 0xb0
+226 0xb1
+227 0xc6
+228 0xb4
+229 0xb5
+230 0xc4
+231 0xb3
+232 0xc5
+233 0xb8
+234 0xb9
+235 0xba
+236 0xbb
+237 0xbc
+238 0xbd
+239 0xbe
+240 0xbf
+241 0xcf
+242 0xc0
+243 0xc1
+244 0xc2
+245 0xc3
+246 0xb6
+247 0xb2
+248 0xcc
+249 0xcb
+250 0xb7
+251 0xc8
+252 0xcd
+253 0xc9
+254 0xc7
+255 0xca
+# Line with '#' at the begin is comment
+# table file may contain number of line as you wana
+# first - code of symbol, second translate code of symbol
+# codes may be in two forms: decimal and hex
+# examples:
+# 192 225
+# 0x81 226
+# 226 0x81
+# 0x90 0xfe
+#
+192 0xee
+193 0xd0
+194 0xd1
+195 0xe6
+196 0xd4
+197 0xd5
+198 0xe4
+199 0xd3
+200 0xe5
+201 0xd8
+202 0xd9
+203 0xda
+204 0xdb
+205 0xdc
+206 0xdd
+207 0xde
+208 0xdf
+209 0xef
+210 0xe0
+211 0xe1
+212 0xe2
+213 0xe3
+214 0xd6
+215 0xd2
+216 0xec
+217 0xeb
+218 0xd7
+219 0xe8
+220 0xed
+221 0xe9
+222 0xe7
+223 0xea
+224 0xce
+225 0xb0
+226 0xb1
+227 0xc6
+228 0xb4
+229 0xb5
+230 0xc4
+231 0xb3
+232 0xc5
+233 0xb8
+234 0xb9
+235 0xba
+236 0xbb
+237 0xbc
+238 0xbd
+239 0xbe
+240 0xbf
+241 0xcf
+242 0xc0
+243 0xc1
+244 0xc2
+245 0xc3
+246 0xb6
+247 0xb2
+248 0xcc
+249 0xcb
+250 0xb7
+251 0xc8
+252 0xcd
+253 0xc9
+254 0xc7
+255 0xca
# Hmm ...
#
+# Hmm ...
+#
253 0x99
254 0x97
255 0x9a
+# Hmm ...
+#
+128 0xc0
+129 0xc1
+130 0xc2
+131 0xc3
+132 0xc4
+133 0xc5
+134 0xc6
+135 0xc7
+136 0xc8
+137 0xc9
+138 0xca
+139 0xcb
+140 0xcc
+141 0xcd
+142 0xce
+143 0xcf
+144 0xd0
+145 0xd1
+146 0xd2
+147 0xd3
+148 0xd4
+149 0xd5
+150 0xd6
+151 0xd7
+152 0xd8
+153 0xd9
+154 0xda
+155 0xdb
+156 0xdc
+157 0xdd
+158 0xde
+159 0xdf
+160 0xa0
+161 0xa1
+162 0xa2
+163 0xa3
+164 0xa4
+165 0xa5
+166 0xa6
+167 0xa7
+168 0xa8
+169 0xa9
+170 0xaa
+171 0xab
+172 0xac
+173 0xad
+174 0xae
+175 0xaf
+176 0xb0
+177 0xb1
+178 0xb2
+179 0xb3
+180 0xb4
+181 0xb5
+182 0xb6
+183 0xb7
+184 0xb8
+185 0xb9
+186 0xba
+187 0xbb
+188 0xbc
+189 0xbd
+190 0xbe
+191 0xbf
+192 0xfe
+193 0xe0
+194 0xe1
+195 0xf6
+196 0xe4
+197 0xe5
+198 0xf4
+199 0xe3
+200 0xf5
+201 0xe8
+202 0xe9
+203 0xea
+204 0xeb
+205 0xec
+206 0xed
+207 0xee
+208 0xef
+209 0xdf
+210 0xf0
+211 0xf1
+212 0xf2
+213 0xf3
+214 0xe6
+215 0xe2
+216 0xfc
+217 0xfb
+218 0xe7
+219 0xf8
+220 0xfd
+221 0xf9
+222 0xf7
+223 0xfa
+224 0x9e
+225 0x80
+226 0x81
+227 0x96
+228 0x84
+229 0x85
+230 0x94
+231 0x83
+232 0x95
+233 0x88
+234 0x89
+235 0x8a
+236 0x8b
+237 0x8c
+238 0x8d
+239 0x8e
+240 0x8f
+241 0x9f
+242 0x90
+243 0x91
+244 0x92
+245 0x93
+246 0x86
+247 0x82
+248 0x9c
+249 0x9b
+250 0x87
+251 0x98
+252 0x9d
+253 0x99
+254 0x97
+255 0x9a
+# Hmm ...
+#
+128 0xc0
+129 0xc1
+130 0xc2
+131 0xc3
+132 0xc4
+133 0xc5
+134 0xc6
+135 0xc7
+136 0xc8
+137 0xc9
+138 0xca
+139 0xcb
+140 0xcc
+141 0xcd
+142 0xce
+143 0xcf
+144 0xd0
+145 0xd1
+146 0xd2
+147 0xd3
+148 0xd4
+149 0xd5
+150 0xd6
+151 0xd7
+152 0xd8
+153 0xd9
+154 0xda
+155 0xdb
+156 0xdc
+157 0xdd
+158 0xde
+159 0xdf
+160 0xa0
+161 0xa1
+162 0xa2
+163 0xa3
+164 0xa4
+165 0xa5
+166 0xa6
+167 0xa7
+168 0xa8
+169 0xa9
+170 0xaa
+171 0xab
+172 0xac
+173 0xad
+174 0xae
+175 0xaf
+176 0xb0
+177 0xb1
+178 0xb2
+179 0xb3
+180 0xb4
+181 0xb5
+182 0xb6
+183 0xb7
+184 0xb8
+185 0xb9
+186 0xba
+187 0xbb
+188 0xbc
+189 0xbd
+190 0xbe
+191 0xbf
+192 0xfe
+193 0xe0
+194 0xe1
+195 0xf6
+196 0xe4
+197 0xe5
+198 0xf4
+199 0xe3
+200 0xf5
+201 0xe8
+202 0xe9
+203 0xea
+204 0xeb
+205 0xec
+206 0xed
+207 0xee
+208 0xef
+209 0xdf
+210 0xf0
+211 0xf1
+212 0xf2
+213 0xf3
+214 0xe6
+215 0xe2
+216 0xfc
+217 0xfb
+218 0xe7
+219 0xf8
+220 0xfd
+221 0xf9
+222 0xf7
+223 0xfa
+224 0x9e
+225 0x80
+226 0x81
+227 0x96
+228 0x84
+229 0x85
+230 0x94
+231 0x83
+232 0x95
+233 0x88
+234 0x89
+235 0x8a
+236 0x8b
+237 0x8c
+238 0x8d
+239 0x8e
+240 0x8f
+241 0x9f
+242 0x90
+243 0x91
+244 0x92
+245 0x93
+246 0x86
+247 0x82
+248 0x9c
+249 0x9b
+250 0x87
+251 0x98
+252 0x9d
+253 0x99
+254 0x97
+255 0x9a
253 217
254 215
255 218
+# Line with '#' at the begin is comment
+# table file may contain number of line as you wana
+# first - code of symbol, second translate code of symbol
+# codes may be in two forms: decimal and hex
+# examples:
+# 192 225
+# 0x81 226
+# 226 0x81
+# 0x90 0xfe
+#
+163 184
+164 186
+166 179
+167 191
+173 180
+179 168
+180 170
+182 178
+183 175
+189 165
+192 254
+193 224
+194 225
+195 246
+196 228
+197 229
+198 244
+199 227
+200 245
+201 232
+202 233
+203 234
+204 235
+205 236
+206 237
+207 238
+208 239
+209 255
+210 240
+211 241
+212 242
+213 243
+214 230
+215 226
+216 252
+217 251
+218 231
+219 248
+220 253
+221 249
+222 247
+223 250
+224 222
+225 192
+226 193
+227 214
+228 196
+229 197
+230 212
+231 195
+232 213
+233 200
+234 201
+235 202
+236 203
+237 204
+238 205
+239 206
+240 207
+241 223
+242 208
+243 209
+244 210
+245 211
+246 198
+247 194
+248 220
+249 219
+250 199
+251 216
+252 221
+253 217
+254 215
+255 218
+# Line with '#' at the begin is comment
+# table file may contain number of line as you wana
+# first - code of symbol, second translate code of symbol
+# codes may be in two forms: decimal and hex
+# examples:
+# 192 225
+# 0x81 226
+# 226 0x81
+# 0x90 0xfe
+#
+163 184
+164 186
+166 179
+167 191
+173 180
+179 168
+180 170
+182 178
+183 175
+189 165
+192 254
+193 224
+194 225
+195 246
+196 228
+197 229
+198 244
+199 227
+200 245
+201 232
+202 233
+203 234
+204 235
+205 236
+206 237
+207 238
+208 239
+209 255
+210 240
+211 241
+212 242
+213 243
+214 230
+215 226
+216 252
+217 251
+218 231
+219 248
+220 253
+221 249
+222 247
+223 250
+224 222
+225 192
+226 193
+227 214
+228 196
+229 197
+230 212
+231 195
+232 213
+233 200
+234 201
+235 202
+236 203
+237 204
+238 205
+239 206
+240 207
+241 223
+242 208
+243 209
+244 210
+245 211
+246 198
+247 194
+248 220
+249 219
+250 199
+251 216
+252 221
+253 217
+254 215
+255 218
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: genam.h,v 1.11 1998/01/24 22:47:48 momjian Exp $
+ * $Id: genam.h,v 1.12 1998/02/26 04:39:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Relation index_open(Oid relationId);
extern Relation index_openr(char *relationName);
extern void index_close(Relation relation);
-extern InsertIndexResult index_insert(Relation relation,
+extern InsertIndexResult
+index_insert(Relation relation,
Datum *datum, char *nulls,
ItemPointer heap_t_ctid,
Relation heapRel);
extern void index_delete(Relation relation, ItemPointer indexItem);
-extern IndexScanDesc index_beginscan(Relation relation, bool scanFromEnd,
+extern IndexScanDesc
+index_beginscan(Relation relation, bool scanFromEnd,
uint16 numberOfKeys, ScanKey key);
extern void index_rescan(IndexScanDesc scan, bool scanFromEnd, ScanKey key);
extern void index_endscan(IndexScanDesc scan);
-extern RetrieveIndexResult index_getnext(IndexScanDesc scan,
+extern RetrieveIndexResult
+index_getnext(IndexScanDesc scan,
ScanDirection direction);
-extern RegProcedure index_getprocid(Relation irel, AttrNumber attnum,
+extern RegProcedure
+index_getprocid(Relation irel, AttrNumber attnum,
uint16 procnum);
-extern Datum GetIndexValue(HeapTuple tuple, TupleDesc hTupDesc,
+extern Datum
+GetIndexValue(HeapTuple tuple, TupleDesc hTupDesc,
int attOff, AttrNumber attrNums[], FuncIndexInfo *fInfo,
bool *attNull, Buffer buffer);
/* in genam.c */
-extern IndexScanDesc RelationGetIndexScan(Relation relation, bool scanFromEnd,
+extern IndexScanDesc
+RelationGetIndexScan(Relation relation, bool scanFromEnd,
uint16 numberOfKeys, ScanKey key);
extern void IndexScanMarkPosition(IndexScanDesc scan);
extern void IndexScanRestorePosition(IndexScanDesc scan);
int flag;
} INTRANGE;
-extern void gistbuild(Relation heap,
+extern void
+gistbuild(Relation heap,
Relation index, int natts,
AttrNumber *attnum, IndexStrategy istrat,
uint16 pint, Datum *params,
FuncIndexInfo *finfo,
PredInfo *predInfo);
-extern InsertIndexResult gistinsert(Relation r, Datum *datum,
+extern InsertIndexResult
+gistinsert(Relation r, Datum *datum,
char *nulls, ItemPointer ht_ctid, Relation heapRel);
extern void _gistdump(Relation r);
extern void gistfreestack(GISTSTACK *s);
extern void initGISTstate(GISTSTATE *giststate, Relation index);
-extern void gistdentryinit(GISTSTATE *giststate, GISTENTRY *e, char *pr,
+extern void
+gistdentryinit(GISTSTATE *giststate, GISTENTRY *e, char *pr,
Relation r, Page pg, OffsetNumber o, int b, bool l);
extern StrategyNumber RelationGetGISTStrategy(Relation, AttrNumber, RegProcedure);
#include
#include
-extern IndexScanDesc gistbeginscan(Relation r, bool fromEnd,
+extern IndexScanDesc
+gistbeginscan(Relation r, bool fromEnd,
uint16 nkeys, ScanKey key);
extern void gistrescan(IndexScanDesc s, bool fromEnd, ScanKey key);
extern void gistmarkpos(IndexScanDesc s);
#include
-extern StrategyNumber RelationGetGISTStrategy(Relation r,
+extern StrategyNumber
+RelationGetGISTStrategy(Relation r,
AttrNumber attnum, RegProcedure proc);
#endif /* GISTSTRAT_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: hash.h,v 1.12 1998/01/24 22:47:55 momjian Exp $
+ * $Id: hash.h,v 1.13 1998/02/26 04:39:59 momjian Exp $
*
* NOTES
* modeled after Margo Seltzer's hash implementation for unix.
/* public routines */
-extern void hashbuild(Relation heap, Relation index, int natts,
+extern void
+hashbuild(Relation heap, Relation index, int natts,
AttrNumber *attnum, IndexStrategy istrat, uint16 pcount,
Datum *params, FuncIndexInfo *finfo, PredInfo *predInfo);
-extern InsertIndexResult hashinsert(Relation rel, Datum *datum, char *nulls,
+extern InsertIndexResult
+hashinsert(Relation rel, Datum *datum, char *nulls,
ItemPointer ht_ctid, Relation heapRel);
extern char *hashgettuple(IndexScanDesc scan, ScanDirection dir);
-extern char * hashbeginscan(Relation rel, bool fromEnd, uint16 keysz,
+extern char *
+hashbeginscan(Relation rel, bool fromEnd, uint16 keysz,
ScanKey scankey);
extern void hashrescan(IndexScanDesc scan, bool fromEnd, ScanKey scankey);
extern void hashendscan(IndexScanDesc scan);
/* hashovfl.c */
extern Buffer _hash_addovflpage(Relation rel, Buffer *metabufp, Buffer buf);
extern Buffer _hash_freeovflpage(Relation rel, Buffer ovflbuf);
-extern int32 _hash_initbitmap(Relation rel, HashMetaPage metap, int32 pnum,
+extern int32
+_hash_initbitmap(Relation rel, HashMetaPage metap, int32 pnum,
int32 nbits, int32 ndx);
-extern void _hash_squeezebucket(Relation rel, HashMetaPage metap,
+extern void
+_hash_squeezebucket(Relation rel, HashMetaPage metap,
Bucket bucket);
extern void _hash_relbuf(Relation rel, Buffer buf, int access);
extern void _hash_wrtbuf(Relation rel, Buffer buf);
extern void _hash_wrtnorelbuf(Relation rel, Buffer buf);
-extern Page _hash_chgbufaccess(Relation rel, Buffer *bufp, int from_access,
+extern Page
+_hash_chgbufaccess(Relation rel, Buffer *bufp, int from_access,
int to_access);
extern void _hash_pageinit(Page page, Size size);
extern void _hash_pagedel(Relation rel, ItemPointer tid);
/* hashsearch.c */
-extern void _hash_search(Relation rel, int keysz, ScanKey scankey,
+extern void
+_hash_search(Relation rel, int keysz, ScanKey scankey,
Buffer *bufP, HashMetaPage metap);
extern RetrieveIndexResult _hash_next(IndexScanDesc scan, ScanDirection dir);
extern RetrieveIndexResult _hash_first(IndexScanDesc scan, ScanDirection dir);
-extern bool _hash_step(IndexScanDesc scan, Buffer *bufP, ScanDirection dir,
+extern bool
+_hash_step(IndexScanDesc scan, Buffer *bufP, ScanDirection dir,
Buffer metabuf);
/* hashutil.c */
-extern ScanKey _hash_mkscankey(Relation rel, IndexTuple itup,
+extern ScanKey
+_hash_mkscankey(Relation rel, IndexTuple itup,
HashMetaPage metap);
extern void _hash_freeskey(ScanKey skey);
extern bool _hash_checkqual(IndexScanDesc scan, IndexTuple itup);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: heapam.h,v 1.29 1998/02/06 20:18:00 momjian Exp $
+ * $Id: heapam.h,v 1.30 1998/02/26 04:40:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/
(attnum) == 1) ? \
( \
(Datum)fetchatt(&((tupleDesc)->attrs[(attnum)-1]), \
- (char *) (tup) + (tup)->t_hoff + \
+ (char *) (tup) + (tup)->t_hoff + \
( \
((attnum) != 1) ? \
(tupleDesc)->attrs[(attnum)-1]->attcacheoff \
)
-
+
/* ----------------
* heap_getattr
*
extern Relation heap_open(Oid relationId);
extern Relation heap_openr(char *relationName);
extern void heap_close(Relation relation);
-extern HeapScanDesc heap_beginscan(Relation relation, int atend,
+extern HeapScanDesc
+heap_beginscan(Relation relation, int atend,
bool seeself, unsigned nkeys, ScanKey key);
extern void heap_rescan(HeapScanDesc sdesc, bool scanFromEnd, ScanKey key);
extern void heap_endscan(HeapScanDesc sdesc);
extern HeapTuple heap_fetch(Relation relation, bool seeself, ItemPointer tid, Buffer *b);
extern Oid heap_insert(Relation relation, HeapTuple tup);
extern int heap_delete(Relation relation, ItemPointer tid);
-extern int heap_replace(Relation relation, ItemPointer otid,
+extern int
+heap_replace(Relation relation, ItemPointer otid,
HeapTuple tup);
extern void heap_markpos(HeapScanDesc sdesc);
extern void heap_restrpos(HeapScanDesc sdesc);
/* in common/heaptuple.c */
extern Size ComputeDataSize(TupleDesc tupleDesc, Datum value[], char nulls[]);
-extern void DataFill(char *data, TupleDesc tupleDesc,
+extern void
+DataFill(char *data, TupleDesc tupleDesc,
Datum value[], char nulls[], uint16 *infomask,
bits8 *bit);
extern int heap_attisnull(HeapTuple tup, int attnum);
extern int heap_sysattrlen(AttrNumber attno);
extern bool heap_sysattrbyval(AttrNumber attno);
extern Datum heap_getsysattr(HeapTuple tup, Buffer b, int attnum);
-extern Datum nocachegetattr(HeapTuple tup, int attnum,
- TupleDesc att, bool *isnull);
+extern Datum
+nocachegetattr(HeapTuple tup, int attnum,
+ TupleDesc att, bool *isnull);
extern HeapTuple heap_copytuple(HeapTuple tuple);
-extern HeapTuple heap_formtuple(TupleDesc tupleDescriptor,
+extern HeapTuple
+heap_formtuple(TupleDesc tupleDescriptor,
Datum value[], char nulls[]);
-extern HeapTuple heap_modifytuple(HeapTuple tuple, Buffer buffer,
+extern HeapTuple
+heap_modifytuple(HeapTuple tuple, Buffer buffer,
Relation relation, Datum replValue[], char replNull[], char repl[]);
HeapTuple heap_addheader(uint32 natts, int structlen, char *structure);
extern void initam(void);
/* hio.c */
-extern void RelationPutHeapTuple(Relation relation, BlockNumber blockIndex,
+extern void
+RelationPutHeapTuple(Relation relation, BlockNumber blockIndex,
HeapTuple tuple);
extern void RelationPutHeapTupleAtEnd(Relation relation, HeapTuple tuple);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: hio.h,v 1.6 1998/01/24 22:48:01 momjian Exp $
+ * $Id: hio.h,v 1.7 1998/02/26 04:40:11 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include
-extern void RelationPutHeapTuple(Relation relation, BlockNumber blockIndex,
+extern void
+RelationPutHeapTuple(Relation relation, BlockNumber blockIndex,
HeapTuple tuple);
extern void RelationPutHeapTupleAtEnd(Relation relation, HeapTuple tuple);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: htup.h,v 1.8 1998/01/31 04:39:22 momjian Exp $
+ * $Id: htup.h,v 1.9 1998/02/26 04:40:14 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
typedef struct HeapTupleData
{
- unsigned int t_len; /* length of entire tuple */
+ unsigned int t_len; /* length of entire tuple */
- Oid t_oid; /* OID of this tuple -- 4 bytes */
+ Oid t_oid; /* OID of this tuple -- 4 bytes */
- CommandId t_cmin; /* insert CID stamp -- 4 bytes each */
- CommandId t_cmax; /* delete CommandId stamp */
+ CommandId t_cmin; /* insert CID stamp -- 4 bytes each */
+ CommandId t_cmax; /* delete CommandId stamp */
- TransactionId t_xmin; /* insert XID stamp -- 4 bytes each */
- TransactionId t_xmax; /* delete XID stamp */
+ TransactionId t_xmin; /* insert XID stamp -- 4 bytes each */
+ TransactionId t_xmax; /* delete XID stamp */
- ItemPointerData t_ctid; /* current TID of this tuple */
-
- int16 t_natts; /* number of attributes */
+ ItemPointerData t_ctid; /* current TID of this tuple */
- uint16 t_infomask; /* various infos */
+ int16 t_natts; /* number of attributes */
- uint8 t_hoff; /* sizeof tuple header */
+ uint16 t_infomask; /* various infos */
- bits8 t_bits[MinHeapTupleBitmapSize / 8];
+ uint8 t_hoff; /* sizeof tuple header */
+
+ bits8 t_bits[MinHeapTupleBitmapSize / 8];
/* bit map of domains */
/* MORE DATA FOLLOWS AT END OF STRUCT */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: iqual.h,v 1.8 1998/01/24 22:48:05 momjian Exp $
+ * $Id: iqual.h,v 1.9 1998/02/26 04:40:17 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern int NIndexTupleProcessed;
-extern bool index_keytest(IndexTuple tuple, TupleDesc tupdesc,
+extern bool
+index_keytest(IndexTuple tuple, TupleDesc tupdesc,
int scanKeySize, ScanKey key);
#endif /* IQUAL_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: istrat.h,v 1.9 1998/01/24 22:48:05 momjian Exp $
+ * $Id: istrat.h,v 1.10 1998/02/26 04:40:19 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
#define IndexStrategyIsValid(s) PointerIsValid(s)
-extern StrategyMap IndexStrategyGetStrategyMap(IndexStrategy indexStrategy,
+extern StrategyMap
+IndexStrategyGetStrategyMap(IndexStrategy indexStrategy,
StrategyNumber maxStrategyNum, AttrNumber attrNum);
-extern Size AttributeNumberGetIndexStrategySize(AttrNumber maxAttributeNumber,
+extern Size
+AttributeNumberGetIndexStrategySize(AttrNumber maxAttributeNumber,
StrategyNumber maxStrategyNumber);
-extern StrategyNumber RelationGetStrategy(Relation relation,
+extern StrategyNumber
+RelationGetStrategy(Relation relation,
AttrNumber attributeNumber, StrategyEvaluation evaluation,
RegProcedure procedure);
-extern bool RelationInvokeStrategy(Relation relation,
+extern bool
+RelationInvokeStrategy(Relation relation,
StrategyEvaluation evaluation, AttrNumber attributeNumber,
StrategyNumber strategy, Datum left, Datum right);
-extern void IndexSupportInitialize(IndexStrategy indexStrategy,
+extern void
+IndexSupportInitialize(IndexStrategy indexStrategy,
RegProcedure *indexSupport, Oid indexObjectId,
Oid accessMethodObjectId, StrategyNumber maxStrategyNumber,
StrategyNumber maxSupportNumber, AttrNumber maxAttributeNumber);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: itup.h,v 1.12 1998/02/06 20:18:01 momjian Exp $
+ * $Id: itup.h,v 1.13 1998/02/26 04:40:19 momjian Exp $
*
*-------------------------------------------------------------------------
*/
(attnum) == 1) ? \
( \
(Datum)fetchatt(&((tupleDesc)->attrs[(attnum)-1]), \
- (char *) (tup) + \
+ (char *) (tup) + \
( \
IndexTupleHasMinHeader(tup) ? \
sizeof (*(tup)) \
) \
)
-
+
/* indextuple.h */
-extern IndexTuple index_formtuple(TupleDesc tupleDescriptor,
+extern IndexTuple
+index_formtuple(TupleDesc tupleDescriptor,
Datum value[], char null[]);
-extern Datum nocache_index_getattr(IndexTuple tup, int attnum,
- TupleDesc tupleDesc, bool *isnull);
-extern RetrieveIndexResult FormRetrieveIndexResult(ItemPointer indexItemPointer,
+extern Datum
+nocache_index_getattr(IndexTuple tup, int attnum,
+ TupleDesc tupleDesc, bool *isnull);
+extern RetrieveIndexResult
+FormRetrieveIndexResult(ItemPointer indexItemPointer,
ItemPointer heapItemPointer);
extern void CopyIndexTuple(IndexTuple source, IndexTuple *target);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nbtree.h,v 1.19 1998/01/24 22:48:07 momjian Exp $
+ * $Id: nbtree.h,v 1.20 1998/02/26 04:40:22 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* prototypes for functions in nbtinsert.c
*/
-extern InsertIndexResult _bt_doinsert(Relation rel, BTItem btitem,
+extern InsertIndexResult
+_bt_doinsert(Relation rel, BTItem btitem,
bool index_is_unique, Relation heapRel);
/* default is to allow duplicates */
-extern bool _bt_itemcmp(Relation rel, Size keysz, BTItem item1, BTItem item2,
+extern bool
+_bt_itemcmp(Relation rel, Size keysz, BTItem item1, BTItem item2,
StrategyNumber strat);
/*
*/
extern bool BuildingBtree; /* in nbtree.c */
-extern void btbuild(Relation heap, Relation index, int natts,
+extern void
+btbuild(Relation heap, Relation index, int natts,
AttrNumber *attnum, IndexStrategy istrat, uint16 pcount,
Datum *params, FuncIndexInfo *finfo, PredInfo *predInfo);
-extern InsertIndexResult btinsert(Relation rel, Datum *datum, char *nulls,
+extern InsertIndexResult
+btinsert(Relation rel, Datum *datum, char *nulls,
ItemPointer ht_ctid, Relation heapRel);
extern char *btgettuple(IndexScanDesc scan, ScanDirection dir);
-extern char * btbeginscan(Relation rel, bool fromEnd, uint16 keysz,
+extern char *
+btbeginscan(Relation rel, bool fromEnd, uint16 keysz,
ScanKey scankey);
extern void btrescan(IndexScanDesc scan, bool fromEnd, ScanKey scankey);
/*
* prototypes for functions in nbtsearch.c
*/
-extern BTStack _bt_search(Relation rel, int keysz, ScanKey scankey,
+extern BTStack
+_bt_search(Relation rel, int keysz, ScanKey scankey,
Buffer *bufP);
-extern Buffer _bt_moveright(Relation rel, Buffer buf, int keysz,
+extern Buffer
+_bt_moveright(Relation rel, Buffer buf, int keysz,
ScanKey scankey, int access);
-extern bool _bt_skeycmp(Relation rel, Size keysz, ScanKey scankey,
+extern bool
+_bt_skeycmp(Relation rel, Size keysz, ScanKey scankey,
Page page, ItemId itemid, StrategyNumber strat);
-extern OffsetNumber _bt_binsrch(Relation rel, Buffer buf, int keysz,
+extern OffsetNumber
+_bt_binsrch(Relation rel, Buffer buf, int keysz,
ScanKey scankey, int srchtype);
extern RetrieveIndexResult _bt_next(IndexScanDesc scan, ScanDirection dir);
extern RetrieveIndexResult _bt_first(IndexScanDesc scan, ScanDirection dir);
/*
* prototypes for functions in nbtstrat.c
*/
-extern StrategyNumber _bt_getstrat(Relation rel, AttrNumber attno,
+extern StrategyNumber
+_bt_getstrat(Relation rel, AttrNumber attno,
RegProcedure proc);
-extern bool _bt_invokestrat(Relation rel, AttrNumber attno,
+extern bool
+_bt_invokestrat(Relation rel, AttrNumber attno,
StrategyNumber strat, Datum left, Datum right);
/*
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: rtree.h,v 1.11 1998/01/24 22:48:08 momjian Exp $
+ * $Id: rtree.h,v 1.12 1998/02/26 04:40:25 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* RTree code.
* Defined in access/index-rtree/
*/
-extern InsertIndexResult rtinsert(Relation r, Datum *datum, char *nulls,
+extern InsertIndexResult
+rtinsert(Relation r, Datum *datum, char *nulls,
ItemPointer ht_ctid, Relation heapRel);
extern char *rtdelete(Relation r, ItemPointer tid);
extern RetrieveIndexResult rtgettuple(IndexScanDesc s, ScanDirection dir);
-extern IndexScanDesc rtbeginscan(Relation r, bool fromEnd, uint16 nkeys,
+extern IndexScanDesc
+rtbeginscan(Relation r, bool fromEnd, uint16 nkeys,
ScanKey key);
extern void rtendscan(IndexScanDesc s);
extern void rtmarkpos(IndexScanDesc s);
extern void rtrestrpos(IndexScanDesc s);
extern void rtrescan(IndexScanDesc s, bool fromEnd, ScanKey key);
-extern void rtbuild(Relation heap, Relation index, int natts,
+extern void
+rtbuild(Relation heap, Relation index, int natts,
AttrNumber *attnum, IndexStrategy istrat, uint16 pcount,
Datum *params, FuncIndexInfo *finfo, PredInfo *predInfo);
extern void _rtdump(Relation r);
/* rtscan.c */
-extern void rtadjscans(Relation r, int op, BlockNumber blkno,
+extern void
+rtadjscans(Relation r, int op, BlockNumber blkno,
OffsetNumber offnum);
/* rtstrat.h */
-extern RegProcedure RTMapOperator(Relation r, AttrNumber attnum,
+extern RegProcedure
+RTMapOperator(Relation r, AttrNumber attnum,
RegProcedure proc);
#endif /* RTREE_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: rtstrat.h,v 1.6 1998/01/24 22:48:08 momjian Exp $
+ * $Id: rtstrat.h,v 1.7 1998/02/26 04:40:26 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include
-extern RegProcedure RTMapOperator(Relation r, AttrNumber attnum,
+extern RegProcedure
+RTMapOperator(Relation r, AttrNumber attnum,
RegProcedure proc);
#endif /* RTSTRAT_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: skey.h,v 1.8 1998/01/24 22:48:10 momjian Exp $
+ * $Id: skey.h,v 1.9 1998/02/26 04:40:27 momjian Exp $
*
*
* Note:
* prototypes for functions in access/common/scankey.c
*/
extern void ScanKeyEntrySetIllegal(ScanKey entry);
-extern void ScanKeyEntryInitialize(ScanKey entry, bits16 flags,
+extern void
+ScanKeyEntryInitialize(ScanKey entry, bits16 flags,
AttrNumber attributeNumber, RegProcedure procedure, Datum argument);
#endif /* SKEY_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: strat.h,v 1.8 1997/09/08 21:51:02 momjian Exp $
+ * $Id: strat.h,v 1.9 1998/02/26 04:40:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*
*
*
+ *
* STRUCTURE */
typedef StrategyTransformMapData *StrategyTransformMap;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: transam.h,v 1.13 1998/01/24 22:48:11 momjian Exp $
+ * $Id: transam.h,v 1.14 1998/02/26 04:40:30 momjian Exp $
*
* NOTES
* Transaction System Version 101 now support proper oid
* commiting of child xactions.
* ----------------
*/
-#define XID_COMMIT 2 /* transaction commited */
-#define XID_ABORT 1 /* transaction aborted */
-#define XID_INPROGRESS 0 /* transaction in progress */
-#define XID_COMMIT_CHILD 3 /* child xact commited */
+#define XID_COMMIT 2 /* transaction commited */
+#define XID_ABORT 1 /* transaction aborted */
+#define XID_INPROGRESS 0 /* transaction in progress */
+#define XID_COMMIT_CHILD 3 /* child xact commited */
typedef unsigned char XidStatus;/* (2 bits) */
*/
typedef struct VariableRelationContentsData
{
- int TransSystemVersion;
- TransactionId nextXidData;
- TransactionId lastXidData; /* unused */
- Oid nextOid;
+ int TransSystemVersion;
+ TransactionId nextXidData;
+ TransactionId lastXidData; /* unused */
+ Oid nextOid;
} VariableRelationContentsData;
typedef VariableRelationContentsData *VariableRelationContents;
/* in transam/transsup.c */
extern void AmiTransactionOverride(bool flag);
-extern void TransComputeBlockNumber(Relation relation,
+extern void
+TransComputeBlockNumber(Relation relation,
TransactionId transactionId, BlockNumber *blockNumberOutP);
-extern XidStatus TransBlockNumberGetXidStatus(Relation relation,
+extern XidStatus
+TransBlockNumberGetXidStatus(Relation relation,
BlockNumber blockNumber, TransactionId xid, bool *failP);
-extern void TransBlockNumberSetXidStatus(Relation relation,
+extern void
+TransBlockNumberSetXidStatus(Relation relation,
BlockNumber blockNumber, TransactionId xid, XidStatus xstatus,
bool *failP);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: tupdesc.h,v 1.15 1998/02/10 16:03:57 momjian Exp $
+ * $Id: tupdesc.h,v 1.16 1998/02/26 04:40:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void FreeTupleDesc(TupleDesc tupdesc);
-extern bool TupleDescInitEntry(TupleDesc desc,
+extern bool
+TupleDescInitEntry(TupleDesc desc,
AttrNumber attributeNumber,
char *attributeName,
Oid typeid,
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: tupmacs.h,v 1.3 1998/02/01 05:38:40 momjian Exp $
+ * $Id: tupmacs.h,v 1.4 1998/02/26 04:40:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
( \
(char *) (long) *((int32 *)(T)) \
) \
- : \
+ : \
( \
(*(A))->attlen < sizeof(int16) ? \
(char *) (long) *((char *)(T)) \
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: xact.h,v 1.11 1997/11/07 18:39:38 thomas Exp $
+ * $Id: xact.h,v 1.12 1998/02/26 04:40:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define TransactionIdIsValid(xid) ((bool) (xid != NullTransactionId))
#define TransactionIdStore(xid, dest) \
(*((TransactionId*)dest) = (TransactionId)xid)
-#define StoreInvalidTransactionId(dest) \
+#define StoreInvalidTransactionId(dest) \
(*((TransactionId*)dest) = NullTransactionId)
/* ----------------
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: bootstrap.h,v 1.10 1998/01/24 22:48:15 momjian Exp $
+ * $Id: bootstrap.h,v 1.11 1998/02/26 04:40:35 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern int DebugMode;
extern int BootstrapMain(int ac, char *av[]);
-extern void index_register(char *heap,
+extern void
+index_register(char *heap,
char *ind,
int natts,
AttrNumber *attnos,
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: c.h,v 1.35 1998/02/24 06:04:35 scrappy Exp $
+ * $Id: c.h,v 1.36 1998/02/26 04:39:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* This function gets call too often, so we inline it if we can.
- * Are we aligned for int32?
+ * Are we aligned for int32?
* We have to cast the pointer to int so we can do the AND
* We got the 64 number by testing this against the stock memset() on
- * BSD/OS 3.0. Larger values were slower.
+ * BSD/OS 3.0. Larger values were slower.
*/
#define MemSet(start, val, len) do \
{ \
extern Exception BadState;
/* in utils/error/assert.c */
-extern int ExceptionalCondition(char *conditionName,
+extern int
+ExceptionalCondition(char *conditionName,
Exception *exceptionP, char *details,
char *fileName, int lineNumber);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: heap.h,v 1.11 1998/01/24 22:48:19 momjian Exp $
+ * $Id: heap.h,v 1.12 1998/02/26 04:40:38 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Relation heap_create(char *relname, TupleDesc att);
-extern Oid heap_create_with_catalog(char relname[], TupleDesc tupdesc);
+extern Oid heap_create_with_catalog(char relname[], TupleDesc tupdesc);
extern void heap_destroy_with_catalog(char relname[]);
extern void heap_destroy(Relation r);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: index.h,v 1.9 1998/01/24 22:48:22 momjian Exp $
+ * $Id: index.h,v 1.10 1998/02/26 04:40:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
-extern Form_pg_am AccessMethodObjectIdGetAccessMethodTupleForm(Oid accessMethodObjectId);
+extern Form_pg_am AccessMethodObjectIdGetAccessMethodTupleForm(Oid accessMethodObjectId);
extern void UpdateIndexPredicate(Oid indexoid, Node *oldPred, Node *predicate);
-extern void InitIndexStrategy(int numatts,
+extern void
+InitIndexStrategy(int numatts,
Relation indexRelation,
Oid accessMethodObjectId);
-extern void index_create(char *heapRelationName,
+extern void
+index_create(char *heapRelationName,
char *indexRelationName,
FuncIndexInfo *funcInfo,
List *attributeList,
extern void index_destroy(Oid indexId);
-extern void FormIndexDatum(int numberOfAttributes,
+extern void
+FormIndexDatum(int numberOfAttributes,
AttrNumber attributeNumber[], HeapTuple heapTuple,
TupleDesc heapDescriptor, Buffer buffer, Datum *datum,
char *nullv, FuncIndexInfoPtr fInfo);
extern void UpdateStats(Oid relid, long reltuples, bool hasindex);
-extern void FillDummyExprContext(ExprContext *econtext, TupleTableSlot *slot,
+extern void
+FillDummyExprContext(ExprContext *econtext, TupleTableSlot *slot,
TupleDesc tupdesc, Buffer buffer);
-extern void index_build(Relation heapRelation, Relation indexRelation,
+extern void
+index_build(Relation heapRelation, Relation indexRelation,
int numberOfAttributes, AttrNumber attributeNumber[],
uint16 parameterCount, Datum *parameter, FuncIndexInfo *funcInfo,
PredInfo *predInfo);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: indexing.h,v 1.14 1998/01/24 22:48:27 momjian Exp $
+ * $Id: indexing.h,v 1.15 1998/02/26 04:40:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
extern void CatalogOpenIndices(int nIndices, char *names[], Relation idescs[]);
extern void CatalogCloseIndices(int nIndices, Relation *idescs);
-extern void CatalogIndexInsert(Relation *idescs,
+extern void
+CatalogIndexInsert(Relation *idescs,
int nIndices,
Relation heapRelation,
HeapTuple heapTuple);
extern bool CatalogHasIndex(char *catName, Oid catId);
-extern HeapTuple AttributeNameIndexScan(Relation heapRelation,
+extern HeapTuple
+AttributeNameIndexScan(Relation heapRelation,
Oid relid,
char *attname);
-extern HeapTuple AttributeNumIndexScan(Relation heapRelation,
+extern HeapTuple
+AttributeNumIndexScan(Relation heapRelation,
Oid relid,
AttrNumber attnum);
extern HeapTuple ProcedureOidIndexScan(Relation heapRelation, Oid procId);
-extern HeapTuple ProcedureNameIndexScan(Relation heapRelation,
+extern HeapTuple
+ProcedureNameIndexScan(Relation heapRelation,
char *procName, int nargs, Oid *argTypes);
extern HeapTuple ProcedureSrcIndexScan(Relation heapRelation, text *procSrc);
extern HeapTuple TypeOidIndexScan(Relation heapRelation, Oid typeId);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_aggregate.h,v 1.13 1998/01/24 22:48:31 momjian Exp $
+ * $Id: pg_aggregate.h,v 1.14 1998/02/26 04:40:44 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
* ---------------
*/
-DATA(insert OID = 0 ( avg PGUID int4pl int4inc int4div 23 23 23 23 _null_ 0 ));
-DATA(insert OID = 0 ( avg PGUID int2pl int2inc int2div 21 21 21 21 _null_ 0 ));
-DATA(insert OID = 0 ( avg PGUID float4pl float4inc float4div 700 700 700 700 _null_ 0.0 ));
-DATA(insert OID = 0 ( avg PGUID float8pl float8inc float8div 701 701 701 701 _null_ 0.0 ));
-DATA(insert OID = 0 ( avg PGUID cash_pl float8inc cash_div_flt8 790 790 701 790 _null_ 0.0 ));
+DATA(insert OID = 0 ( avg PGUID int4pl int4inc int4div 23 23 23 23 _null_ 0 ));
+DATA(insert OID = 0 ( avg PGUID int2pl int2inc int2div 21 21 21 21 _null_ 0 ));
+DATA(insert OID = 0 ( avg PGUID float4pl float4inc float4div 700 700 700 700 _null_ 0.0 ));
+DATA(insert OID = 0 ( avg PGUID float8pl float8inc float8div 701 701 701 701 _null_ 0.0 ));
+DATA(insert OID = 0 ( avg PGUID cash_pl float8inc cash_div_flt8 790 790 701 790 _null_ 0.0 ));
DATA(insert OID = 0 ( avg PGUID timespan_pl float8inc timespan_div 1186 1186 701 1186 _null_ 0.0 ));
DATA(insert OID = 0 ( sum PGUID int4pl - - 23 23 0 23 _null_ _null_ ));
/*
* prototypes for functions in pg_aggregate.c
*/
-extern void AggregateCreate(char *aggName,
+extern void
+AggregateCreate(char *aggName,
char *aggtransfn1Name,
char *aggtransfn2Name,
char *aggfinalfnName,
char *aggtransfn2typeName,
char *agginitval1,
char *agginitval2);
-extern char * AggNameGetInitVal(char *aggName, Oid basetype,
+extern char *
+AggNameGetInitVal(char *aggName, Oid basetype,
int xfuncno, bool *isNull);
#endif /* PG_AGGREGATE_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_amop.h,v 1.8 1997/11/30 23:03:28 thomas Exp $
+ * $Id: pg_amop.h,v 1.9 1998/02/26 04:40:47 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
*/
/* int2_ops */
-DATA(insert OID = 0 ( 405 421 94 1 hashsel hashnpage ));
+DATA(insert OID = 0 ( 405 421 94 1 hashsel hashnpage ));
/* float8_ops */
-DATA(insert OID = 0 ( 405 423 670 1 hashsel hashnpage ));
+DATA(insert OID = 0 ( 405 423 670 1 hashsel hashnpage ));
/* int4_ops */
-DATA(insert OID = 0 ( 405 426 96 1 hashsel hashnpage ));
+DATA(insert OID = 0 ( 405 426 96 1 hashsel hashnpage ));
/* oid_ops */
-DATA(insert OID = 0 ( 405 427 607 1 hashsel hashnpage ));
+DATA(insert OID = 0 ( 405 427 607 1 hashsel hashnpage ));
/* float4_ops */
-DATA(insert OID = 0 ( 405 428 620 1 hashsel hashnpage ));
+DATA(insert OID = 0 ( 405 428 620 1 hashsel hashnpage ));
/* char_ops */
-DATA(insert OID = 0 ( 405 429 92 1 hashsel hashnpage ));
+DATA(insert OID = 0 ( 405 429 92 1 hashsel hashnpage ));
/* char2_ops */
-DATA(insert OID = 0 ( 405 406 412 1 hashsel hashnpage ));
+DATA(insert OID = 0 ( 405 406 412 1 hashsel hashnpage ));
/* char4_ops */
-DATA(insert OID = 0 ( 405 407 413 1 hashsel hashnpage ));
+DATA(insert OID = 0 ( 405 407 413 1 hashsel hashnpage ));
/* char8_ops */
-DATA(insert OID = 0 ( 405 408 414 1 hashsel hashnpage ));
+DATA(insert OID = 0 ( 405 408 414 1 hashsel hashnpage ));
/* char16_ops */
-DATA(insert OID = 0 ( 405 430 1267 1 hashsel hashnpage ));
+DATA(insert OID = 0 ( 405 430 1267 1 hashsel hashnpage ));
/* name_ops */
DATA(insert OID = 0 ( 405 1181 93 1 hashsel hashnpage ));
/* text_ops */
-DATA(insert OID = 0 ( 405 431 98 1 hashsel hashnpage ));
+DATA(insert OID = 0 ( 405 431 98 1 hashsel hashnpage ));
/* bpchar_ops */
DATA(insert OID = 0 ( 405 1076 1054 1 hashsel hashnpage ));
/* varchar_ops */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_attribute.h,v 1.29 1998/02/25 13:09:24 scrappy Exp $
+ * $Id: pg_attribute.h,v 1.30 1998/02/26 04:40:48 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
int4 attnelems;
int4 attcacheoff;
+
/*
* fastgetattr() uses attcacheoff to cache byte offsets of attributes
* in heap tuples. The data actually stored in pg_attribute (-1)
*/
int2 atttypmod;
+
/*
* atttypmod records type-specific modifications supplied at table
- * creation time, and passes it to input and output functions as the
- * third argument.
+ * creation time, and passes it to input and output functions as the
+ * third argument.
*/
bool attbyval;
+
/*
* attbyval is a copy of the typbyval field from pg_type for this
* attribute. See atttypid above. See struct TypeTupleFormData for
*/
#define Schema_pg_type \
{ 1247l, {"typname"}, 19l, 0, NAMEDATALEN, 1, 0, -1, -1, '\0', '\0', 'i', '\0', '\0' }, \
-{ 1247l, {"typowner"}, 26l, 0, 4, 2, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
-{ 1247l, {"typlen"}, 21l, 0, 2, 3, 0, -1, -1, '\001', '\0', 's', '\0', '\0' }, \
-{ 1247l, {"typprtlen"}, 21l, 0, 2, 4, 0, -1, -1, '\001', '\0', 's', '\0', '\0' }, \
-{ 1247l, {"typbyval"}, 16l, 0, 1, 5, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
-{ 1247l, {"typtype"}, 18l, 0, 1, 6, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
-{ 1247l, {"typisdefined"}, 16l, 0, 1, 7, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
-{ 1247l, {"typdelim"}, 18l, 0, 1, 8, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
-{ 1247l, {"typrelid"}, 26l, 0, 4, 9, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
-{ 1247l, {"typelem"}, 26l, 0, 4, 10, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
-{ 1247l, {"typinput"}, 24l, 0, 4, 11, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
-{ 1247l, {"typoutput"}, 24l, 0, 4, 12, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
-{ 1247l, {"typreceive"}, 24l, 0, 4, 13, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
-{ 1247l, {"typsend"}, 24l, 0, 4, 14, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
-{ 1247l, {"typalign"}, 18l, 0, 1, 15, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
-{ 1247l, {"typdefault"}, 25l, 0, -1, 16, 0, -1, -1, '\0' , '\0', 'i', '\0', '\0' }
+{ 1247l, {"typowner"}, 26l, 0, 4, 2, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
+{ 1247l, {"typlen"}, 21l, 0, 2, 3, 0, -1, -1, '\001', '\0', 's', '\0', '\0' }, \
+{ 1247l, {"typprtlen"}, 21l, 0, 2, 4, 0, -1, -1, '\001', '\0', 's', '\0', '\0' }, \
+{ 1247l, {"typbyval"}, 16l, 0, 1, 5, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
+{ 1247l, {"typtype"}, 18l, 0, 1, 6, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
+{ 1247l, {"typisdefined"}, 16l, 0, 1, 7, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
+{ 1247l, {"typdelim"}, 18l, 0, 1, 8, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
+{ 1247l, {"typrelid"}, 26l, 0, 4, 9, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
+{ 1247l, {"typelem"}, 26l, 0, 4, 10, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
+{ 1247l, {"typinput"}, 24l, 0, 4, 11, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
+{ 1247l, {"typoutput"}, 24l, 0, 4, 12, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
+{ 1247l, {"typreceive"}, 24l, 0, 4, 13, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
+{ 1247l, {"typsend"}, 24l, 0, 4, 14, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
+{ 1247l, {"typalign"}, 18l, 0, 1, 15, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
+{ 1247l, {"typdefault"}, 25l, 0, -1, 16, 0, -1, -1, '\0' , '\0', 'i', '\0', '\0' }
DATA(insert OID = 0 ( 1247 typname 19 0 NAMEDATALEN 1 0 -1 -1 f f i f f));
DATA(insert OID = 0 ( 1247 typowner 26 0 4 2 0 -1 -1 t f i f f));
{ 1255l, {"prolang"}, 26l, 0, 4, 3, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
{ 1255l, {"proisinh"}, 16l, 0, 1, 4, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
{ 1255l, {"proistrusted"}, 16l, 0, 1, 5, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
-{ 1255l, {"proiscachable"}, 16l, 0, 1, 6, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
+{ 1255l, {"proiscachable"}, 16l, 0, 1, 6, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
{ 1255l, {"pronargs"}, 21l, 0, 2, 7, 0, -1, -1, '\001', '\0', 's', '\0', '\0' }, \
{ 1255l, {"proretset"}, 16l, 0, 1, 8, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
{ 1255l, {"prorettype"}, 26l, 0, 4, 9, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
* pg_shadow
* ----------------
*/
-DATA(insert OID = 0 ( 1260 usename 19 0 NAMEDATALEN 1 0 -1 -1 f f i f f));
-DATA(insert OID = 0 ( 1260 usesysid 23 0 4 2 0 -1 -1 t f s f f));
-DATA(insert OID = 0 ( 1260 usecreatedb 16 0 1 3 0 -1 -1 t f c f f));
-DATA(insert OID = 0 ( 1260 usetrace 16 0 1 4 0 -1 -1 t f c f f));
-DATA(insert OID = 0 ( 1260 usesuper 16 0 1 5 0 -1 -1 t f c f f));
-DATA(insert OID = 0 ( 1260 usecatupd 16 0 1 6 0 -1 -1 t f c f f));
-DATA(insert OID = 0 ( 1260 passwd 25 0 -1 7 0 -1 -1 f f i f f));
-DATA(insert OID = 0 ( 1260 valuntil 702 0 4 8 0 -1 -1 t f i f f));
+DATA(insert OID = 0 ( 1260 usename 19 0 NAMEDATALEN 1 0 -1 -1 f f i f f));
+DATA(insert OID = 0 ( 1260 usesysid 23 0 4 2 0 -1 -1 t f s f f));
+DATA(insert OID = 0 ( 1260 usecreatedb 16 0 1 3 0 -1 -1 t f c f f));
+DATA(insert OID = 0 ( 1260 usetrace 16 0 1 4 0 -1 -1 t f c f f));
+DATA(insert OID = 0 ( 1260 usesuper 16 0 1 5 0 -1 -1 t f c f f));
+DATA(insert OID = 0 ( 1260 usecatupd 16 0 1 6 0 -1 -1 t f c f f));
+DATA(insert OID = 0 ( 1260 passwd 25 0 -1 7 0 -1 -1 f f i f f));
+DATA(insert OID = 0 ( 1260 valuntil 702 0 4 8 0 -1 -1 t f i f f));
DATA(insert OID = 0 ( 1260 ctid 27 0 6 -1 0 -1 -1 f f i f f));
DATA(insert OID = 0 ( 1260 oid 26 0 4 -2 0 -1 -1 t f i f f));
DATA(insert OID = 0 ( 1260 xmin 28 0 4 -3 0 -1 -1 f f i f f));
*/
#define Schema_pg_attribute \
{ 1249l, {"attrelid"}, 26l, 0, 4, 1, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
-{ 1249l, {"attname"}, 19l, 0, NAMEDATALEN, 2, 0, -1, -1, '\0', '\0', 'i', '\0', '\0' }, \
+{ 1249l, {"attname"}, 19l, 0, NAMEDATALEN, 2, 0, -1, -1, '\0', '\0', 'i', '\0', '\0' }, \
{ 1249l, {"atttypid"}, 26l, 0, 4, 3, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
-{ 1249l, {"attdisbursion"}, 700l, 0, 4, 4, 0, -1, -1, '\0', '\0', 'i', '\0', '\0' }, \
+{ 1249l, {"attdisbursion"}, 700l, 0, 4, 4, 0, -1, -1, '\0', '\0', 'i', '\0', '\0' }, \
{ 1249l, {"attlen"}, 21l, 0, 2, 5, 0, -1, -1, '\001', '\0', 's', '\0', '\0' }, \
{ 1249l, {"attnum"}, 21l, 0, 2, 6, 0, -1, -1, '\001', '\0', 's', '\0', '\0' }, \
{ 1249l, {"attnelems"}, 23l, 0, 4, 7, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
{ 1249l, {"attcacheoff"}, 23l, 0, 4, 8, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
-{ 1249l, {"atttypmod"}, 21l, 0, 2, 9, 0, -1, -1, '\001', '\0', 's', '\0', '\0' }, \
+{ 1249l, {"atttypmod"}, 21l, 0, 2, 9, 0, -1, -1, '\001', '\0', 's', '\0', '\0' }, \
{ 1249l, {"attbyval"}, 16l, 0, 1, 10, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
{ 1249l, {"attisset"}, 16l, 0, 1, 11, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
{ 1249l, {"attalign"}, 18l, 0, 1, 12, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
*/
#define Schema_pg_class \
{ 1259l, {"relname"}, 19l, 0, NAMEDATALEN, 1, 0, -1, -1, '\0', '\0', 'i', '\0', '\0' }, \
-{ 1259l, {"reltype"}, 26l, 0, 4, 2, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
-{ 1259l, {"relowner"}, 26l, 0, 4, 3, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
-{ 1259l, {"relam"}, 26l, 0, 4, 4, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
+{ 1259l, {"reltype"}, 26l, 0, 4, 2, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
+{ 1259l, {"relowner"}, 26l, 0, 4, 3, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
+{ 1259l, {"relam"}, 26l, 0, 4, 4, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
{ 1259l, {"relpages"}, 23, 0l, 4, 5, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
{ 1259l, {"reltuples"}, 23, 0l, 4, 6, 0, -1, -1, '\001', '\0', 'i', '\0', '\0' }, \
{ 1259l, {"relhasindex"}, 16, 0l, 1, 7, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
{ 1259l, {"relisshared"}, 16, 0l, 1, 8, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
{ 1259l, {"relkind"}, 18, 0l, 1, 9, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
{ 1259l, {"relnatts"}, 21, 0l, 2, 10, 0, -1, -1, '\001', '\0', 's', '\0', '\0' }, \
-{ 1259l, {"relchecks"}, 21l, 0, 2, 11, 0, -1, -1, '\001', '\0', 's', '\0', '\0' }, \
-{ 1259l, {"reltriggers"}, 21l, 0, 2, 12, 0, -1, -1, '\001', '\0', 's', '\0', '\0' }, \
+{ 1259l, {"relchecks"}, 21l, 0, 2, 11, 0, -1, -1, '\001', '\0', 's', '\0', '\0' }, \
+{ 1259l, {"reltriggers"}, 21l, 0, 2, 12, 0, -1, -1, '\001', '\0', 's', '\0', '\0' }, \
{ 1259l, {"relhasrules"}, 16, 0l, 1, 13, 0, -1, -1, '\001', '\0', 'c', '\0', '\0' }, \
-{ 1259l, {"relacl"}, 1034l, 0, -1, 14, 0, -1, -1, '\0', '\0', 'i', '\0', '\0' }
+{ 1259l, {"relacl"}, 1034l, 0, -1, 14, 0, -1, -1, '\0', '\0', 'i', '\0', '\0' }
DATA(insert OID = 0 ( 1259 relname 19 0 NAMEDATALEN 1 0 -1 -1 f f i f f));
DATA(insert OID = 0 ( 1259 reltype 26 0 4 2 0 -1 -1 t f i f f));
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_class.h,v 1.19 1998/02/25 13:09:25 scrappy Exp $
+ * $Id: pg_class.h,v 1.20 1998/02/26 04:40:52 momjian Exp $
*
* NOTES
* ``pg_relation'' is being replaced by ``pg_class''. currently
* must be exactly this many instances in Class pg_attribute for this
* class which have attnum > 0 (= user attribute).
*/
- int2 relchecks; /* # of CHECK constraints, not stored in db? */
+ int2 relchecks; /* # of CHECK constraints, not stored in
+ * db? */
int2 reltriggers; /* # of TRIGGERs */
bool relhasrules;
aclitem relacl[1]; /* this is here for the catalog */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_description.h,v 1.4 1997/11/16 04:36:41 momjian Exp $
+ * $Id: pg_description.h,v 1.5 1998/02/26 04:40:53 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
*/
/* ----------------
- * pg_description definition. cpp turns this into
+ * pg_description definition. cpp turns this into
* typedef struct FormData_pg_description
* ----------------
*/
*/
#define Natts_pg_description 2
#define Anum_pg_description_objoid 1
-#define Anum_pg_description_description 2
+#define Anum_pg_description_description 2
/* ----------------
* initial contents of pg_description
*/
/* Because the contents of this table are taken from the other *.h files,
- there is no initialization. It is loaded from initdb using a COPY
+ there is no initialization. It is loaded from initdb using a COPY
statement.
*/
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_operator.h,v 1.24 1998/02/03 16:01:54 thomas Exp $
+ * $Id: pg_operator.h,v 1.25 1998/02/26 04:40:56 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
DATA(insert OID = 796 ( ">=" PGUID 0 b t f 602 602 701 793 0 0 0 path_n_ge intltsel intltjoinsel ));
DATA(insert OID = 797 ( "#" PGUID 0 l t f 0 602 23 0 0 0 0 path_npoints - - ));
DATA(insert OID = 798 ( "?#" PGUID 0 b t f 602 602 16 0 0 0 0 path_inter - - ));
-DATA(insert OID = 799 ( "@-@" PGUID 0 l t f 0 602 701 0 0 0 0 path_length - - ));
+DATA(insert OID = 799 ( "@-@" PGUID 0 l t f 0 602 701 0 0 0 0 path_length - - ));
DATA(insert OID = 800 ( ">^" PGUID 0 b t f 603 603 16 0 0 0 0 box_above intltsel intltjoinsel ));
DATA(insert OID = 801 ( "<^" PGUID 0 b t f 603 603 16 0 0 0 0 box_below intltsel intltjoinsel ));
DATA(insert OID = 802 ( "?#" PGUID 0 b t f 603 603 16 0 0 0 0 box_overlap - - ));
DATA(insert OID = 1589 ( ">" PGUID 0 b t f 601 601 16 1588 0 0 0 lseg_gt intltsel - ));
DATA(insert OID = 1590 ( ">=" PGUID 0 b t f 601 601 16 1587 0 0 0 lseg_ge intltsel - ));
-DATA(insert OID = 1591 ( "@-@" PGUID 0 l t f 0 601 701 0 0 0 0 lseg_length - - ));
+DATA(insert OID = 1591 ( "@-@" PGUID 0 l t f 0 601 701 0 0 0 0 lseg_length - - ));
/*
* function prototypes
*/
-extern void OperatorCreate(char *operatorName,
+extern void
+OperatorCreate(char *operatorName,
char *leftTypeName,
char *rightTypeName,
char *procedureName,
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_proc.h,v 1.46 1998/02/03 16:01:59 thomas Exp $
+ * $Id: pg_proc.h,v 1.47 1998/02/26 04:40:59 momjian Exp $
*
* NOTES
* The script catalog/genbki.sh reads this file and generates .bki
DATA(insert OID = 66 ( int4lt PGUID 11 f t f 2 f 16 "23 23" 100 0 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 67 ( texteq PGUID 11 f t f 2 f 16 "25 25" 100 0 0 0 foo bar ));
+DATA(insert OID = 67 ( texteq PGUID 11 f t f 2 f 16 "25 25" 100 0 0 0 foo bar ));
DESCR("equals");
#define TextEqualRegProcedure 67
DESCR("matches regex., case-sensitive");
DATA(insert OID = 1252 ( nameregexne PGUID 11 f t f 2 f 16 "19 25" 100 0 0 100 foo bar ));
DESCR("does not match regex., case-sensitive");
-DATA(insert OID = 1254 ( textregexeq PGUID 11 f t f 2 f 16 "25 25" 100 0 1 0 foo bar ));
+DATA(insert OID = 1254 ( textregexeq PGUID 11 f t f 2 f 16 "25 25" 100 0 1 0 foo bar ));
DESCR("matches regex., case-sensitive");
-DATA(insert OID = 1256 ( textregexne PGUID 11 f t f 2 f 16 "25 25" 100 0 1 0 foo bar ));
+DATA(insert OID = 1256 ( textregexne PGUID 11 f t f 2 f 16 "25 25" 100 0 1 0 foo bar ));
DESCR("does not match regex., case-sensitive");
DATA(insert OID = 1257 ( textlen PGUID 11 f t f 1 f 23 "25" 100 0 1 0 foo bar ));
DESCR("length");
-DATA(insert OID = 1258 ( textcat PGUID 11 f t f 2 f 25 "25 25" 100 0 1 0 foo bar ));
+DATA(insert OID = 1258 ( textcat PGUID 11 f t f 2 f 25 "25 25" 100 0 1 0 foo bar ));
DESCR("concat");
DATA(insert OID = 84 ( boolne PGUID 11 f t f 2 f 16 "16 16" 100 0 0 100 foo bar ));
DESCR("not equal");
DESCR("selectivity");
DATA(insert OID = 112 ( int4_text PGUID 11 f t f 1 f 25 "23" 100 0 0 100 foo bar ));
- DESCR("convert");
+DESCR("convert");
DATA(insert OID = 113 ( int2_text PGUID 11 f t f 1 f 25 "21" 100 0 0 100 foo bar ));
DESCR("convert");
DATA(insert OID = 114 ( oid_text PGUID 11 f t f 1 f 25 "26" 100 0 0 100 foo bar ));
DESCR("(internal)");
DATA(insert OID = 124 ( box_out PGUID 11 f t f 1 f 23 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
-DATA(insert OID = 125 ( box_overlap PGUID 11 f t f 2 f 16 "603 603" 100 1 0 100 foo bar ));
+DATA(insert OID = 125 ( box_overlap PGUID 11 f t f 2 f 16 "603 603" 100 1 0 100 foo bar ));
DESCR("overlaps");
-DATA(insert OID = 126 ( box_ge PGUID 11 f t f 2 f 16 "603 603" 100 1 0 100 foo bar ));
+DATA(insert OID = 126 ( box_ge PGUID 11 f t f 2 f 16 "603 603" 100 1 0 100 foo bar ));
DESCR("greater-than-or-equals");
-DATA(insert OID = 127 ( box_gt PGUID 11 f t f 2 f 16 "603 603" 100 1 0 100 foo bar ));
+DATA(insert OID = 127 ( box_gt PGUID 11 f t f 2 f 16 "603 603" 100 1 0 100 foo bar ));
DESCR("greater-than");
-DATA(insert OID = 128 ( box_eq PGUID 11 f t f 2 f 16 "603 603" 100 1 0 100 foo bar ));
+DATA(insert OID = 128 ( box_eq PGUID 11 f t f 2 f 16 "603 603" 100 1 0 100 foo bar ));
DESCR("equals");
-DATA(insert OID = 129 ( box_lt PGUID 11 f t f 2 f 16 "603 603" 100 1 0 100 foo bar ));
+DATA(insert OID = 129 ( box_lt PGUID 11 f t f 2 f 16 "603 603" 100 1 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 130 ( box_le PGUID 11 f t f 2 f 16 "603 603" 100 1 0 100 foo bar ));
+DATA(insert OID = 130 ( box_le PGUID 11 f t f 2 f 16 "603 603" 100 1 0 100 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 131 ( point_above PGUID 11 f t f 2 f 16 "600 600" 100 0 0 100 foo bar ));
+DATA(insert OID = 131 ( point_above PGUID 11 f t f 2 f 16 "600 600" 100 0 0 100 foo bar ));
DESCR("is above");
-DATA(insert OID = 132 ( point_left PGUID 11 f t f 2 f 16 "600 600" 100 0 0 100 foo bar ));
+DATA(insert OID = 132 ( point_left PGUID 11 f t f 2 f 16 "600 600" 100 0 0 100 foo bar ));
DESCR("is left of");
-DATA(insert OID = 133 ( point_right PGUID 11 f t f 2 f 16 "600 600" 100 0 0 100 foo bar ));
+DATA(insert OID = 133 ( point_right PGUID 11 f t f 2 f 16 "600 600" 100 0 0 100 foo bar ));
DESCR("is left of");
-DATA(insert OID = 134 ( point_below PGUID 11 f t f 2 f 16 "600 600" 100 0 0 100 foo bar ));
+DATA(insert OID = 134 ( point_below PGUID 11 f t f 2 f 16 "600 600" 100 0 0 100 foo bar ));
DESCR("is below");
-DATA(insert OID = 135 ( point_eq PGUID 11 f t f 2 f 16 "600 600" 100 0 0 100 foo bar ));
+DATA(insert OID = 135 ( point_eq PGUID 11 f t f 2 f 16 "600 600" 100 0 0 100 foo bar ));
DESCR("same as");
-DATA(insert OID = 136 ( on_pb PGUID 11 f t f 2 f 16 "600 603" 100 0 0 100 foo bar ));
+DATA(insert OID = 136 ( on_pb PGUID 11 f t f 2 f 16 "600 603" 100 0 0 100 foo bar ));
DESCR("point is inside");
DATA(insert OID = 137 ( on_ppath PGUID 11 f t f 2 f 16 "600 602" 100 0 1 0 foo bar ));
DESCR("contained in");
DESCR("multiply");
DATA(insert OID = 142 ( int4fac PGUID 11 f t f 1 f 23 "23" 100 0 0 100 foo bar ));
DESCR("fraction");
-DATA(insert OID = 143 ( pointdist PGUID 11 f t f 2 f 23 "600 600" 100 0 0 100 foo bar ));
+DATA(insert OID = 143 ( pointdist PGUID 11 f t f 2 f 23 "600 600" 100 0 0 100 foo bar ));
DESCR("");
DATA(insert OID = 144 ( int4ne PGUID 11 f t f 2 f 16 "23 23" 100 0 0 100 foo bar ));
DESCR("not equal");
DESCR("modulus");
DATA(insert OID = 156 ( int4mod PGUID 11 f t f 2 f 23 "23 23" 100 0 0 100 foo bar ));
DESCR("modulus");
-DATA(insert OID = 157 ( textne PGUID 11 f t f 2 f 16 "25 25" 100 0 0 0 foo bar ));
+DATA(insert OID = 157 ( textne PGUID 11 f t f 2 f 16 "25 25" 100 0 0 0 foo bar ));
DESCR("not equal");
DATA(insert OID = 158 ( int24eq PGUID 11 f t f 2 f 23 "21 23" 100 0 0 100 foo bar ));
DESCR("equals");
DATA(insert OID = 185 ( oidne PGUID 11 f t f 2 f 16 "26 26" 100 0 0 100 foo bar ));
DESCR("not equal");
-DATA(insert OID = 186 ( box_same PGUID 11 f t f 2 f 16 "603 603" 100 0 0 100 foo bar ));
+DATA(insert OID = 186 ( box_same PGUID 11 f t f 2 f 16 "603 603" 100 0 0 100 foo bar ));
DESCR("same as");
-DATA(insert OID = 187 ( box_contain PGUID 11 f t f 2 f 16 "603 603" 100 0 0 100 foo bar ));
+DATA(insert OID = 187 ( box_contain PGUID 11 f t f 2 f 16 "603 603" 100 0 0 100 foo bar ));
DESCR("contains");
-DATA(insert OID = 188 ( box_left PGUID 11 f t f 2 f 16 "603 603" 100 0 0 100 foo bar ));
+DATA(insert OID = 188 ( box_left PGUID 11 f t f 2 f 16 "603 603" 100 0 0 100 foo bar ));
DESCR("is left of");
-DATA(insert OID = 189 ( box_overleft PGUID 11 f t f 2 f 16 "603 603" 100 0 0 100 foo bar ));
+DATA(insert OID = 189 ( box_overleft PGUID 11 f t f 2 f 16 "603 603" 100 0 0 100 foo bar ));
DESCR("overlaps, but does not extend to right of");
-DATA(insert OID = 190 ( box_overright PGUID 11 f t f 2 f 16 "603 603" 100 0 0 100 foo bar ));
+DATA(insert OID = 190 ( box_overright PGUID 11 f t f 2 f 16 "603 603" 100 0 0 100 foo bar ));
DESCR("overlaps, but does not extend to left of");
-DATA(insert OID = 191 ( box_right PGUID 11 f t f 2 f 16 "603 603" 100 0 0 100 foo bar ));
+DATA(insert OID = 191 ( box_right PGUID 11 f t f 2 f 16 "603 603" 100 0 0 100 foo bar ));
DESCR("is left of");
-DATA(insert OID = 192 ( box_contained PGUID 11 f t f 2 f 16 "603 603" 100 0 0 100 foo bar ));
+DATA(insert OID = 192 ( box_contained PGUID 11 f t f 2 f 16 "603 603" 100 0 0 100 foo bar ));
DESCR("contained in");
DATA(insert OID = 193 ( rt_box_union PGUID 11 f t f 2 f 603 "603 603" 100 0 0 100 foo bar ));
DESCR("r-tree");
DESCR("(internal)");
DATA(insert OID = 247 ( tintervalout PGUID 11 f t f 1 f 23 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
-DATA(insert OID = 248 ( ininterval PGUID 11 f t f 2 f 16 "702 704" 100 0 0 100 foo bar ));
+DATA(insert OID = 248 ( ininterval PGUID 11 f t f 2 f 16 "702 704" 100 0 0 100 foo bar ));
DESCR("abstime in tinterval");
DATA(insert OID = 249 ( intervalrel PGUID 11 f t f 1 f 703 "704" 100 0 0 100 foo bar ));
DESCR("");
DATA(insert OID = 250 ( timenow PGUID 11 f t f 0 f 702 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
-DATA(insert OID = 251 ( abstimeeq PGUID 11 f t f 2 f 16 "702 702" 100 0 0 100 foo bar ));
+DATA(insert OID = 251 ( abstimeeq PGUID 11 f t f 2 f 16 "702 702" 100 0 0 100 foo bar ));
DESCR("equals");
-DATA(insert OID = 252 ( abstimene PGUID 11 f t f 2 f 16 "702 702" 100 0 0 100 foo bar ));
+DATA(insert OID = 252 ( abstimene PGUID 11 f t f 2 f 16 "702 702" 100 0 0 100 foo bar ));
DESCR("not equal");
-DATA(insert OID = 253 ( abstimelt PGUID 11 f t f 2 f 16 "702 702" 100 0 0 100 foo bar ));
+DATA(insert OID = 253 ( abstimelt PGUID 11 f t f 2 f 16 "702 702" 100 0 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 254 ( abstimegt PGUID 11 f t f 2 f 16 "702 702" 100 0 0 100 foo bar ));
+DATA(insert OID = 254 ( abstimegt PGUID 11 f t f 2 f 16 "702 702" 100 0 0 100 foo bar ));
DESCR("greater-than");
-DATA(insert OID = 255 ( abstimele PGUID 11 f t f 2 f 16 "702 702" 100 0 0 100 foo bar ));
+DATA(insert OID = 255 ( abstimele PGUID 11 f t f 2 f 16 "702 702" 100 0 0 100 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 256 ( abstimege PGUID 11 f t f 2 f 16 "702 702" 100 0 0 100 foo bar ));
+DATA(insert OID = 256 ( abstimege PGUID 11 f t f 2 f 16 "702 702" 100 0 0 100 foo bar ));
DESCR("greater-than-or-equals");
-DATA(insert OID = 257 ( reltimeeq PGUID 11 f t f 2 f 16 "703 703" 100 0 0 100 foo bar ));
+DATA(insert OID = 257 ( reltimeeq PGUID 11 f t f 2 f 16 "703 703" 100 0 0 100 foo bar ));
DESCR("equals");
-DATA(insert OID = 258 ( reltimene PGUID 11 f t f 2 f 16 "703 703" 100 0 0 100 foo bar ));
+DATA(insert OID = 258 ( reltimene PGUID 11 f t f 2 f 16 "703 703" 100 0 0 100 foo bar ));
DESCR("not equal");
-DATA(insert OID = 259 ( reltimelt PGUID 11 f t f 2 f 16 "703 703" 100 0 0 100 foo bar ));
+DATA(insert OID = 259 ( reltimelt PGUID 11 f t f 2 f 16 "703 703" 100 0 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 260 ( reltimegt PGUID 11 f t f 2 f 16 "703 703" 100 0 0 100 foo bar ));
+DATA(insert OID = 260 ( reltimegt PGUID 11 f t f 2 f 16 "703 703" 100 0 0 100 foo bar ));
DESCR("greater-than");
-DATA(insert OID = 261 ( reltimele PGUID 11 f t f 2 f 16 "703 703" 100 0 0 100 foo bar ));
+DATA(insert OID = 261 ( reltimele PGUID 11 f t f 2 f 16 "703 703" 100 0 0 100 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 262 ( reltimege PGUID 11 f t f 2 f 16 "703 703" 100 0 0 100 foo bar ));
+DATA(insert OID = 262 ( reltimege PGUID 11 f t f 2 f 16 "703 703" 100 0 0 100 foo bar ));
DESCR("greater-than-or-equals");
-DATA(insert OID = 263 ( intervalsame PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
+DATA(insert OID = 263 ( intervalsame PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
DESCR("same as");
-DATA(insert OID = 264 ( intervalct PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
+DATA(insert OID = 264 ( intervalct PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 265 ( intervalov PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
+DATA(insert OID = 265 ( intervalov PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
DESCR("overlaps");
-DATA(insert OID = 266 ( intervalleneq PGUID 11 f t f 2 f 16 "704 703" 100 0 0 100 foo bar ));
+DATA(insert OID = 266 ( intervalleneq PGUID 11 f t f 2 f 16 "704 703" 100 0 0 100 foo bar ));
DESCR("length equals");
-DATA(insert OID = 267 ( intervallenne PGUID 11 f t f 2 f 16 "704 703" 100 0 0 100 foo bar ));
+DATA(insert OID = 267 ( intervallenne PGUID 11 f t f 2 f 16 "704 703" 100 0 0 100 foo bar ));
DESCR("length not equal to");
-DATA(insert OID = 268 ( intervallenlt PGUID 11 f t f 2 f 16 "704 703" 100 0 0 100 foo bar ));
+DATA(insert OID = 268 ( intervallenlt PGUID 11 f t f 2 f 16 "704 703" 100 0 0 100 foo bar ));
DESCR("length less-than");
-DATA(insert OID = 269 ( intervallengt PGUID 11 f t f 2 f 16 "704 703" 100 0 0 100 foo bar ));
+DATA(insert OID = 269 ( intervallengt PGUID 11 f t f 2 f 16 "704 703" 100 0 0 100 foo bar ));
DESCR("length greater-than");
-DATA(insert OID = 270 ( intervallenle PGUID 11 f t f 2 f 16 "704 703" 100 0 0 100 foo bar ));
+DATA(insert OID = 270 ( intervallenle PGUID 11 f t f 2 f 16 "704 703" 100 0 0 100 foo bar ));
DESCR("length less-than-or-equals");
-DATA(insert OID = 271 ( intervallenge PGUID 11 f t f 2 f 16 "704 703" 100 0 0 100 foo bar ));
+DATA(insert OID = 271 ( intervallenge PGUID 11 f t f 2 f 16 "704 703" 100 0 0 100 foo bar ));
DESCR("length greater-than-or-equals");
DATA(insert OID = 272 ( intervalstart PGUID 11 f t f 1 f 702 "704" 100 0 0 100 foo bar ));
DESCR("start of interval");
DESCR("");
DATA(insert OID = 274 ( timeofday PGUID 11 f t f 0 f 25 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
-DATA(insert OID = 275 ( abstime_finite PGUID 11 f t f 1 f 16 "702" 100 0 0 100 foo bar ));
+DATA(insert OID = 275 ( abstime_finite PGUID 11 f t f 1 f 16 "702" 100 0 0 100 foo bar ));
DESCR("");
DATA(insert OID = 276 ( int2fac PGUID 11 f t f 1 f 21 "21" 100 0 0 100 foo bar ));
DESCR("");
-DATA(insert OID = 277 ( inter_sl PGUID 11 f t f 2 f 16 "601 628" 100 0 0 100 foo bar ));
+DATA(insert OID = 277 ( inter_sl PGUID 11 f t f 2 f 16 "601 628" 100 0 0 100 foo bar ));
DESCR("");
-DATA(insert OID = 278 ( inter_lb PGUID 11 f t f 2 f 16 "628 603" 100 0 0 100 foo bar ));
+DATA(insert OID = 278 ( inter_lb PGUID 11 f t f 2 f 16 "628 603" 100 0 0 100 foo bar ));
DESCR("");
DATA(insert OID = 279 ( float48mul PGUID 11 f t f 2 f 701 "700 701" 100 0 0 100 foo bar ));
DATA(insert OID = 286 ( float84mi PGUID 11 f t f 2 f 701 "701 700" 100 0 0 100 foo bar ));
DESCR("subtract");
-DATA(insert OID = 287 ( float4eq PGUID 11 f t f 2 f 16 "700 700" 100 0 0 100 foo bar ));
+DATA(insert OID = 287 ( float4eq PGUID 11 f t f 2 f 16 "700 700" 100 0 0 100 foo bar ));
DESCR("equals");
-DATA(insert OID = 288 ( float4ne PGUID 11 f t f 2 f 16 "700 700" 100 0 0 100 foo bar ));
+DATA(insert OID = 288 ( float4ne PGUID 11 f t f 2 f 16 "700 700" 100 0 0 100 foo bar ));
DESCR("not equal");
-DATA(insert OID = 289 ( float4lt PGUID 11 f t f 2 f 16 "700 700" 100 0 0 100 foo bar ));
+DATA(insert OID = 289 ( float4lt PGUID 11 f t f 2 f 16 "700 700" 100 0 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 290 ( float4le PGUID 11 f t f 2 f 16 "700 700" 100 0 0 100 foo bar ));
+DATA(insert OID = 290 ( float4le PGUID 11 f t f 2 f 16 "700 700" 100 0 0 100 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 291 ( float4gt PGUID 11 f t f 2 f 16 "700 700" 100 0 0 100 foo bar ));
+DATA(insert OID = 291 ( float4gt PGUID 11 f t f 2 f 16 "700 700" 100 0 0 100 foo bar ));
DESCR("greater-than");
-DATA(insert OID = 292 ( float4ge PGUID 11 f t f 2 f 16 "700 700" 100 0 0 100 foo bar ));
+DATA(insert OID = 292 ( float4ge PGUID 11 f t f 2 f 16 "700 700" 100 0 0 100 foo bar ));
DESCR("greater-than-or-equals");
-DATA(insert OID = 293 ( float8eq PGUID 11 f t f 2 f 16 "701 701" 100 0 0 100 foo bar ));
+DATA(insert OID = 293 ( float8eq PGUID 11 f t f 2 f 16 "701 701" 100 0 0 100 foo bar ));
DESCR("equals");
-DATA(insert OID = 294 ( float8ne PGUID 11 f t f 2 f 16 "701 701" 100 0 0 100 foo bar ));
+DATA(insert OID = 294 ( float8ne PGUID 11 f t f 2 f 16 "701 701" 100 0 0 100 foo bar ));
DESCR("not equal");
-DATA(insert OID = 295 ( float8lt PGUID 11 f t f 2 f 16 "701 701" 100 0 0 100 foo bar ));
+DATA(insert OID = 295 ( float8lt PGUID 11 f t f 2 f 16 "701 701" 100 0 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 296 ( float8le PGUID 11 f t f 2 f 16 "701 701" 100 0 0 100 foo bar ));
+DATA(insert OID = 296 ( float8le PGUID 11 f t f 2 f 16 "701 701" 100 0 0 100 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 297 ( float8gt PGUID 11 f t f 2 f 16 "701 701" 100 0 0 100 foo bar ));
+DATA(insert OID = 297 ( float8gt PGUID 11 f t f 2 f 16 "701 701" 100 0 0 100 foo bar ));
DESCR("greater-than");
-DATA(insert OID = 298 ( float8ge PGUID 11 f t f 2 f 16 "701 701" 100 0 0 100 foo bar ));
+DATA(insert OID = 298 ( float8ge PGUID 11 f t f 2 f 16 "701 701" 100 0 0 100 foo bar ));
DESCR("greater-than-or-equals");
-DATA(insert OID = 299 ( float48eq PGUID 11 f t f 2 f 16 "700 701" 100 0 0 100 foo bar ));
+DATA(insert OID = 299 ( float48eq PGUID 11 f t f 2 f 16 "700 701" 100 0 0 100 foo bar ));
DESCR("equals");
/* OIDS 300 - 399 */
-DATA(insert OID = 300 ( float48ne PGUID 11 f t f 2 f 16 "700 701" 100 0 0 100 foo bar ));
+DATA(insert OID = 300 ( float48ne PGUID 11 f t f 2 f 16 "700 701" 100 0 0 100 foo bar ));
DESCR("not equal");
-DATA(insert OID = 301 ( float48lt PGUID 11 f t f 2 f 16 "700 701" 100 0 0 100 foo bar ));
+DATA(insert OID = 301 ( float48lt PGUID 11 f t f 2 f 16 "700 701" 100 0 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 302 ( float48le PGUID 11 f t f 2 f 16 "700 701" 100 0 0 100 foo bar ));
+DATA(insert OID = 302 ( float48le PGUID 11 f t f 2 f 16 "700 701" 100 0 0 100 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 303 ( float48gt PGUID 11 f t f 2 f 16 "700 701" 100 0 0 100 foo bar ));
+DATA(insert OID = 303 ( float48gt PGUID 11 f t f 2 f 16 "700 701" 100 0 0 100 foo bar ));
DESCR("greater-than");
-DATA(insert OID = 304 ( float48ge PGUID 11 f t f 2 f 16 "700 701" 100 0 0 100 foo bar ));
+DATA(insert OID = 304 ( float48ge PGUID 11 f t f 2 f 16 "700 701" 100 0 0 100 foo bar ));
DESCR("greater-than-or-equals");
-DATA(insert OID = 305 ( float84eq PGUID 11 f t f 2 f 16 "701 700" 100 0 0 100 foo bar ));
+DATA(insert OID = 305 ( float84eq PGUID 11 f t f 2 f 16 "701 700" 100 0 0 100 foo bar ));
DESCR("equals");
-DATA(insert OID = 306 ( float84ne PGUID 11 f t f 2 f 16 "701 700" 100 0 0 100 foo bar ));
+DATA(insert OID = 306 ( float84ne PGUID 11 f t f 2 f 16 "701 700" 100 0 0 100 foo bar ));
DESCR("not equal");
-DATA(insert OID = 307 ( float84lt PGUID 11 f t f 2 f 16 "701 700" 100 0 0 100 foo bar ));
+DATA(insert OID = 307 ( float84lt PGUID 11 f t f 2 f 16 "701 700" 100 0 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 308 ( float84le PGUID 11 f t f 2 f 16 "701 700" 100 0 0 100 foo bar ));
+DATA(insert OID = 308 ( float84le PGUID 11 f t f 2 f 16 "701 700" 100 0 0 100 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 309 ( float84gt PGUID 11 f t f 2 f 16 "701 700" 100 0 0 100 foo bar ));
+DATA(insert OID = 309 ( float84gt PGUID 11 f t f 2 f 16 "701 700" 100 0 0 100 foo bar ));
DESCR("greater-than");
-DATA(insert OID = 310 ( float84ge PGUID 11 f t f 2 f 16 "701 700" 100 0 0 100 foo bar ));
+DATA(insert OID = 310 ( float84ge PGUID 11 f t f 2 f 16 "701 700" 100 0 0 100 foo bar ));
DESCR("greater-than-or-equals");
DATA(insert OID = 311 ( ftod PGUID 11 f t f 2 f 701 "700" 100 0 0 100 foo bar ));
DESCR("convert");
DATA(insert OID = 314 ( i4toi2 PGUID 11 f t f 1 f 21 "23" 100 0 0 100 foo bar ));
DESCR("convert");
-DATA(insert OID = 315 ( keyfirsteq PGUID 11 f t f 2 f 16 "0 21" 100 0 0 100 foo bar ));
+DATA(insert OID = 315 ( keyfirsteq PGUID 11 f t f 2 f 16 "0 21" 100 0 0 100 foo bar ));
DESCR("");
DATA(insert OID = 316 ( i4tod PGUID 11 f t f 1 f 701 "23" 100 0 0 100 foo bar ));
DESCR("convert");
DESCR("btree less-equal-greater");
DATA(insert OID = 353 ( btint24cmp PGUID 11 f t f 2 f 23 "21 23" 100 0 0 100 foo bar ));
DESCR("btree less-equal-greater");
-DATA(insert OID = 354 ( btfloat4cmp PGUID 11 f t f 2 f 23 "700 700" 100 0 0 100 foo bar ));
+DATA(insert OID = 354 ( btfloat4cmp PGUID 11 f t f 2 f 23 "700 700" 100 0 0 100 foo bar ));
DESCR("btree less-equal-greater");
-DATA(insert OID = 355 ( btfloat8cmp PGUID 11 f t f 2 f 23 "701 701" 100 0 0 100 foo bar ));
+DATA(insert OID = 355 ( btfloat8cmp PGUID 11 f t f 2 f 23 "701 701" 100 0 0 100 foo bar ));
DESCR("btree less-equal-greater");
DATA(insert OID = 356 ( btoidcmp PGUID 11 f t f 2 f 23 "26 26" 100 0 0 100 foo bar ));
DESCR("btree less-equal-greater");
-DATA(insert OID = 357 ( btabstimecmp PGUID 11 f t f 2 f 23 "702 702" 100 0 0 100 foo bar ));
+DATA(insert OID = 357 ( btabstimecmp PGUID 11 f t f 2 f 23 "702 702" 100 0 0 100 foo bar ));
DESCR("btree less-equal-greater");
DATA(insert OID = 358 ( btcharcmp PGUID 11 f t f 2 f 23 "18 18" 100 0 0 100 foo bar ));
DESCR("btree less-equal-greater");
DESCR("closest point on box");
DATA(insert OID = 368 ( close_sb PGUID 11 f t f 2 f 600 "601 603" 100 0 0 100 foo bar ));
DESCR("closest point to line segment on box");
-DATA(insert OID = 369 ( on_ps PGUID 11 f t f 2 f 16 "600 601" 100 0 0 100 foo bar ));
+DATA(insert OID = 369 ( on_ps PGUID 11 f t f 2 f 16 "600 601" 100 0 0 100 foo bar ));
DESCR("contained in");
DATA(insert OID = 370 ( path_distance PGUID 11 f t f 2 f 701 "602 602" 100 0 1 0 foo bar ));
DESCR("distance between");
DATA(insert OID = 371 ( dist_ppath PGUID 11 f t f 2 f 701 "600 602" 100 0 1 0 foo bar ));
DESCR("distance between");
-DATA(insert OID = 372 ( on_sb PGUID 11 f t f 2 f 16 "601 603" 100 0 0 100 foo bar ));
+DATA(insert OID = 372 ( on_sb PGUID 11 f t f 2 f 16 "601 603" 100 0 0 100 foo bar ));
DESCR("contained in");
-DATA(insert OID = 373 ( inter_sb PGUID 11 f t f 2 f 16 "601 603" 100 0 0 100 foo bar ));
+DATA(insert OID = 373 ( inter_sb PGUID 11 f t f 2 f 16 "601 603" 100 0 0 100 foo bar ));
DESCR("");
DATA(insert OID = 1274 ( btchar16cmp PGUID 11 f t f 2 f 23 "19 19" 100 0 0 100 foo bar ));
DESCR("btree less-equal-greater");
DESCR("hash");
DATA(insert OID = 450 ( hashint4 PGUID 11 f t f 2 f 23 "23 23" 100 0 0 100 foo bar ));
DESCR("hash");
-DATA(insert OID = 451 ( hashfloat4 PGUID 11 f t f 2 f 23 "700 700" 100 0 0 100 foo bar ));
+DATA(insert OID = 451 ( hashfloat4 PGUID 11 f t f 2 f 23 "700 700" 100 0 0 100 foo bar ));
DESCR("hash");
-DATA(insert OID = 452 ( hashfloat8 PGUID 11 f t f 2 f 23 "701 701" 100 0 0 100 foo bar ));
+DATA(insert OID = 452 ( hashfloat8 PGUID 11 f t f 2 f 23 "701 701" 100 0 0 100 foo bar ));
DESCR("hash");
DATA(insert OID = 453 ( hashoid PGUID 11 f t f 2 f 23 "26 26" 100 0 0 100 foo bar ));
DESCR("hash");
DESCR("(internal)");
DATA(insert OID = 471 ( char8out PGUID 11 f t f 1 f 23 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
-DATA(insert OID = 472 ( char2eq PGUID 11 f t f 2 f 16 "409 409" 100 0 0 100 foo bar ));
+DATA(insert OID = 472 ( char2eq PGUID 11 f t f 2 f 16 "409 409" 100 0 0 100 foo bar ));
DESCR("equals");
-DATA(insert OID = 473 ( char4eq PGUID 11 f t f 2 f 16 "410 410" 100 0 0 100 foo bar ));
+DATA(insert OID = 473 ( char4eq PGUID 11 f t f 2 f 16 "410 410" 100 0 0 100 foo bar ));
DESCR("equals");
-DATA(insert OID = 474 ( char8eq PGUID 11 f t f 2 f 16 "411 411" 100 0 0 100 foo bar ));
+DATA(insert OID = 474 ( char8eq PGUID 11 f t f 2 f 16 "411 411" 100 0 0 100 foo bar ));
DESCR("equals");
-DATA(insert OID = 475 ( char2lt PGUID 11 f t f 2 f 16 "409 409" 100 0 0 100 foo bar ));
+DATA(insert OID = 475 ( char2lt PGUID 11 f t f 2 f 16 "409 409" 100 0 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 476 ( char4lt PGUID 11 f t f 2 f 16 "410 410" 100 0 0 100 foo bar ));
+DATA(insert OID = 476 ( char4lt PGUID 11 f t f 2 f 16 "410 410" 100 0 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 477 ( char8lt PGUID 11 f t f 2 f 16 "411 411" 100 0 0 100 foo bar ));
+DATA(insert OID = 477 ( char8lt PGUID 11 f t f 2 f 16 "411 411" 100 0 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 478 ( char2le PGUID 11 f t f 2 f 16 "409 409" 100 0 0 100 foo bar ));
+DATA(insert OID = 478 ( char2le PGUID 11 f t f 2 f 16 "409 409" 100 0 0 100 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 479 ( char4le PGUID 11 f t f 2 f 16 "410 410" 100 0 0 100 foo bar ));
+DATA(insert OID = 479 ( char4le PGUID 11 f t f 2 f 16 "410 410" 100 0 0 100 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 480 ( char8le PGUID 11 f t f 2 f 16 "411 411" 100 0 0 100 foo bar ));
+DATA(insert OID = 480 ( char8le PGUID 11 f t f 2 f 16 "411 411" 100 0 0 100 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 481 ( char2gt PGUID 11 f t f 2 f 16 "409 409" 100 0 0 100 foo bar ));
+DATA(insert OID = 481 ( char2gt PGUID 11 f t f 2 f 16 "409 409" 100 0 0 100 foo bar ));
DESCR("greater-than");
-DATA(insert OID = 482 ( char4gt PGUID 11 f t f 2 f 16 "410 410" 100 0 0 100 foo bar ));
+DATA(insert OID = 482 ( char4gt PGUID 11 f t f 2 f 16 "410 410" 100 0 0 100 foo bar ));
DESCR("greater-than");
-DATA(insert OID = 483 ( char8gt PGUID 11 f t f 2 f 16 "411 411" 100 0 0 100 foo bar ));
+DATA(insert OID = 483 ( char8gt PGUID 11 f t f 2 f 16 "411 411" 100 0 0 100 foo bar ));
DESCR("greater-than");
-DATA(insert OID = 484 ( char2ge PGUID 11 f t f 2 f 16 "409 409" 100 0 0 100 foo bar ));
+DATA(insert OID = 484 ( char2ge PGUID 11 f t f 2 f 16 "409 409" 100 0 0 100 foo bar ));
DESCR("greater-than-or-equals");
DATA(insert OID = 1275 ( char16eq PGUID 11 f t f 2 f 16 "19 19" 100 0 0 100 foo bar ));
DESCR("equals");
DESCR("convert to interval");
DATA(insert OID = 683 ( oid8eq PGUID 11 f t f 2 f 16 "30 30" 100 0 0 100 foo bar ));
DESCR("equals");
-DATA(insert OID = 684 ( char4ge PGUID 11 f t f 2 f 16 "410 410" 100 0 0 100 foo bar ));
+DATA(insert OID = 684 ( char4ge PGUID 11 f t f 2 f 16 "410 410" 100 0 0 100 foo bar ));
DESCR("greater-than-or-equals");
-DATA(insert OID = 685 ( char8ge PGUID 11 f t f 2 f 16 "411 411" 100 0 0 100 foo bar ));
+DATA(insert OID = 685 ( char8ge PGUID 11 f t f 2 f 16 "411 411" 100 0 0 100 foo bar ));
DESCR("greater-than-or-equals");
-DATA(insert OID = 686 ( char2ne PGUID 11 f t f 2 f 16 "409 409" 100 0 0 100 foo bar ));
+DATA(insert OID = 686 ( char2ne PGUID 11 f t f 2 f 16 "409 409" 100 0 0 100 foo bar ));
DESCR("not equal");
-DATA(insert OID = 687 ( char4ne PGUID 11 f t f 2 f 16 "410 410" 100 0 0 100 foo bar ));
+DATA(insert OID = 687 ( char4ne PGUID 11 f t f 2 f 16 "410 410" 100 0 0 100 foo bar ));
DESCR("not equal");
-DATA(insert OID = 688 ( char8ne PGUID 11 f t f 2 f 16 "411 411" 100 0 0 100 foo bar ));
+DATA(insert OID = 688 ( char8ne PGUID 11 f t f 2 f 16 "411 411" 100 0 0 100 foo bar ));
DESCR("not equal");
-DATA(insert OID = 689 ( btchar2cmp PGUID 11 f t f 2 f 23 "409 409" 100 0 0 100 foo bar ));
+DATA(insert OID = 689 ( btchar2cmp PGUID 11 f t f 2 f 23 "409 409" 100 0 0 100 foo bar ));
DESCR("btree less-equal-greater");
-DATA(insert OID = 690 ( btchar4cmp PGUID 11 f t f 2 f 23 "410 410" 100 0 0 100 foo bar ));
+DATA(insert OID = 690 ( btchar4cmp PGUID 11 f t f 2 f 23 "410 410" 100 0 0 100 foo bar ));
DESCR("btree less-equal-greater");
-DATA(insert OID = 691 ( btchar8cmp PGUID 11 f t f 2 f 23 "411 411" 100 0 0 100 foo bar ));
+DATA(insert OID = 691 ( btchar8cmp PGUID 11 f t f 2 f 23 "411 411" 100 0 0 100 foo bar ));
DESCR("btree less-equal-greater");
-DATA(insert OID = 692 ( hashchar2 PGUID 11 f t f 2 f 23 "409 409" 100 0 0 100 foo bar ));
+DATA(insert OID = 692 ( hashchar2 PGUID 11 f t f 2 f 23 "409 409" 100 0 0 100 foo bar ));
DESCR("hash");
-DATA(insert OID = 693 ( hashchar4 PGUID 11 f t f 2 f 23 "410 410" 100 0 0 100 foo bar ));
+DATA(insert OID = 693 ( hashchar4 PGUID 11 f t f 2 f 23 "410 410" 100 0 0 100 foo bar ));
DESCR("hash");
-DATA(insert OID = 694 ( hashchar8 PGUID 11 f t f 2 f 23 "411 411" 100 0 0 100 foo bar ));
+DATA(insert OID = 694 ( hashchar8 PGUID 11 f t f 2 f 23 "411 411" 100 0 0 100 foo bar ));
DESCR("hash");
DATA(insert OID = 695 ( char8regexeq PGUID 11 f t f 2 f 16 "411 25" 100 0 0 100 foo bar ));
DESCR("matches regex., case-sensitive");
DATA(insert OID = 730 ( pqtest PGUID 11 f t f 1 f 23 "25" 100 0 0 100 foo bar ));
DESCR("");
-DATA(insert OID = 740 ( text_lt PGUID 11 f t f 2 f 16 "25 25" 100 0 0 0 foo bar ));
+DATA(insert OID = 740 ( text_lt PGUID 11 f t f 2 f 16 "25 25" 100 0 0 0 foo bar ));
DESCR("less-than");
-DATA(insert OID = 741 ( text_le PGUID 11 f t f 2 f 16 "25 25" 100 0 0 0 foo bar ));
+DATA(insert OID = 741 ( text_le PGUID 11 f t f 2 f 16 "25 25" 100 0 0 0 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 742 ( text_gt PGUID 11 f t f 2 f 16 "25 25" 100 0 0 0 foo bar ));
+DATA(insert OID = 742 ( text_gt PGUID 11 f t f 2 f 16 "25 25" 100 0 0 0 foo bar ));
DESCR("greater-than");
-DATA(insert OID = 743 ( text_ge PGUID 11 f t f 2 f 16 "25 25" 100 0 0 0 foo bar ));
+DATA(insert OID = 743 ( text_ge PGUID 11 f t f 2 f 16 "25 25" 100 0 0 0 foo bar ));
DESCR("greater-than-or-equals");
DATA(insert OID = 744 ( array_eq PGUID 11 f t f 2 f 16 "0 0" 100 0 0 100 foo bar));
DESCR("array");
DATA(insert OID = 749 ( array_ref PGUID 11 f t f 7 f 23 "0 23 0 23 23 23 0" 100 0 0 100 foo bar));
DESCR("array");
-DATA(insert OID = 750 ( array_in PGUID 11 f t f 2 f 23 "0 0" 100 0 0 100 foo bar ));
+DATA(insert OID = 750 ( array_in PGUID 11 f t f 2 f 23 "0 0" 100 0 0 100 foo bar ));
DESCR("array");
-DATA(insert OID = 751 ( array_out PGUID 11 f t f 2 f 23 "0 0" 100 0 0 100 foo bar ));
+DATA(insert OID = 751 ( array_out PGUID 11 f t f 2 f 23 "0 0" 100 0 0 100 foo bar ));
DESCR("array");
DATA(insert OID = 752 ( filename_in PGUID 11 f t f 2 f 605 "0" 100 0 0 100 foo bar ));
DESCR("storage manager(internal)");
DATA(insert OID = 761 ( smgrout PGUID 11 f t f 1 f 23 "0" 100 0 0 100 foo bar ));
DESCR("storage manager(internal)");
-DATA(insert OID = 762 ( smgreq PGUID 11 f t f 2 f 16 "210 210" 100 0 0 100 foo bar ));
+DATA(insert OID = 762 ( smgreq PGUID 11 f t f 2 f 16 "210 210" 100 0 0 100 foo bar ));
DESCR("storage manager");
-DATA(insert OID = 763 ( smgrne PGUID 11 f t f 2 f 16 "210 210" 100 0 0 100 foo bar ));
+DATA(insert OID = 763 ( smgrne PGUID 11 f t f 2 f 16 "210 210" 100 0 0 100 foo bar ));
DESCR("storage manager");
DATA(insert OID = 764 ( lo_import PGUID 11 f t f 1 f 26 "25" 100 0 0 100 foo bar ));
DATA(insert OID = 782 ( gistbuild PGUID 11 f t f 9 f 23 "0" 100 0 0 100 foo bar ));
DESCR("gist(internal)");
-DATA(insert OID = 784 ( intervaleq PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
+DATA(insert OID = 784 ( intervaleq PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
DESCR("equals");
-DATA(insert OID = 785 ( intervalne PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
+DATA(insert OID = 785 ( intervalne PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
DESCR("not equal");
-DATA(insert OID = 786 ( intervallt PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
+DATA(insert OID = 786 ( intervallt PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 787 ( intervalgt PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
+DATA(insert OID = 787 ( intervalgt PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
DESCR("greater-than");
-DATA(insert OID = 788 ( intervalle PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
+DATA(insert OID = 788 ( intervalle PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 789 ( intervalge PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
+DATA(insert OID = 789 ( intervalge PGUID 11 f t f 2 f 16 "704 704" 100 0 0 100 foo bar ));
DESCR("greater-than-or-equals");
/* OIDS 800 - 899 */
DESCR("(internal)");
DATA(insert OID = 821 ( oidint2out PGUID 11 f t f 1 f 19 "0" 100 0 0 100 foo bar));
DESCR("(internal)");
-DATA(insert OID = 822 ( oidint2lt PGUID 11 f t f 2 f 16 "810 810" 100 0 0 100 foo bar));
+DATA(insert OID = 822 ( oidint2lt PGUID 11 f t f 2 f 16 "810 810" 100 0 0 100 foo bar));
DESCR("less-than");
-DATA(insert OID = 823 ( oidint2le PGUID 11 f t f 2 f 16 "810 810" 100 0 0 100 foo bar));
+DATA(insert OID = 823 ( oidint2le PGUID 11 f t f 2 f 16 "810 810" 100 0 0 100 foo bar));
DESCR("less-than-or-equals");
-DATA(insert OID = 824 ( oidint2eq PGUID 11 f t f 2 f 16 "810 810" 100 0 0 100 foo bar));
+DATA(insert OID = 824 ( oidint2eq PGUID 11 f t f 2 f 16 "810 810" 100 0 0 100 foo bar));
DESCR("equals");
#define OidInt2EqRegProcedure 824
-DATA(insert OID = 825 ( oidint2ge PGUID 11 f t f 2 f 16 "810 810" 100 0 0 100 foo bar));
+DATA(insert OID = 825 ( oidint2ge PGUID 11 f t f 2 f 16 "810 810" 100 0 0 100 foo bar));
DESCR("greater-than-or-equals");
-DATA(insert OID = 826 ( oidint2gt PGUID 11 f t f 2 f 16 "810 810" 100 0 0 100 foo bar));
+DATA(insert OID = 826 ( oidint2gt PGUID 11 f t f 2 f 16 "810 810" 100 0 0 100 foo bar));
DESCR("greater-than");
-DATA(insert OID = 827 ( oidint2ne PGUID 11 f t f 2 f 16 "810 810" 100 0 0 100 foo bar));
+DATA(insert OID = 827 ( oidint2ne PGUID 11 f t f 2 f 16 "810 810" 100 0 0 100 foo bar));
DESCR("not equal");
-DATA(insert OID = 828 ( oidint2cmp PGUID 11 f t f 2 f 21 "810 810" 100 0 0 100 foo bar));
+DATA(insert OID = 828 ( oidint2cmp PGUID 11 f t f 2 f 21 "810 810" 100 0 0 100 foo bar));
DESCR("less-equal-greater");
DATA(insert OID = 829 ( mkoidint2 PGUID 11 f t f 2 f 810 "26 21" 100 0 0 100 foo bar));
DESCR("");
DATA(insert OID = 848 ( flt4_mul_cash PGUID 11 f t f 2 f 790 "700 790" 100 0 0 100 foo bar ));
DESCR("multiply");
-DATA(insert OID = 862 ( int4_mul_cash PGUID 11 f t f 2 f 790 "23 790" 100 0 0 100 foo bar ));
+DATA(insert OID = 862 ( int4_mul_cash PGUID 11 f t f 2 f 790 "23 790" 100 0 0 100 foo bar ));
DESCR("multiply");
-DATA(insert OID = 863 ( int2_mul_cash PGUID 11 f t f 2 f 790 "21 790" 100 0 0 100 foo bar ));
+DATA(insert OID = 863 ( int2_mul_cash PGUID 11 f t f 2 f 790 "21 790" 100 0 0 100 foo bar ));
DESCR("multiply");
-DATA(insert OID = 864 ( cash_mul_int4 PGUID 11 f t f 2 f 790 "790 23" 100 0 0 100 foo bar ));
+DATA(insert OID = 864 ( cash_mul_int4 PGUID 11 f t f 2 f 790 "790 23" 100 0 0 100 foo bar ));
DESCR("multiply");
-DATA(insert OID = 865 ( cash_div_int4 PGUID 11 f t f 2 f 790 "790 23" 100 0 0 100 foo bar ));
+DATA(insert OID = 865 ( cash_div_int4 PGUID 11 f t f 2 f 790 "790 23" 100 0 0 100 foo bar ));
DESCR("divide");
-DATA(insert OID = 866 ( cash_mul_int2 PGUID 11 f t f 2 f 790 "790 21" 100 0 0 100 foo bar ));
+DATA(insert OID = 866 ( cash_mul_int2 PGUID 11 f t f 2 f 790 "790 21" 100 0 0 100 foo bar ));
DESCR("multiply");
-DATA(insert OID = 867 ( cash_div_int2 PGUID 11 f t f 2 f 790 "790 21" 100 0 0 100 foo bar ));
+DATA(insert OID = 867 ( cash_div_int2 PGUID 11 f t f 2 f 790 "790 21" 100 0 0 100 foo bar ));
DESCR("divide");
DATA(insert OID = 886 ( cash_in PGUID 11 f t f 1 f 790 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
DATA(insert OID = 921 ( oidint4out PGUID 11 f t f 1 f 19 "0" 100 0 0 100 foo bar));
DESCR("(internal)");
-DATA(insert OID = 922 ( oidint4lt PGUID 11 f t f 2 f 16 "910 910" 100 0 0 100 foo bar));
+DATA(insert OID = 922 ( oidint4lt PGUID 11 f t f 2 f 16 "910 910" 100 0 0 100 foo bar));
DESCR("less-than");
-DATA(insert OID = 923 ( oidint4le PGUID 11 f t f 2 f 16 "910 910" 100 0 0 100 foo bar));
+DATA(insert OID = 923 ( oidint4le PGUID 11 f t f 2 f 16 "910 910" 100 0 0 100 foo bar));
DESCR("less-than-or-equals");
-DATA(insert OID = 924 ( oidint4eq PGUID 11 f t f 2 f 16 "910 910" 100 0 0 100 foo bar));
+DATA(insert OID = 924 ( oidint4eq PGUID 11 f t f 2 f 16 "910 910" 100 0 0 100 foo bar));
DESCR("equals");
#define OidInt4EqRegProcedure 924
-DATA(insert OID = 925 ( oidint4ge PGUID 11 f t f 2 f 16 "910 910" 100 0 0 100 foo bar));
+DATA(insert OID = 925 ( oidint4ge PGUID 11 f t f 2 f 16 "910 910" 100 0 0 100 foo bar));
DESCR("greater-than-or-equals");
-DATA(insert OID = 926 ( oidint4gt PGUID 11 f t f 2 f 16 "910 910" 100 0 0 100 foo bar));
+DATA(insert OID = 926 ( oidint4gt PGUID 11 f t f 2 f 16 "910 910" 100 0 0 100 foo bar));
DESCR("greater-than");
-DATA(insert OID = 927 ( oidint4ne PGUID 11 f t f 2 f 16 "910 910" 100 0 0 100 foo bar));
+DATA(insert OID = 927 ( oidint4ne PGUID 11 f t f 2 f 16 "910 910" 100 0 0 100 foo bar));
DESCR("not equal");
-DATA(insert OID = 928 ( oidint4cmp PGUID 11 f t f 2 f 23 "910 910" 100 0 0 100 foo bar));
+DATA(insert OID = 928 ( oidint4cmp PGUID 11 f t f 2 f 23 "910 910" 100 0 0 100 foo bar));
DESCR("less-equal-greater");
DATA(insert OID = 929 ( mkoidint4 PGUID 11 f t f 2 f 910 "26 23" 100 0 0 100 foo bar));
DESCR("");
DESCR("(internal)");
DATA(insert OID = 941 ( oidnameout PGUID 11 f t f 1 f 19 "0" 100 0 0 100 foo bar));
DESCR("(internal)");
-DATA(insert OID = 942 ( oidnamelt PGUID 11 f t f 2 f 16 "911 911" 100 0 0 100 foo bar));
+DATA(insert OID = 942 ( oidnamelt PGUID 11 f t f 2 f 16 "911 911" 100 0 0 100 foo bar));
DESCR("less-than");
-DATA(insert OID = 943 ( oidnamele PGUID 11 f t f 2 f 16 "911 911" 100 0 0 100 foo bar));
+DATA(insert OID = 943 ( oidnamele PGUID 11 f t f 2 f 16 "911 911" 100 0 0 100 foo bar));
DESCR("less-than-or-equals");
-DATA(insert OID = 944 ( oidnameeq PGUID 11 f t f 2 f 16 "911 911" 100 0 0 100 foo bar));
+DATA(insert OID = 944 ( oidnameeq PGUID 11 f t f 2 f 16 "911 911" 100 0 0 100 foo bar));
DESCR("equals");
#define OidNameEqRegProcedure 944
-DATA(insert OID = 945 ( oidnamege PGUID 11 f t f 2 f 16 "911 911" 100 0 0 100 foo bar));
+DATA(insert OID = 945 ( oidnamege PGUID 11 f t f 2 f 16 "911 911" 100 0 0 100 foo bar));
DESCR("greater-than-or-equals");
-DATA(insert OID = 946 ( oidnamegt PGUID 11 f t f 2 f 16 "911 911" 100 0 0 100 foo bar));
+DATA(insert OID = 946 ( oidnamegt PGUID 11 f t f 2 f 16 "911 911" 100 0 0 100 foo bar));
DESCR("greater-than");
-DATA(insert OID = 947 ( oidnamene PGUID 11 f t f 2 f 16 "911 911" 100 0 0 100 foo bar));
+DATA(insert OID = 947 ( oidnamene PGUID 11 f t f 2 f 16 "911 911" 100 0 0 100 foo bar));
DESCR("not equal");
-DATA(insert OID = 948 ( oidnamecmp PGUID 11 f t f 2 f 23 "911 911" 100 0 0 100 foo bar));
+DATA(insert OID = 948 ( oidnamecmp PGUID 11 f t f 2 f 23 "911 911" 100 0 0 100 foo bar));
DESCR("less-equal-greater");
DATA(insert OID = 949 ( mkoidname PGUID 11 f t f 2 f 911 "26 19" 100 0 0 100 foo bar));
DESCR("");
DATA(insert OID = 963 ( close_lb PGUID 11 f t f 2 f 600 "628 603" 100 0 10 100 foo bar ));
DESCR("closest point to line on box");
-DATA(insert OID = 964 ( lo_unlink PGUID 11 f t f 1 f 23 "23" 100 0 0 100 foo bar ));
+DATA(insert OID = 964 ( lo_unlink PGUID 11 f t f 1 f 23 "23" 100 0 0 100 foo bar ));
DESCR("large object unlink(delete)");
-DATA(insert OID = 972 ( regproctooid PGUID 11 f t f 1 f 26 "24" 100 0 0 100 foo bar ));
+DATA(insert OID = 972 ( regproctooid PGUID 11 f t f 1 f 26 "24" 100 0 0 100 foo bar ));
DESCR("get oid for regproc");
DATA(insert OID = 973 ( path_inter PGUID 11 f t f 2 f 16 "602 602" 100 0 10 100 foo bar ));
DESCR("intersects");
DATA(insert OID = 981 ( box_diagonal PGUID 11 f t f 1 f 601 "603" 100 0 0 100 foo bar ));
DESCR("box diagonal");
-DATA(insert OID = 982 ( path_n_lt PGUID 11 f t f 2 f 16 "602 602" 100 0 0 100 foo bar ));
+DATA(insert OID = 982 ( path_n_lt PGUID 11 f t f 2 f 16 "602 602" 100 0 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 983 ( path_n_gt PGUID 11 f t f 2 f 16 "602 602" 100 0 0 100 foo bar ));
+DATA(insert OID = 983 ( path_n_gt PGUID 11 f t f 2 f 16 "602 602" 100 0 0 100 foo bar ));
DESCR("greater-than");
-DATA(insert OID = 984 ( path_n_eq PGUID 11 f t f 2 f 16 "602 602" 100 0 0 100 foo bar ));
+DATA(insert OID = 984 ( path_n_eq PGUID 11 f t f 2 f 16 "602 602" 100 0 0 100 foo bar ));
DESCR("equals");
-DATA(insert OID = 985 ( path_n_le PGUID 11 f t f 2 f 16 "602 602" 100 0 0 100 foo bar ));
+DATA(insert OID = 985 ( path_n_le PGUID 11 f t f 2 f 16 "602 602" 100 0 0 100 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 986 ( path_n_ge PGUID 11 f t f 2 f 16 "602 602" 100 0 0 100 foo bar ));
+DATA(insert OID = 986 ( path_n_ge PGUID 11 f t f 2 f 16 "602 602" 100 0 0 100 foo bar ));
DESCR("greater-than-or-equals");
DATA(insert OID = 987 ( path_length PGUID 11 f t f 1 f 701 "602" 100 0 1 0 foo bar ));
DESCR("sum of path segments");
-DATA(insert OID = 988 ( point_ne PGUID 11 f t f 2 f 16 "600 600" 100 0 0 100 foo bar ));
+DATA(insert OID = 988 ( point_ne PGUID 11 f t f 2 f 16 "600 600" 100 0 0 100 foo bar ));
DESCR("not equal");
-DATA(insert OID = 989 ( point_vert PGUID 11 f t f 2 f 16 "600 600" 100 0 0 100 foo bar ));
+DATA(insert OID = 989 ( point_vert PGUID 11 f t f 2 f 16 "600 600" 100 0 0 100 foo bar ));
DESCR("is vertical");
-DATA(insert OID = 990 ( point_horiz PGUID 11 f t f 2 f 16 "600 600" 100 0 0 100 foo bar ));
+DATA(insert OID = 990 ( point_horiz PGUID 11 f t f 2 f 16 "600 600" 100 0 0 100 foo bar ));
DESCR("is horizontal");
DATA(insert OID = 991 ( point_distance PGUID 11 f t f 2 f 701 "600 600" 100 0 0 100 foo bar ));
DESCR("distance between");
DESCR("slope between points");
DATA(insert OID = 993 ( lseg_construct PGUID 11 f t f 2 f 601 "600 600" 100 0 0 100 foo bar ));
DESCR("convert points to line segment");
-DATA(insert OID = 994 ( lseg_intersect PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
+DATA(insert OID = 994 ( lseg_intersect PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
DESCR("intersects");
-DATA(insert OID = 995 ( lseg_parallel PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
+DATA(insert OID = 995 ( lseg_parallel PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
DESCR("is parallel to");
-DATA(insert OID = 996 ( lseg_perp PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
+DATA(insert OID = 996 ( lseg_perp PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
DESCR("is perpendicular to");
-DATA(insert OID = 997 ( lseg_vertical PGUID 11 f t f 1 f 16 "601" 100 0 0 100 foo bar ));
+DATA(insert OID = 997 ( lseg_vertical PGUID 11 f t f 1 f 16 "601" 100 0 0 100 foo bar ));
DESCR("is vertical");
-DATA(insert OID = 998 ( lseg_horizontal PGUID 11 f t f 1 f 16 "601" 100 0 0 100 foo bar ));
+DATA(insert OID = 998 ( lseg_horizontal PGUID 11 f t f 1 f 16 "601" 100 0 0 100 foo bar ));
DESCR("is horizontal");
-DATA(insert OID = 999 ( lseg_eq PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
+DATA(insert OID = 999 ( lseg_eq PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
DESCR("equals");
/* OIDS 1000 - 1999 */
DATA(insert OID = 1030 ( nonnullvalue PGUID 11 f t f 1 f 16 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
#define NonNullValueRegProcedure 1030
-DATA(insert OID = 1031 ( aclitemin PGUID 11 f t f 1 f 1033 "0" 100 0 0 100 foo bar ));
+DATA(insert OID = 1031 ( aclitemin PGUID 11 f t f 1 f 1033 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
DATA(insert OID = 1032 ( aclitemout PGUID 11 f t f 1 f 23 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
-DATA(insert OID = 1035 ( aclinsert PGUID 11 f t f 2 f 1034 "1034 1033" 100 0 0 100 foo bar ));
+DATA(insert OID = 1035 ( aclinsert PGUID 11 f t f 2 f 1034 "1034 1033" 100 0 0 100 foo bar ));
DESCR("addition");
-DATA(insert OID = 1036 ( aclremove PGUID 11 f t f 2 f 1034 "1034 1033" 100 0 0 100 foo bar ));
+DATA(insert OID = 1036 ( aclremove PGUID 11 f t f 2 f 1034 "1034 1033" 100 0 0 100 foo bar ));
DESCR("subtract");
DATA(insert OID = 1037 ( aclcontains PGUID 11 f t f 2 f 16 "1034 1033" 100 0 0 100 foo bar ));
DESCR("matches regex., case-sensitive");
DESCR("");
#define SetEvalRegProcedure 1038
-DATA(insert OID = 1044 ( bpcharin PGUID 11 f t f 3 f 1042 "0" 100 0 0 100 foo bar ));
+DATA(insert OID = 1044 ( bpcharin PGUID 11 f t f 3 f 1042 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
DATA(insert OID = 1045 ( bpcharout PGUID 11 f t f 1 f 23 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
-DATA(insert OID = 1046 ( varcharin PGUID 11 f t f 3 f 1043 "0" 100 0 0 100 foo bar ));
+DATA(insert OID = 1046 ( varcharin PGUID 11 f t f 3 f 1043 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
DATA(insert OID = 1047 ( varcharout PGUID 11 f t f 1 f 23 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
DATA(insert OID = 1081 ( hashvarchar PGUID 11 f t f 1 f 23 "1043" 100 0 0 100 foo bar ));
DESCR("hash");
-DATA(insert OID = 1084 ( date_in PGUID 11 f t f 1 f 1082 "0" 100 0 0 100 foo bar ));
+DATA(insert OID = 1084 ( date_in PGUID 11 f t f 1 f 1082 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
DATA(insert OID = 1085 ( date_out PGUID 11 f t f 1 f 23 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
DESCR("not equal");
DATA(insert OID = 1107 ( time_cmp PGUID 11 f t f 2 f 23 "1083 1083" 100 0 0 100 foo bar ));
DESCR("less-equal-greater");
-DATA(insert OID = 1138 ( date_larger PGUID 11 f t f 2 f 1082 "1082 1082" 100 0 0 100 foo bar ));
+DATA(insert OID = 1138 ( date_larger PGUID 11 f t f 2 f 1082 "1082 1082" 100 0 0 100 foo bar ));
DESCR("");
-DATA(insert OID = 1139 ( date_smaller PGUID 11 f t f 2 f 1082 "1082 1082" 100 0 0 100 foo bar ));
+DATA(insert OID = 1139 ( date_smaller PGUID 11 f t f 2 f 1082 "1082 1082" 100 0 0 100 foo bar ));
DESCR("");
DATA(insert OID = 1140 ( date_mi PGUID 11 f t f 2 f 23 "1082 1082" 100 0 0 100 foo bar ));
DESCR("subtract");
DESCR("addition");
DATA(insert OID = 1142 ( date_mii PGUID 11 f t f 2 f 1082 "1082 23" 100 0 0 100 foo bar ));
DESCR("subtract");
-DATA(insert OID = 1143 ( time_in PGUID 11 f t f 1 f 1083 "0" 100 0 0 100 foo bar ));
+DATA(insert OID = 1143 ( time_in PGUID 11 f t f 1 f 1083 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
DATA(insert OID = 1144 ( time_out PGUID 11 f t f 1 f 23 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
DATA(insert OID = 1149 ( circle_div_pt PGUID 11 f t f 2 f 718 "718 600" 100 0 0 100 foo bar ));
DESCR("divide");
-DATA(insert OID = 1150 ( datetime_in PGUID 11 f t f 1 f 1184 "0" 100 0 0 100 foo bar ));
+DATA(insert OID = 1150 ( datetime_in PGUID 11 f t f 1 f 1184 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
-DATA(insert OID = 1151 ( datetime_out PGUID 11 f t f 1 f 23 "0" 100 0 0 100 foo bar ));
+DATA(insert OID = 1151 ( datetime_out PGUID 11 f t f 1 f 23 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
-DATA(insert OID = 1152 ( datetime_eq PGUID 11 f t f 2 f 16 "1184 1184" 100 0 0 100 foo bar ));
+DATA(insert OID = 1152 ( datetime_eq PGUID 11 f t f 2 f 16 "1184 1184" 100 0 0 100 foo bar ));
DESCR("equals");
-DATA(insert OID = 1153 ( datetime_ne PGUID 11 f t f 2 f 16 "1184 1184" 100 0 0 100 foo bar ));
+DATA(insert OID = 1153 ( datetime_ne PGUID 11 f t f 2 f 16 "1184 1184" 100 0 0 100 foo bar ));
DESCR("not equal");
-DATA(insert OID = 1154 ( datetime_lt PGUID 11 f t f 2 f 16 "1184 1184" 100 0 0 100 foo bar ));
+DATA(insert OID = 1154 ( datetime_lt PGUID 11 f t f 2 f 16 "1184 1184" 100 0 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 1155 ( datetime_le PGUID 11 f t f 2 f 16 "1184 1184" 100 0 0 100 foo bar ));
+DATA(insert OID = 1155 ( datetime_le PGUID 11 f t f 2 f 16 "1184 1184" 100 0 0 100 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 1156 ( datetime_ge PGUID 11 f t f 2 f 16 "1184 1184" 100 0 0 100 foo bar ));
+DATA(insert OID = 1156 ( datetime_ge PGUID 11 f t f 2 f 16 "1184 1184" 100 0 0 100 foo bar ));
DESCR("greater-than-or-equals");
-DATA(insert OID = 1157 ( datetime_gt PGUID 11 f t f 2 f 16 "1184 1184" 100 0 0 100 foo bar ));
+DATA(insert OID = 1157 ( datetime_gt PGUID 11 f t f 2 f 16 "1184 1184" 100 0 0 100 foo bar ));
DESCR("greater-than");
DATA(insert OID = 1158 ( datetime_finite PGUID 11 f t f 1 f 16 "1184" 100 0 0 100 foo bar ));
DESCR("");
DATA(insert OID = 1159 ( datetime_zone PGUID 11 f t f 2 f 25 "25 1184" 100 0 0 100 foo bar ));
DESCR("");
-DATA(insert OID = 1160 ( timespan_in PGUID 11 f t f 1 f 1186 "0" 100 0 0 100 foo bar ));
+DATA(insert OID = 1160 ( timespan_in PGUID 11 f t f 1 f 1186 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
DATA(insert OID = 1161 ( timespan_out PGUID 11 f t f 1 f 23 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
DESCR("matches regex., case-insensitive");
DATA(insert OID = 1237 ( char16icregexne PGUID 11 f t f 2 f 16 "20 25" 100 0 0 100 foo bar ));
DESCR("does not match regex., case-insensitive");
-DATA(insert OID = 1238 ( texticregexeq PGUID 11 f t f 2 f 16 "25 25" 100 0 1 0 foo bar ));
+DATA(insert OID = 1238 ( texticregexeq PGUID 11 f t f 2 f 16 "25 25" 100 0 1 0 foo bar ));
DESCR("matches regex., case-insensitive");
-DATA(insert OID = 1239 ( texticregexne PGUID 11 f t f 2 f 16 "25 25" 100 0 1 0 foo bar ));
+DATA(insert OID = 1239 ( texticregexne PGUID 11 f t f 2 f 16 "25 25" 100 0 1 0 foo bar ));
DESCR("does not match regex., case-insensitive");
DATA(insert OID = 1240 ( nameicregexeq PGUID 11 f t f 2 f 16 "19 25" 100 0 0 100 foo bar ));
DESCR("matches regex., case-insensitive");
DATA(insert OID = 1241 ( nameicregexne PGUID 11 f t f 2 f 16 "19 25" 100 0 0 100 foo bar ));
DESCR("does not match regex., case-insensitive");
-DATA(insert OID = 1251 ( bpcharlen PGUID 11 f t f 1 f 23 "1042" 100 0 0 100 foo bar ));
+DATA(insert OID = 1251 ( bpcharlen PGUID 11 f t f 1 f 23 "1042" 100 0 0 100 foo bar ));
DESCR("octet length");
-DATA(insert OID = 1253 ( varcharlen PGUID 11 f t f 1 f 23 "1043" 100 0 0 100 foo bar ));
+DATA(insert OID = 1253 ( varcharlen PGUID 11 f t f 1 f 23 "1043" 100 0 0 100 foo bar ));
DESCR("octet length");
-DATA(insert OID = 1263 ( text_timespan PGUID 11 f t f 1 f 1186 "25" 100 0 0 100 foo bar ));
+DATA(insert OID = 1263 ( text_timespan PGUID 11 f t f 1 f 1186 "25" 100 0 0 100 foo bar ));
DESCR("convert");
DATA(insert OID = 1271 ( timespan_finite PGUID 11 f t f 1 f 16 "1186" 100 0 0 100 foo bar ));
DESCR("boolean test");
DATA(insert OID = 1295 ( char8icregexne PGUID 11 f t f 2 f 16 "411 25" 100 0 0 100 foo bar ));
DESCR("does not match regex., case-insensitive");
-DATA(insert OID = 1297 ( timestamp_in PGUID 11 f t f 1 f 1296 "0" 100 0 0 100 foo bar ));
+DATA(insert OID = 1297 ( timestamp_in PGUID 11 f t f 1 f 1296 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
-DATA(insert OID = 1298 ( timestamp_out PGUID 11 f t f 1 f 23 "0" 100 0 0 100 foo bar ));
+DATA(insert OID = 1298 ( timestamp_out PGUID 11 f t f 1 f 23 "0" 100 0 0 100 foo bar ));
DESCR("(internal)");
-DATA(insert OID = 1299 ( now PGUID 11 f t f 0 f 1296 "0" 100 0 0 100 foo bar ));
+DATA(insert OID = 1299 ( now PGUID 11 f t f 0 f 1296 "0" 100 0 0 100 foo bar ));
DESCR("current transaction time");
/* OIDS 1300 - 1399 */
-DATA(insert OID = 1306 ( timestampeq PGUID 11 f t f 2 f 16 "1296 1296" 100 0 0 100 foo bar ));
+DATA(insert OID = 1306 ( timestampeq PGUID 11 f t f 2 f 16 "1296 1296" 100 0 0 100 foo bar ));
DESCR("equals");
-DATA(insert OID = 1307 ( timestampne PGUID 11 f t f 2 f 16 "1296 1296" 100 0 0 100 foo bar ));
+DATA(insert OID = 1307 ( timestampne PGUID 11 f t f 2 f 16 "1296 1296" 100 0 0 100 foo bar ));
DESCR("not equal");
-DATA(insert OID = 1308 ( timestamplt PGUID 11 f t f 2 f 16 "1296 1296" 100 0 0 100 foo bar ));
+DATA(insert OID = 1308 ( timestamplt PGUID 11 f t f 2 f 16 "1296 1296" 100 0 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 1309 ( timestampgt PGUID 11 f t f 2 f 16 "1296 1296" 100 0 0 100 foo bar ));
+DATA(insert OID = 1309 ( timestampgt PGUID 11 f t f 2 f 16 "1296 1296" 100 0 0 100 foo bar ));
DESCR("greater-than");
-DATA(insert OID = 1310 ( timestample PGUID 11 f t f 2 f 16 "1296 1296" 100 0 0 100 foo bar ));
+DATA(insert OID = 1310 ( timestample PGUID 11 f t f 2 f 16 "1296 1296" 100 0 0 100 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 1311 ( timestampge PGUID 11 f t f 2 f 16 "1296 1296" 100 0 0 100 foo bar ));
+DATA(insert OID = 1311 ( timestampge PGUID 11 f t f 2 f 16 "1296 1296" 100 0 0 100 foo bar ));
DESCR("greater-than-or-equals");
-DATA(insert OID = 1314 ( datetime_cmp PGUID 11 f t f 2 f 23 "1184 1184" 100 0 0 100 foo bar ));
+DATA(insert OID = 1314 ( datetime_cmp PGUID 11 f t f 2 f 23 "1184 1184" 100 0 0 100 foo bar ));
DESCR("less-equal-greater");
-DATA(insert OID = 1315 ( timespan_cmp PGUID 11 f t f 2 f 23 "1186 1186" 100 0 0 100 foo bar ));
+DATA(insert OID = 1315 ( timespan_cmp PGUID 11 f t f 2 f 23 "1186 1186" 100 0 0 100 foo bar ));
DESCR("less-equal-greater");
-DATA(insert OID = 1316 ( datetime_time PGUID 11 f t f 1 f 1083 "1184" 100 0 0 100 foo bar ));
+DATA(insert OID = 1316 ( datetime_time PGUID 11 f t f 1 f 1083 "1184" 100 0 0 100 foo bar ));
DESCR("convert");
DATA(insert OID = 1318 ( datetime_timestamp PGUID 11 f t f 1 f 1296 "1184" 100 0 0 100 foo bar ));
DESCR("convert");
-DATA(insert OID = 1326 ( timespan_div PGUID 11 f t f 2 f 1186 "1186 701" 100 0 0 100 foo bar ));
+DATA(insert OID = 1326 ( timespan_div PGUID 11 f t f 2 f 1186 "1186 701" 100 0 0 100 foo bar ));
DESCR("divide");
-DATA(insert OID = 1339 ( date_zone PGUID 14 f t f 2 f 25 "25 1184" 100 0 0 100 "select datetime_zone($1, $2)" - ));
+DATA(insert OID = 1339 ( date_zone PGUID 14 f t f 2 f 25 "25 1184" 100 0 0 100 "select datetime_zone($1, $2)" - ));
DESCR("");
-DATA(insert OID = 1340 ( text PGUID 14 f t f 1 f 25 "1184" 100 0 0 100 "select datetime_text($1)" - ));
+DATA(insert OID = 1340 ( text PGUID 14 f t f 1 f 25 "1184" 100 0 0 100 "select datetime_text($1)" - ));
DESCR("convert");
-DATA(insert OID = 1341 ( text PGUID 14 f t f 1 f 25 "1186" 100 0 0 100 "select timespan_text($1)" - ));
+DATA(insert OID = 1341 ( text PGUID 14 f t f 1 f 25 "1186" 100 0 0 100 "select timespan_text($1)" - ));
DESCR("convert");
-DATA(insert OID = 1342 ( text PGUID 14 f t f 1 f 25 "23" 100 0 0 100 "select int4_text($1)" - ));
+DATA(insert OID = 1342 ( text PGUID 14 f t f 1 f 25 "23" 100 0 0 100 "select int4_text($1)" - ));
DESCR("convert");
-DATA(insert OID = 1343 ( text PGUID 14 f t f 1 f 25 "21" 100 0 0 100 "select int2_text($1)" - ));
+DATA(insert OID = 1343 ( text PGUID 14 f t f 1 f 25 "21" 100 0 0 100 "select int2_text($1)" - ));
DESCR("convert");
-DATA(insert OID = 1344 ( text PGUID 14 f t f 1 f 25 "26" 100 0 0 100 "select oid_text($1)" - ));
+DATA(insert OID = 1344 ( text PGUID 14 f t f 1 f 25 "26" 100 0 0 100 "select oid_text($1)" - ));
DESCR("convert");
-DATA(insert OID = 1345 ( oid PGUID 14 f t f 1 f 26 "25" 100 0 0 100 "select text_oid($1)" - ));
+DATA(insert OID = 1345 ( oid PGUID 14 f t f 1 f 26 "25" 100 0 0 100 "select text_oid($1)" - ));
DESCR("convert");
-DATA(insert OID = 1346 ( int2 PGUID 14 f t f 1 f 21 "25" 100 0 0 100 "select text_int2($1)" - ));
+DATA(insert OID = 1346 ( int2 PGUID 14 f t f 1 f 21 "25" 100 0 0 100 "select text_int2($1)" - ));
DESCR("convert");
-DATA(insert OID = 1347 ( int4 PGUID 14 f t f 1 f 23 "25" 100 0 0 100 "select text_int4($1)" - ));
+DATA(insert OID = 1347 ( int4 PGUID 14 f t f 1 f 23 "25" 100 0 0 100 "select text_int4($1)" - ));
DESCR("convert");
-DATA(insert OID = 1348 ( obj_description PGUID 14 f t f 1 f 25 "26" 100 0 0 100 "select description from pg_description where objoid = $1" - ));
+DATA(insert OID = 1348 ( obj_description PGUID 14 f t f 1 f 25 "26" 100 0 0 100 "select description from pg_description where objoid = $1" - ));
DESCR("get description for object id");
-DATA(insert OID = 1349 ( oid8types PGUID 11 f t f 1 f 25 "30" 100 0 0 100 foo bar ));
+DATA(insert OID = 1349 ( oid8types PGUID 11 f t f 1 f 25 "30" 100 0 0 100 foo bar ));
DESCR("print type names of oid8 field");
-DATA(insert OID = 1350 ( datetime PGUID 14 f t f 1 f 1184 "1184" 100 0 0 100 "select $1" - ));
+DATA(insert OID = 1350 ( datetime PGUID 14 f t f 1 f 1184 "1184" 100 0 0 100 "select $1" - ));
DESCR("convert");
-DATA(insert OID = 1351 ( datetime PGUID 14 f t f 1 f 1184 "25" 100 0 0 100 "select text_datetime($1)" - ));
+DATA(insert OID = 1351 ( datetime PGUID 14 f t f 1 f 1184 "25" 100 0 0 100 "select text_datetime($1)" - ));
DESCR("convert");
-DATA(insert OID = 1352 ( datetime PGUID 14 f t f 1 f 1184 "702" 100 0 0 100 "select abstime_datetime($1)" - ));
+DATA(insert OID = 1352 ( datetime PGUID 14 f t f 1 f 1184 "702" 100 0 0 100 "select abstime_datetime($1)" - ));
DESCR("convert");
-DATA(insert OID = 1353 ( datetime PGUID 14 f t f 1 f 1184 "1082" 100 0 0 100 "select date_datetime($1)" - ));
+DATA(insert OID = 1353 ( datetime PGUID 14 f t f 1 f 1184 "1082" 100 0 0 100 "select date_datetime($1)" - ));
DESCR("convert");
-DATA(insert OID = 1354 ( datetime PGUID 14 f t f 1 f 1184 "1296" 100 0 0 100 "select timestamp_datetime($1)" - ));
+DATA(insert OID = 1354 ( datetime PGUID 14 f t f 1 f 1184 "1296" 100 0 0 100 "select timestamp_datetime($1)" - ));
DESCR("convert");
-DATA(insert OID = 1355 ( datetime PGUID 14 f t f 2 f 1184 "1082 1083" 100 0 0 100 "select datetime_datetime($1, $2)" - ));
+DATA(insert OID = 1355 ( datetime PGUID 14 f t f 2 f 1184 "1082 1083" 100 0 0 100 "select datetime_datetime($1, $2)" - ));
DESCR("convert");
-DATA(insert OID = 1356 ( timespan PGUID 14 f t f 1 f 1186 "1186" 100 0 0 100 "select $1" - ));
+DATA(insert OID = 1356 ( timespan PGUID 14 f t f 1 f 1186 "1186" 100 0 0 100 "select $1" - ));
DESCR("convert");
-DATA(insert OID = 1357 ( timespan PGUID 14 f t f 1 f 1186 "703" 100 0 0 100 "select reltime_timespan($1)" - ));
+DATA(insert OID = 1357 ( timespan PGUID 14 f t f 1 f 1186 "703" 100 0 0 100 "select reltime_timespan($1)" - ));
DESCR("convert");
-DATA(insert OID = 1358 ( timespan PGUID 14 f t f 1 f 1186 "1083" 100 0 0 100 "select time_timespan($1)" - ));
+DATA(insert OID = 1358 ( timespan PGUID 14 f t f 1 f 1186 "1083" 100 0 0 100 "select time_timespan($1)" - ));
DESCR("convert");
-DATA(insert OID = 1359 ( date PGUID 14 f t f 1 f 1082 "1082" 100 0 0 100 "select $1" - ));
+DATA(insert OID = 1359 ( date PGUID 14 f t f 1 f 1082 "1082" 100 0 0 100 "select $1" - ));
DESCR("convert");
-DATA(insert OID = 1360 ( date PGUID 14 f t f 1 f 1082 "1184" 100 0 0 100 "select datetime_date($1)" - ));
+DATA(insert OID = 1360 ( date PGUID 14 f t f 1 f 1082 "1184" 100 0 0 100 "select datetime_date($1)" - ));
DESCR("convert");
-DATA(insert OID = 1361 ( date PGUID 14 f t f 1 f 1082 "702" 100 0 0 100 "select abstime_date($1)" - ));
+DATA(insert OID = 1361 ( date PGUID 14 f t f 1 f 1082 "702" 100 0 0 100 "select abstime_date($1)" - ));
DESCR("convert");
-DATA(insert OID = 1362 ( time PGUID 14 f t f 1 f 1083 "1083" 100 0 0 100 "select $1" - ));
+DATA(insert OID = 1362 ( time PGUID 14 f t f 1 f 1083 "1083" 100 0 0 100 "select $1" - ));
DESCR("convert");
-DATA(insert OID = 1363 ( time PGUID 14 f t f 1 f 1083 "1184" 100 0 0 100 "select datetime_time($1)" - ));
+DATA(insert OID = 1363 ( time PGUID 14 f t f 1 f 1083 "1184" 100 0 0 100 "select datetime_time($1)" - ));
DESCR("convert");
-DATA(insert OID = 1364 ( time PGUID 14 f t f 1 f 1083 "702" 100 0 0 100 "select abstime_time($1)" - ));
+DATA(insert OID = 1364 ( time PGUID 14 f t f 1 f 1083 "702" 100 0 0 100 "select abstime_time($1)" - ));
DESCR("convert");
-DATA(insert OID = 1365 ( abstime PGUID 14 f t f 1 f 702 "702" 100 0 0 100 "select $1" - ));
+DATA(insert OID = 1365 ( abstime PGUID 14 f t f 1 f 702 "702" 100 0 0 100 "select $1" - ));
DESCR("convert");
-DATA(insert OID = 1366 ( abstime PGUID 14 f t f 1 f 702 "1184" 100 0 0 100 "select datetime_abstime($1)" - ));
+DATA(insert OID = 1366 ( abstime PGUID 14 f t f 1 f 702 "1184" 100 0 0 100 "select datetime_abstime($1)" - ));
DESCR("convert");
-DATA(insert OID = 1367 ( reltime PGUID 14 f t f 1 f 703 "703" 100 0 0 100 "select $1" - ));
+DATA(insert OID = 1367 ( reltime PGUID 14 f t f 1 f 703 "703" 100 0 0 100 "select $1" - ));
DESCR("convert");
-DATA(insert OID = 1368 ( reltime PGUID 14 f t f 1 f 703 "1186" 100 0 0 100 "select timespan_reltime($1)" - ));
+DATA(insert OID = 1368 ( reltime PGUID 14 f t f 1 f 703 "1186" 100 0 0 100 "select timespan_reltime($1)" - ));
DESCR("convert");
-DATA(insert OID = 1369 ( timestamp PGUID 14 f t f 1 f 1296 "1296" 100 0 0 100 "select $1" - ));
+DATA(insert OID = 1369 ( timestamp PGUID 14 f t f 1 f 1296 "1296" 100 0 0 100 "select $1" - ));
DESCR("convert");
-DATA(insert OID = 1370 ( timestamp PGUID 14 f t f 1 f 1296 "1184" 100 0 0 100 "select datetime_stamp($1)" - ));
+DATA(insert OID = 1370 ( timestamp PGUID 14 f t f 1 f 1296 "1184" 100 0 0 100 "select datetime_stamp($1)" - ));
DESCR("convert");
-DATA(insert OID = 1371 ( length PGUID 14 f t f 1 f 23 "25" 100 0 0 100 "select textlen($1)" - ));
+DATA(insert OID = 1371 ( length PGUID 14 f t f 1 f 23 "25" 100 0 0 100 "select textlen($1)" - ));
DESCR("octet length");
-DATA(insert OID = 1372 ( length PGUID 14 f t f 1 f 23 "1042" 100 0 0 100 "select bpcharlen($1)" - ));
+DATA(insert OID = 1372 ( length PGUID 14 f t f 1 f 23 "1042" 100 0 0 100 "select bpcharlen($1)" - ));
DESCR("octet length");
-DATA(insert OID = 1373 ( length PGUID 14 f t f 1 f 23 "1043" 100 0 0 100 "select varcharlen($1)" - ));
+DATA(insert OID = 1373 ( length PGUID 14 f t f 1 f 23 "1043" 100 0 0 100 "select varcharlen($1)" - ));
DESCR("octet length");
DATA(insert OID = 1380 ( date_part PGUID 14 f t f 2 f 701 "25 1184" 100 0 0 100 "select datetime_part($1, $2)" - ));
DESCR("truncate datetime to field");
DATA(insert OID = 1387 ( date_trunc PGUID 14 f t f 2 f 1186 "25 1186" 100 0 0 100 "select timespan_trunc($1, $2)" - ));
DESCR("truncate timespan to field");
-DATA(insert OID = 1388 ( age PGUID 14 f t f 2 f 1186 "1184 1184" 100 0 0 100 "select datetime_age($1, $2)" - ));
+DATA(insert OID = 1388 ( age PGUID 14 f t f 2 f 1186 "1184 1184" 100 0 0 100 "select datetime_age($1, $2)" - ));
DESCR("difference between datetimes but leave years and months unresolved");
-DATA(insert OID = 1389 ( age PGUID 14 f t f 1 f 1186 "1184" 100 0 0 100 "select datetime_age(\'today\', $1)" - ));
+DATA(insert OID = 1389 ( age PGUID 14 f t f 1 f 1186 "1184" 100 0 0 100 "select datetime_age(\'today\', $1)" - ));
DESCR("difference between datetime and today but leave years and months unresolved");
-DATA(insert OID = 1390 ( isfinite PGUID 14 f t f 1 f 16 "1184" 100 0 0 100 "select datetime_finite($1)" - ));
+DATA(insert OID = 1390 ( isfinite PGUID 14 f t f 1 f 16 "1184" 100 0 0 100 "select datetime_finite($1)" - ));
DESCR("boolean test");
-DATA(insert OID = 1391 ( isfinite PGUID 14 f t f 1 f 16 "1186" 100 0 0 100 "select timespan_finite($1)" - ));
+DATA(insert OID = 1391 ( isfinite PGUID 14 f t f 1 f 16 "1186" 100 0 0 100 "select timespan_finite($1)" - ));
DESCR("boolean test");
-DATA(insert OID = 1392 ( isfinite PGUID 14 f t f 1 f 16 "702" 100 0 0 100 "select abstime_finite($1)" - ));
+DATA(insert OID = 1392 ( isfinite PGUID 14 f t f 1 f 16 "702" 100 0 0 100 "select abstime_finite($1)" - ));
DESCR("boolean test");
-DATA(insert OID = 1393 ( timespan PGUID 14 f t f 1 f 1186 "25" 100 0 0 100 "select text_timespan($1)" - ));
+DATA(insert OID = 1393 ( timespan PGUID 14 f t f 1 f 1186 "25" 100 0 0 100 "select text_timespan($1)" - ));
DESCR("convert");
/* reserve OIDs 1370-1399 for additional date/time conversion routines! tgl 97/04/01 */
DESCR("(internal)");
DATA(insert OID = 1451 ( circle_out PGUID 11 f t f 1 f 23 "0" 100 0 1 0 foo bar ));
DESCR("(internal)");
-DATA(insert OID = 1452 ( circle_same PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1452 ( circle_same PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
DESCR("same as");
-DATA(insert OID = 1453 ( circle_contain PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1453 ( circle_contain PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
DESCR("contains");
-DATA(insert OID = 1454 ( circle_left PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1454 ( circle_left PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
DESCR("is left of");
-DATA(insert OID = 1455 ( circle_overleft PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1455 ( circle_overleft PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
DESCR("overlaps, but does not extend to right of");
-DATA(insert OID = 1456 ( circle_overright PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1456 ( circle_overright PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
DESCR("");
-DATA(insert OID = 1457 ( circle_right PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1457 ( circle_right PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
DESCR("is left of");
-DATA(insert OID = 1458 ( circle_contained PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1458 ( circle_contained PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
DESCR("");
-DATA(insert OID = 1459 ( circle_overlap PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1459 ( circle_overlap PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
DESCR("overlaps");
-DATA(insert OID = 1460 ( circle_below PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1460 ( circle_below PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
DESCR("is below");
-DATA(insert OID = 1461 ( circle_above PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1461 ( circle_above PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
DESCR("is above");
-DATA(insert OID = 1462 ( circle_eq PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1462 ( circle_eq PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
DESCR("equals");
-DATA(insert OID = 1463 ( circle_ne PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1463 ( circle_ne PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
DESCR("not equal");
-DATA(insert OID = 1464 ( circle_lt PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1464 ( circle_lt PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
DESCR("less-than");
-DATA(insert OID = 1465 ( circle_gt PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1465 ( circle_gt PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
DESCR("greater-than");
-DATA(insert OID = 1466 ( circle_le PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1466 ( circle_le PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 1467 ( circle_ge PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1467 ( circle_ge PGUID 11 f t f 2 f 16 "718 718" 100 0 1 0 foo bar ));
DESCR("greater-than-or-equals");
-DATA(insert OID = 1468 ( circle_area PGUID 11 f t f 1 f 701 "718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1468 ( circle_area PGUID 11 f t f 1 f 701 "718" 100 0 1 0 foo bar ));
DESCR("area");
-DATA(insert OID = 1469 ( circle_diameter PGUID 11 f t f 1 f 701 "718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1469 ( circle_diameter PGUID 11 f t f 1 f 701 "718" 100 0 1 0 foo bar ));
DESCR("diameter");
-DATA(insert OID = 1470 ( circle_radius PGUID 11 f t f 1 f 701 "718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1470 ( circle_radius PGUID 11 f t f 1 f 701 "718" 100 0 1 0 foo bar ));
DESCR("radius");
-DATA(insert OID = 1471 ( circle_distance PGUID 11 f t f 2 f 701 "718 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1471 ( circle_distance PGUID 11 f t f 2 f 701 "718 718" 100 0 1 0 foo bar ));
DESCR("distance between");
-DATA(insert OID = 1472 ( circle_center PGUID 11 f t f 1 f 600 "718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1472 ( circle_center PGUID 11 f t f 1 f 600 "718" 100 0 1 0 foo bar ));
DESCR("center of");
-DATA(insert OID = 1473 ( circle PGUID 11 f t f 2 f 718 "600 701" 100 0 1 0 foo bar ));
+DATA(insert OID = 1473 ( circle PGUID 11 f t f 2 f 718 "600 701" 100 0 1 0 foo bar ));
DESCR("convert");
-DATA(insert OID = 1474 ( poly_circle PGUID 11 f t f 1 f 718 "604" 100 0 1 0 foo bar ));
+DATA(insert OID = 1474 ( poly_circle PGUID 11 f t f 1 f 718 "604" 100 0 1 0 foo bar ));
DESCR("convert");
DATA(insert OID = 1475 ( circle_poly PGUID 11 f t f 2 f 604 "23 718" 100 0 1 0 foo bar ));
DESCR("convert");
-DATA(insert OID = 1476 ( dist_pc PGUID 11 f t f 2 f 604 "600 718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1476 ( dist_pc PGUID 11 f t f 2 f 604 "600 718" 100 0 1 0 foo bar ));
DESCR("distance between");
-DATA(insert OID = 1477 ( circle_contain_pt PGUID 11 f t f 2 f 16 "718 600" 100 0 0 100 foo bar ));
+DATA(insert OID = 1477 ( circle_contain_pt PGUID 11 f t f 2 f 16 "718 600" 100 0 0 100 foo bar ));
DESCR("");
-DATA(insert OID = 1478 ( pt_contained_circle PGUID 11 f t f 2 f 16 "600 718" 100 0 0 100 foo bar ));
+DATA(insert OID = 1478 ( pt_contained_circle PGUID 11 f t f 2 f 16 "600 718" 100 0 0 100 foo bar ));
DESCR("");
-DATA(insert OID = 1479 ( box_circle PGUID 11 f t f 1 f 718 "603" 100 0 1 0 foo bar ));
+DATA(insert OID = 1479 ( box_circle PGUID 11 f t f 1 f 718 "603" 100 0 1 0 foo bar ));
DESCR("convert");
-DATA(insert OID = 1480 ( circle_box PGUID 11 f t f 1 f 603 "718" 100 0 1 0 foo bar ));
+DATA(insert OID = 1480 ( circle_box PGUID 11 f t f 1 f 603 "718" 100 0 1 0 foo bar ));
DESCR("convert");
DATA(insert OID = 1481 ( text_substr PGUID 11 f t f 3 f 25 "25 23 23" 100 0 0 100 foo bar ));
DESCR("return portion of string");
-DATA(insert OID = 1482 ( lseg_ne PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
+DATA(insert OID = 1482 ( lseg_ne PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
DESCR("not equal");
-DATA(insert OID = 1483 ( lseg_lt PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
+DATA(insert OID = 1483 ( lseg_lt PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
DESCR("less-than");
-DATA(insert OID = 1484 ( lseg_le PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
+DATA(insert OID = 1484 ( lseg_le PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
DESCR("less-than-or-equals");
-DATA(insert OID = 1485 ( lseg_gt PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
+DATA(insert OID = 1485 ( lseg_gt PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
DESCR("greater-than");
-DATA(insert OID = 1486 ( lseg_ge PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
+DATA(insert OID = 1486 ( lseg_ge PGUID 11 f t f 2 f 16 "601 601" 100 0 0 100 foo bar ));
DESCR("greater-than-or-equals");
-DATA(insert OID = 1487 ( lseg_length PGUID 11 f t f 1 f 701 "601" 100 0 1 0 foo bar ));
+DATA(insert OID = 1487 ( lseg_length PGUID 11 f t f 1 f 701 "601" 100 0 1 0 foo bar ));
DESCR("distance between endpoints");
DATA(insert OID = 1488 ( close_ls PGUID 11 f t f 2 f 600 "628 601" 100 0 10 100 foo bar ));
DESCR("closest point to line on line segment");
/*
* prototypes for functions pg_proc.c
*/
-extern Oid ProcedureCreate(char *procedureName,
+extern Oid
+ProcedureCreate(char *procedureName,
bool returnsSet,
char *returnTypeName,
char *languageName,
* pg_shadow.h--
* definition of the system "shadow" relation (pg_shadow)
* along with the relation's initial contents.
- * pg_user is now a public accessible view on pg_shadow.
+ * pg_user is now a public accessible view on pg_shadow.
*
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_shadow.h,v 1.1 1998/02/25 13:09:26 scrappy Exp $
+ * $Id: pg_shadow.h,v 1.2 1998/02/26 04:41:00 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
* information from the DATA() statements.
*
- * WHENEVER the definition for pg_shadow changes, the
- * view creation of pg_user must be changed in initdb.sh!
+ * WHENEVER the definition for pg_shadow changes, the
+ * view creation of pg_user must be changed in initdb.sh!
*
*-------------------------------------------------------------------------
*/
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_type.h,v 1.34 1998/02/25 13:09:27 scrappy Exp $
+ * $Id: pg_type.h,v 1.35 1998/02/26 04:41:01 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
*/
extern Oid TypeGet(char *typeName, bool *defined);
extern Oid TypeShellMake(char *typeName);
-extern Oid TypeCreate(char *typeName,
+extern Oid
+TypeCreate(char *typeName,
Oid relationOid,
int16 internalSize,
int16 externalSize,
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: command.h,v 1.8 1998/01/24 22:48:44 momjian Exp $
+ * $Id: command.h,v 1.9 1998/02/26 04:41:04 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* BadArg if forward invalid.
* "WARN" if portal not found.
*/
-extern void PerformPortalFetch(char *name, bool forward, int count,
+extern void
+PerformPortalFetch(char *name, bool forward, int count,
char *tag, CommandDest dest);
/*
* PerformAddAttribute --
* Performs the POSTQUEL function ADD.
*/
-extern void PerformAddAttribute(char *relationName, char *userName,
+extern void
+PerformAddAttribute(char *relationName, char *userName,
bool inh, ColumnDef *colDef);
#endif /* COMMAND_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: defrem.h,v 1.11 1998/01/24 22:48:45 momjian Exp $
+ * $Id: defrem.h,v 1.12 1998/02/26 04:41:06 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* prototypes in defind.c
*/
-extern void DefineIndex(char *heapRelationName,
+extern void
+DefineIndex(char *heapRelationName,
char *indexRelationName,
char *accessMethodName,
List *attributeList,
bool unique,
Expr *predicate,
List *rangetable);
-extern void ExtendIndex(char *indexRelationName,
+extern void
+ExtendIndex(char *indexRelationName,
Expr *predicate,
List *rangetable);
extern void RemoveIndex(char *name);
* prototypes in remove.c
*/
extern void RemoveFunction(char *functionName, int nargs, List *argNameList);
-extern void RemoveOperator(char *operatorName,
+extern void
+RemoveOperator(char *operatorName,
char *typeName1, char *typeName2);
extern void RemoveType(char *typeName);
extern void RemoveAggregate(char *aggName, char *aggType);
#include
-extern void CreateProceduralLanguage(CreatePLangStmt * stmt);
-extern void DropProceduralLanguage(DropPLangStmt * stmt);
+extern void CreateProceduralLanguage(CreatePLangStmt *stmt);
+extern void DropProceduralLanguage(DropPLangStmt *stmt);
#endif /* PROCLANG_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: rename.h,v 1.3 1998/01/24 22:48:46 momjian Exp $
+ * $Id: rename.h,v 1.4 1998/02/26 04:41:08 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef RENAME_H
#define RENAME_H
-extern void renameatt(char *relname,
+extern void
+renameatt(char *relname,
char *oldattname,
char *newattname,
char *userName, int recurse);
-extern void renamerel(char *oldrelname,
+extern void
+renamerel(char *oldrelname,
char *newrelname);
#endif /* RENAME_H */
HeapTuple tg_trigtuple;
HeapTuple tg_newtuple;
Trigger *tg_trigger;
-} TriggerData;
+} TriggerData;
extern TriggerData *CurrentTriggerData;
(!TRIGGER_FIRED_BEFORE (event))
-extern void CreateTrigger(CreateTrigStmt * stmt);
-extern void DropTrigger(DropTrigStmt * stmt);
+extern void CreateTrigger(CreateTrigStmt *stmt);
+extern void DropTrigger(DropTrigStmt *stmt);
extern void RelationRemoveTriggers(Relation rel);
extern HeapTuple ExecBRInsertTriggers(Relation rel, HeapTuple tuple);
extern void DefineUser(CreateUserStmt *stmt);
extern void AlterUser(AlterUserStmt *stmt);
-extern void RemoveUser(char* user);
+extern void RemoveUser(char *user);
#endif /* USER_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: vacuum.h,v 1.12 1998/01/15 19:46:24 pgsql Exp $
+ * $Id: vacuum.h,v 1.13 1998/02/26 04:41:12 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/pg_list.h"
#include "storage/block.h"
#include "storage/off.h"
-
+
typedef struct VAttListData
{
* Headers for handling of 'SET var TO', 'SHOW var' and 'RESET var'
* statements
*
- * $Id: variable.h,v 1.1 1998/01/05 18:53:08 momjian Exp $
+ * $Id: variable.h,v 1.2 1998/02/26 04:41:13 momjian Exp $
*
*/
#ifndef VARIABLE_H
extern bool reset_geqo(void);
extern bool parse_geqo(const char *);
-#endif /* VARIABLE_H */
+#endif /* VARIABLE_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: execdesc.h,v 1.7 1998/01/24 22:48:50 momjian Exp $
+ * $Id: execdesc.h,v 1.8 1998/02/26 04:41:17 momjian Exp $
*
*-------------------------------------------------------------------------
*/
} QueryDesc;
/* in pquery.c */
-extern QueryDesc * CreateQueryDesc(Query *parsetree, Plan *plantree,
+extern QueryDesc *
+CreateQueryDesc(Query *parsetree, Plan *plantree,
CommandDest dest);
#endif /* EXECDESC_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: executor.h,v 1.20 1998/02/13 03:43:33 vadim Exp $
+ * $Id: executor.h,v 1.21 1998/02/26 04:41:19 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* prototypes from functions in execAmi.c
*/
-extern void ExecOpenScanR(Oid relOid, int nkeys, ScanKey skeys, bool isindex,
+extern void
+ExecOpenScanR(Oid relOid, int nkeys, ScanKey skeys, bool isindex,
ScanDirection dir, Relation *returnRelation,
Pointer *returnScanDesc);
extern void ExecCloseR(Plan *node);
extern void ExecReScan(Plan *node, ExprContext *exprCtxt, Plan *parent);
-extern HeapScanDesc ExecReScanR(Relation relDesc, HeapScanDesc scanDesc,
+extern HeapScanDesc
+ExecReScanR(Relation relDesc, HeapScanDesc scanDesc,
ScanDirection direction, int nkeys, ScanKey skeys);
extern void ExecMarkPos(Plan *node);
extern void ExecRestrPos(Plan *node);
* prototypes from functions in execJunk.c
*/
extern JunkFilter *ExecInitJunkFilter(List *targetList);
-extern bool ExecGetJunkAttribute(JunkFilter *junkfilter, TupleTableSlot *slot,
+extern bool
+ExecGetJunkAttribute(JunkFilter *junkfilter, TupleTableSlot *slot,
char *attrName, Datum *value, bool *isNull);
extern HeapTuple ExecRemoveJunk(JunkFilter *junkfilter, TupleTableSlot *slot);
extern bool execConstByVal;
extern int execConstLen;
-extern Datum ExecExtractResult(TupleTableSlot *slot, AttrNumber attnum,
+extern Datum
+ExecExtractResult(TupleTableSlot *slot, AttrNumber attnum,
bool *isNull);
-extern Datum ExecEvalParam(Param *expression, ExprContext *econtext,
+extern Datum
+ExecEvalParam(Param *expression, ExprContext *econtext,
bool *isNull);
/* stop here */
-extern char *GetAttributeByNum(TupleTableSlot *slot, AttrNumber attrno,
- bool *isNull);
+extern char *
+GetAttributeByNum(TupleTableSlot *slot, AttrNumber attrno,
+ bool *isNull);
extern char *GetAttributeByName(TupleTableSlot *slot, char *attname, bool *isNull);
-extern Datum ExecEvalExpr(Node *expression, ExprContext *econtext, bool *isNull,
+extern Datum
+ExecEvalExpr(Node *expression, ExprContext *econtext, bool *isNull,
bool *isDone);
extern bool ExecQual(List *qual, ExprContext *econtext);
extern int ExecTargetListLength(List *targetlist);
extern TupleTable ExecCreateTupleTable(int initialSize);
extern void ExecDestroyTupleTable(TupleTable table, bool shouldFree);
extern TupleTableSlot *ExecAllocTableSlot(TupleTable table);
-extern TupleTableSlot *ExecStoreTuple(HeapTuple tuple,
+extern TupleTableSlot *
+ExecStoreTuple(HeapTuple tuple,
TupleTableSlot *slot,
Buffer buffer,
bool shouldFree);
extern TupleTableSlot *ExecClearTuple(TupleTableSlot *slot);
extern bool ExecSetSlotPolicy(TupleTableSlot *slot, bool shouldFree);
-extern TupleDesc ExecSetSlotDescriptor(TupleTableSlot *slot,
+extern TupleDesc
+ExecSetSlotDescriptor(TupleTableSlot *slot,
TupleDesc tupdesc);
extern void ExecSetSlotDescriptorIsNew(TupleTableSlot *slot, bool isNew);
extern void ExecIncrSlotBufferRefcnt(TupleTableSlot *slot);
extern bool TupIsNull(TupleTableSlot *slot);
extern void ExecInitResultTupleSlot(EState *estate, CommonState *commonstate);
-extern void ExecInitScanTupleSlot(EState *estate,
+extern void
+ExecInitScanTupleSlot(EState *estate,
CommonScanState *commonscanstate);
extern void ExecInitMarkedTupleSlot(EState *estate, MergeJoinState *mergestate);
extern void ExecInitOuterTupleSlot(EState *estate, HashJoinState *hashstate);
extern TupleDesc ExecGetTupType(Plan *node);
extern TupleDesc ExecTypeFromTL(List *targetList);
-extern void SetChangedParamList (Plan *node, List *newchg);
+extern void SetChangedParamList(Plan *node, List *newchg);
/*
* prototypes from functions in execTuples.c
*/
extern void ResetTupleCount(void);
-extern void ExecAssignNodeBaseInfo(EState *estate, CommonState *basenode,
+extern void
+ExecAssignNodeBaseInfo(EState *estate, CommonState *basenode,
Plan *parent);
extern void ExecAssignExprContext(EState *estate, CommonState *commonstate);
-extern void ExecAssignResultType(CommonState *commonstate,
+extern void
+ExecAssignResultType(CommonState *commonstate,
TupleDesc tupDesc);
-extern void ExecAssignResultTypeFromOuterPlan(Plan *node,
+extern void
+ExecAssignResultTypeFromOuterPlan(Plan *node,
CommonState *commonstate);
extern void ExecAssignResultTypeFromTL(Plan *node, CommonState *commonstate);
extern TupleDesc ExecGetResultType(CommonState *commonstate);
extern void ExecAssignProjectionInfo(Plan *node, CommonState *commonstate);
extern void ExecFreeProjectionInfo(CommonState *commonstate);
extern TupleDesc ExecGetScanType(CommonScanState *csstate);
-extern void ExecAssignScanType(CommonScanState *csstate,
+extern void
+ExecAssignScanType(CommonScanState *csstate,
TupleDesc tupDesc);
-extern void ExecAssignScanTypeFromOuterPlan(Plan *node,
+extern void
+ExecAssignScanTypeFromOuterPlan(Plan *node,
CommonScanState *csstate);
extern AttributeTupleForm ExecGetTypeInfo(Relation relDesc);
-extern void ExecOpenIndices(Oid resultRelationOid,
+extern void
+ExecOpenIndices(Oid resultRelationOid,
RelationInfo *resultRelationInfo);
extern void ExecCloseIndices(RelationInfo *resultRelationInfo);
-extern void ExecInsertIndexTuples(TupleTableSlot *slot, ItemPointer tupleid,
+extern void
+ExecInsertIndexTuples(TupleTableSlot *slot, ItemPointer tupleid,
EState *estate, bool is_update);
#endif /* EXECUTOR_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: functions.h,v 1.6 1998/01/24 22:48:55 momjian Exp $
+ * $Id: functions.h,v 1.7 1998/02/26 04:41:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/primnodes.h"
#include "utils/syscache.h"
-extern Datum ProjectAttribute(TupleDesc TD, TargetEntry *tlist,
+extern Datum
+ProjectAttribute(TupleDesc TD, TargetEntry *tlist,
HeapTuple tup, bool *isnullP);
-extern Datum postquel_function(Func *funcNode, char **args,
+extern Datum
+postquel_function(Func *funcNode, char **args,
bool *isNull, bool *isDone);
#endif /* FUNCTIONS_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodeHash.h,v 1.8 1998/02/13 03:43:35 vadim Exp $
+ * $Id: nodeHash.h,v 1.9 1998/02/26 04:41:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/plannodes.h"
#include "storage/fd.h"
#include "utils/syscache.h"
-
+
extern TupleTableSlot *ExecHash(Hash *node);
extern bool ExecInitHash(Hash *node, EState *estate, Plan *parent);
extern int ExecCountSlotsHash(Hash *node);
extern void ExecEndHash(Hash *node);
extern HashJoinTable ExecHashTableCreate(Hash *node);
-extern void ExecHashTableInsert(HashJoinTable hashtable, ExprContext *econtext,
+extern void
+ExecHashTableInsert(HashJoinTable hashtable, ExprContext *econtext,
Var *hashkey, File *batches);
extern void ExecHashTableDestroy(HashJoinTable hashtable);
-extern int ExecHashGetBucket(HashJoinTable hashtable, ExprContext *econtext,
+extern int
+ExecHashGetBucket(HashJoinTable hashtable, ExprContext *econtext,
Var *hashkey);
-extern HeapTuple ExecScanHashBucket(HashJoinState *hjstate, HashBucket bucket,
+extern HeapTuple
+ExecScanHashBucket(HashJoinState *hjstate, HashBucket bucket,
HeapTuple curtuple, List *hjclauses,
ExprContext *econtext);
extern void ExecHashTableReset(HashJoinTable hashtable, int ntuples);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodeHashjoin.h,v 1.8 1998/02/13 03:43:36 vadim Exp $
+ * $Id: nodeHashjoin.h,v 1.9 1998/02/26 04:41:23 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern bool ExecInitHashJoin(HashJoin *node, EState *estate, Plan *parent);
extern int ExecCountSlotsHashJoin(HashJoin *node);
extern void ExecEndHashJoin(HashJoin *node);
-extern char * ExecHashJoinSaveTuple(HeapTuple heapTuple, char *buffer,
+extern char *
+ExecHashJoinSaveTuple(HeapTuple heapTuple, char *buffer,
File file, char *position);
extern void ExecReScanHashJoin(HashJoin *node, ExprContext *exprCtxt, Plan *parent);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodeMaterial.h,v 1.6 1998/02/13 03:43:37 vadim Exp $
+ * $Id: nodeMaterial.h,v 1.7 1998/02/26 04:41:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern int ExecCountSlotsMaterial(Material *node);
extern void ExecEndMaterial(Material *node);
extern void ExecMaterialReScan(Material *node, ExprContext *exprCtxt, Plan *parent);
+
#if 0
extern List ExecMaterialMarkPos(Material *node);
extern void ExecMaterialRestrPos(Material *node);
+
#endif
#endif /* NODEMATERIAL_H */
extern Datum ExecSubPlan(SubPlan *node, List *pvar, ExprContext *econtext);
extern bool ExecInitSubPlan(SubPlan *node, EState *estate, Plan *parent);
-extern void ExecReScanSetParamPlan (SubPlan *node, Plan *parent);
-extern void ExecSetParamPlan (SubPlan *node);
+extern void ExecReScanSetParamPlan(SubPlan *node, Plan *parent);
+extern void ExecSetParamPlan(SubPlan *node);
extern void ExecEndSubPlan(SubPlan *node);
#endif /* NODESUBPLAN_H */
uint32 free; /* # of free vals */
TupleDesc tupdesc; /* tuple descriptor */
HeapTuple *vals; /* tuples */
-} SPITupleTable;
+} SPITupleTable;
#define SPI_ERROR_CONNECT -1
#define SPI_ERROR_COPY -2
extern int SPI_connect(void);
extern int SPI_finish(void);
extern int SPI_exec(char *src, int tcount);
-extern int SPI_execp(void *plan, Datum * values, char *Nulls, int tcount);
-extern void *SPI_prepare(char *src, int nargs, Oid * argtypes);
+extern int SPI_execp(void *plan, Datum *values, char *Nulls, int tcount);
+extern void *SPI_prepare(char *src, int nargs, Oid *argtypes);
extern void *SPI_saveplan(void *plan);
extern HeapTuple SPI_copytuple(HeapTuple tuple);
-extern HeapTuple SPI_modifytuple(Relation rel, HeapTuple tuple, int natts,
- int *attnum, Datum * Values, char *Nulls);
+extern HeapTuple
+SPI_modifytuple(Relation rel, HeapTuple tuple, int natts,
+ int *attnum, Datum *Values, char *Nulls);
extern int SPI_fnumber(TupleDesc tupdesc, char *fname);
extern char *SPI_fname(TupleDesc tupdesc, int fnumber);
extern char *SPI_getvalue(HeapTuple tuple, TupleDesc tupdesc, int fnumber);
-extern Datum SPI_getbinval(HeapTuple tuple, TupleDesc tupdesc, int fnumber, bool * isnull);
+extern Datum SPI_getbinval(HeapTuple tuple, TupleDesc tupdesc, int fnumber, bool *isnull);
extern char *SPI_gettype(TupleDesc tupdesc, int fnumber);
extern Oid SPI_gettypeid(TupleDesc tupdesc, int fnumber);
extern char *SPI_getrelname(Relation rel);
-extern void *SPI_palloc (Size size);
-extern void *SPI_repalloc(void *pointer, Size size);
-extern void SPI_pfree(void *pointer);
+extern void *SPI_palloc(Size size);
+extern void *SPI_repalloc(void *pointer, Size size);
+extern void SPI_pfree(void *pointer);
#endif /* SPI_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: qsort.h,v 1.4 1998/01/24 22:49:12 momjian Exp $
+ * $Id: qsort.h,v 1.5 1998/02/26 04:41:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define QSORT_H
-extern void pg_qsort(void *bot,
+extern void
+pg_qsort(void *bot,
size_t nmemb,
size_t size,
int (*compar) (void *, void *));
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: auth.h,v 1.8 1998/01/26 01:42:05 scrappy Exp $
+ * $Id: auth.h,v 1.9 1998/02/26 04:41:35 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*----------------------------------------------------------------
*/
-void be_recvauth(Port *port);
-void auth_failed(Port *port);
+void be_recvauth(Port *port);
+void auth_failed(Port *port);
#define PG_KRB4_VERSION "PGVER4.1" /* at most KRB_SENDAUTH_VLEN chars */
#define PG_KRB5_VERSION "PGVER5.1"
#define CRYPT_PWD_FILE_SEPCHAR "'\\t'"
#define CRYPT_PWD_FILE_SEPSTR "\t"
#define CRYPT_PWD_RELOAD_SUFX ".reload"
-
-extern char** pwd_cache;
-extern int pwd_cache_count;
-extern char* crypt_getpwdfilename(void);
-extern char* crypt_getpwdreloadfilename(void);
+extern char **pwd_cache;
+extern int pwd_cache_count;
+
+extern char *crypt_getpwdfilename(void);
+extern char *crypt_getpwdreloadfilename(void);
+
#if 0
-extern MsgType crypt_salt(const char* user);
+extern MsgType crypt_salt(const char *user);
+
#endif
-extern int crypt_verify(Port* port, const char* user, const char* pgpass);
+extern int crypt_verify(Port *port, const char *user, const char *pgpass);
#endif
* Interface to hba.c
*
*
- * $Id: hba.h,v 1.7 1998/01/26 01:42:15 scrappy Exp $
+ * $Id: hba.h,v 1.8 1998/02/26 04:41:43 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define MAX_TOKEN 80
/* Maximum size of one token in the configuration file */
-#define MAX_AUTH_ARG 80 /* Max size of an authentication arg */
+#define MAX_AUTH_ARG 80 /* Max size of an authentication arg */
#define IDENT_PORT 113
/* Standard TCP port number for Ident service. Assigned by IANA */
#define IDENT_USERNAME_MAX 512
/* Max size of username ident server can return */
-typedef enum UserAuth {
+typedef enum UserAuth
+{
uaReject,
uaKrb4,
uaKrb5,
uaCrypt
} UserAuth;
-int hba_getauthmethod(SockAddr *raddr, char *database, char *auth_arg,
- UserAuth *auth_method);
-int authident(struct sockaddr_in *raddr, struct sockaddr_in *laddr,
- const char postgres_username[], const char auth_arg[]);
+int
+hba_getauthmethod(SockAddr *raddr, char *database, char *auth_arg,
+ UserAuth *auth_method);
+int
+authident(struct sockaddr_in * raddr, struct sockaddr_in * laddr,
+ const char postgres_username[], const char auth_arg[]);
#endif
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: libpq-be.h,v 1.9 1998/01/26 01:42:17 scrappy Exp $
+ * $Id: libpq-be.h,v 1.10 1998/02/26 04:41:49 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* Protocol v0 password packet. */
-typedef struct PasswordPacketV0 {
+typedef struct PasswordPacketV0
+{
uint32 unused;
char data[288]; /* User and password as strings. */
} PasswordPacketV0;
* Password packet. The length of the password can be changed without
* affecting anything.
*/
-
-typedef struct PasswordPacket {
- char passwd[100]; /* The password. */
+
+typedef struct PasswordPacket
+{
+ char passwd[100]; /* The password. */
} PasswordPacket;
/* Error message packet. */
-typedef struct ErrorMessagePacket {
- char data[1 + 100]; /* 'E' + the message. */
+typedef struct ErrorMessagePacket
+{
+ char data[1 + 100]; /* 'E' + the message. */
} ErrorMessagePacket;
/* Authentication request packet. */
-typedef struct AuthRequestPacket {
- char data[1 + sizeof (AuthRequest) + 2]; /* 'R' + the request + optional salt. */
+typedef struct AuthRequestPacket
+{
+ char data[1 + sizeof(AuthRequest) + 2]; /* 'R' + the request +
+ * optional salt. */
} AuthRequestPacket;
-
+
/* These are used by the packet handling routines. */
-typedef enum {
+typedef enum
+{
Idle,
ReadingPacketLength,
ReadingPacket,
WritingPacket
} PacketState;
-typedef struct Packet {
- PacketState state; /* What's in progress. */
+typedef struct Packet
+{
+ PacketState state; /* What's in progress. */
PacketLen len; /* Actual length */
- int nrtodo; /* Bytes still to transfer */
- char *ptr; /* Buffer pointer */
- void (*iodone)(); /* I/O complete callback */
- char *arg; /* Argument to callback */
+ int nrtodo; /* Bytes still to transfer */
+ char *ptr; /* Buffer pointer */
+ void (*iodone) (); /* I/O complete callback */
+ char *arg; /* Argument to callback */
/* A union of all the different packets. */
- union {
+ union
+ {
/* These are outgoing so have no packet length prepended. */
- ErrorMessagePacket em;
- AuthRequestPacket ar;
+ ErrorMessagePacket em;
+ AuthRequestPacket ar;
/* These are incoming and have a packet length prepended. */
- StartupPacket si;
- PasswordPacketV0 pwv0;
- PasswordPacket pw;
- } pkt;
+ StartupPacket si;
+ PasswordPacketV0 pwv0;
+ PasswordPacket pw;
+ } pkt;
} Packet;
/*
- * This is used by the postmaster in its communication with frontends. It is
+ * This is used by the postmaster in its communication with frontends. It is
* contains all state information needed during this communication before the
* backend is run.
*/
-
-typedef struct Port {
- int sock; /* File descriptor */
+
+typedef struct Port
+{
+ int sock; /* File descriptor */
Packet pktInfo; /* For the packet handlers */
SockAddr laddr; /* local addr (us) */
SockAddr raddr; /* remote addr (them) */
* handshake.
*/
- ProtocolVersion proto;
+ ProtocolVersion proto;
char database[SM_DATABASE + 1];
char user[SM_USER + 1];
char options[SM_OPTIONS + 1];
} Port;
-extern FILE *Pfout, *Pfin;
-extern int PQAsyncNotifyWaiting;
+extern FILE *Pfout,
+ *Pfin;
+extern int PQAsyncNotifyWaiting;
extern ProtocolVersion FrontendProtocol;
/*
* prototypes for functions in pqpacket.c
*/
-void PacketReceiveSetup(Packet *pkt, void (*iodone)(), char *arg);
-int PacketReceiveFragment(Packet *pkt, int sock);
-void PacketSendSetup(Packet *pkt, int nbytes, void (*iodone)(), char *arg);
-int PacketSendFragment(Packet *pkt, int sock);
-void PacketSendError(Packet *pkt, char *errormsg);
-
+void PacketReceiveSetup(Packet *pkt, void (*iodone) (), char *arg);
+int PacketReceiveFragment(Packet *pkt, int sock);
+void PacketSendSetup(Packet *pkt, int nbytes, void (*iodone) (), char *arg);
+int PacketSendFragment(Packet *pkt, int sock);
+void PacketSendError(Packet *pkt, char *errormsg);
+
#endif /* LIBPQ_BE_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: libpq.h,v 1.11 1998/01/26 01:49:19 scrappy Exp $
+ * $Id: libpq.h,v 1.12 1998/02/26 04:41:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern int PQnfieldsGroup(PortalBuffer *portal, int group_index);
extern int PQfnumberGroup(PortalBuffer *portal, int group_index, char *field_name);
extern char *PQfnameGroup(PortalBuffer *portal, int group_index, int field_number);
-extern int PQftypeGroup(PortalBuffer *portal, int group_index,
+extern int
+PQftypeGroup(PortalBuffer *portal, int group_index,
int field_number);
-extern int PQfsizeGroup(PortalBuffer *portal, int group_index,
+extern int
+PQfsizeGroup(PortalBuffer *portal, int group_index,
int field_number);
extern GroupBuffer *PQgroup(PortalBuffer *portal, int tuple_index);
extern int PQgetgroup(PortalBuffer *portal, int tuple_index);
extern int pq_recvoob(char *msgPtr, int *lenPtr);
extern int pq_getinaddr(struct sockaddr_in * sin, char *host, int port);
extern int pq_getinserv(struct sockaddr_in * sin, char *host, char *serv);
-extern int pq_connect(char *dbname, char *user, char *args, char *hostName,
+extern int
+pq_connect(char *dbname, char *user, char *args, char *hostName,
char *debugTty, char *execFile, short portName);
extern int StreamOpen(char *hostName, short portName, Port *port);
extern void pq_regoob(void (*fptr) ());
#ifndef PASSWORD_H
#define PASSWORD_H
-int verify_password(char *auth_arg, char *user, char *password);
+int verify_password(char *auth_arg, char *user, char *password);
#endif
/*-------------------------------------------------------------------------
*
* pqcomm.h--
- * Definitions common to frontends and backends.
+ * Definitions common to frontends and backends.
*
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pqcomm.h,v 1.22 1998/01/28 02:29:40 momjian Exp $
+ * $Id: pqcomm.h,v 1.23 1998/02/26 04:41:53 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* Define a generic socket address type. */
-typedef union SockAddr {
- struct sockaddr sa;
- struct sockaddr_in in;
- struct sockaddr_un un;
+typedef union SockAddr
+{
+ struct sockaddr sa;
+ struct sockaddr_in in;
+ struct sockaddr_un un;
} SockAddr;
/* Configure the UNIX socket address for the well known port. */
-#define UNIXSOCK_PATH(sun,port) \
+#define UNIXSOCK_PATH(sun,port) \
(sprintf((sun).sun_path, "/tmp/.s.PGSQL.%d", (port)) + \
offsetof(struct sockaddr_un, sun_path))
/*
* version.
*/
-#define PG_PROTOCOL_MAJOR(v) ((v) >> 16)
-#define PG_PROTOCOL_MINOR(v) ((v) & 0x0000ffff)
-#define PG_PROTOCOL(m,n) (((m) << 16) | (n))
+#define PG_PROTOCOL_MAJOR(v) ((v) >> 16)
+#define PG_PROTOCOL_MINOR(v) ((v) & 0x0000ffff)
+#define PG_PROTOCOL(m,n) (((m) << 16) | (n))
/* The earliest and latest frontend/backend protocol version supported. */
-#define PG_PROTOCOL_EARLIEST PG_PROTOCOL(0,0)
-#define PG_PROTOCOL_LATEST PG_PROTOCOL(1,0)
+#define PG_PROTOCOL_EARLIEST PG_PROTOCOL(0,0)
+#define PG_PROTOCOL_LATEST PG_PROTOCOL(1,0)
/*
* All packets sent to the postmaster start with the length. This is omitted
typedef uint32 PacketLen;
-
+
/*
* Startup message parameters sizes. These must not be changed without changing
* the protcol version. These are all strings that are '\0' terminated only if
* there is room.
*/
-#define SM_DATABASE 64
-#define SM_USER 32
-#define SM_OPTIONS 64
-#define SM_UNUSED 64
-#define SM_TTY 64
+#define SM_DATABASE 64
+#define SM_USER 32
+#define SM_OPTIONS 64
+#define SM_UNUSED 64
+#define SM_TTY 64
-typedef uint32 ProtocolVersion; /* Fe/Be protocol version nr. */
+typedef uint32 ProtocolVersion; /* Fe/Be protocol version nr. */
-typedef struct StartupPacket {
- ProtocolVersion protoVersion; /* Protocol version */
+typedef struct StartupPacket
+{
+ ProtocolVersion protoVersion; /* Protocol version */
char database[SM_DATABASE]; /* Database name */
- char user[SM_USER]; /* User name */
+ char user[SM_USER]; /* User name */
char options[SM_OPTIONS]; /* Optional additional args */
- char unused[SM_UNUSED]; /* Unused */
- char tty[SM_TTY]; /* Tty for debug output */
+ char unused[SM_UNUSED]; /* Unused */
+ char tty[SM_TTY]; /* Tty for debug output */
} StartupPacket;
/* These are the authentication requests sent by the backend. */
-#define AUTH_REQ_OK 0 /* User is authenticated */
-#define AUTH_REQ_KRB4 1 /* Kerberos V4 */
-#define AUTH_REQ_KRB5 2 /* Kerberos V5 */
-#define AUTH_REQ_PASSWORD 3 /* Password */
-#define AUTH_REQ_CRYPT 4 /* Encrypted password */
+#define AUTH_REQ_OK 0 /* User is authenticated */
+#define AUTH_REQ_KRB4 1 /* Kerberos V4 */
+#define AUTH_REQ_KRB5 2 /* Kerberos V5 */
+#define AUTH_REQ_PASSWORD 3 /* Password */
+#define AUTH_REQ_CRYPT 4 /* Encrypted password */
typedef uint32 AuthRequest;
/* This next section is to maintain compatibility with protocol v0.0. */
-#define STARTUP_MSG 7 /* Initialise a connection */
-#define STARTUP_KRB4_MSG 10 /* krb4 session follows */
-#define STARTUP_KRB5_MSG 11 /* krb5 session follows */
-#define STARTUP_PASSWORD_MSG 14 /* Password follows */
+#define STARTUP_MSG 7 /* Initialise a connection */
+#define STARTUP_KRB4_MSG 10 /* krb4 session follows */
+#define STARTUP_KRB5_MSG 11 /* krb5 session follows */
+#define STARTUP_PASSWORD_MSG 14 /* Password follows */
typedef ProtocolVersion MsgType;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: miscadmin.h,v 1.19 1998/01/25 05:15:01 momjian Exp $
+ * $Id: miscadmin.h,v 1.20 1998/02/26 04:39:48 momjian Exp $
*
* NOTES
* some of the information in this file will be moved to
* USE_POSTGRES_DATES specifies traditional postgres format for output.
* USE_ISO_DATES specifies ISO-compliant format for output.
* USE_SQL_DATES specified Oracle/Ingres-compliant format for output.
- * USE_GERMAN_DATES specifies German-style dd.mm/yyyy date format.
+ * USE_GERMAN_DATES specifies German-style dd.mm/yyyy date format.
*
* DateStyle specifies preference for date formatting for output.
* EuroDates if client prefers dates interpreted and written w/European conventions.
/* in utils/misc/database.c */
extern void GetRawDatabaseInfo(char *name, Oid *owner, Oid *db_id, char *path);
-extern int GetDatabaseInfo(char *name, Oid *owner, char *path);
+extern int GetDatabaseInfo(char *name, Oid *owner, char *path);
extern char *ExpandDatabasePath(char *path);
/* now in utils/init/miscinit.c */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: execnodes.h,v 1.14 1998/02/18 12:41:36 vadim Exp $
+ * $Id: execnodes.h,v 1.15 1998/02/26 04:41:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
typedef struct ExprContext
{
- NodeTag type;
- TupleTableSlot *ecxt_scantuple;
- TupleTableSlot *ecxt_innertuple;
- TupleTableSlot *ecxt_outertuple;
- Relation ecxt_relation;
- Index ecxt_relid;
- ParamListInfo ecxt_param_list_info;
- ParamExecData *ecxt_param_exec_vals; /* this is for subselects */
- List *ecxt_range_table;
- Datum *ecxt_values; /* precomputed values for aggreg */
- char *ecxt_nulls; /* null flags for aggreg values */
+ NodeTag type;
+ TupleTableSlot *ecxt_scantuple;
+ TupleTableSlot *ecxt_innertuple;
+ TupleTableSlot *ecxt_outertuple;
+ Relation ecxt_relation;
+ Index ecxt_relid;
+ ParamListInfo ecxt_param_list_info;
+ ParamExecData *ecxt_param_exec_vals; /* this is for subselects */
+ List *ecxt_range_table;
+ Datum *ecxt_values; /* precomputed values for aggreg */
+ char *ecxt_nulls; /* null flags for aggreg values */
} ExprContext;
/* ----------------
*/
typedef struct EState
{
- NodeTag type;
- ScanDirection es_direction;
- List *es_range_table;
- RelationInfo *es_result_relation_info;
- Relation es_into_relation_descriptor;
- ParamListInfo es_param_list_info;
- ParamExecData *es_param_exec_vals; /* this is for subselects */
- int es_BaseId;
- TupleTable es_tupleTable;
- JunkFilter *es_junkFilter;
- int *es_refcount;
- uint32 es_processed; /* # of tuples processed */
- Oid es_lastoid; /* last oid processed (by INSERT) */
+ NodeTag type;
+ ScanDirection es_direction;
+ List *es_range_table;
+ RelationInfo *es_result_relation_info;
+ Relation es_into_relation_descriptor;
+ ParamListInfo es_param_list_info;
+ ParamExecData *es_param_exec_vals; /* this is for subselects */
+ int es_BaseId;
+ TupleTable es_tupleTable;
+ JunkFilter *es_junkFilter;
+ int *es_refcount;
+ uint32 es_processed; /* # of tuples processed */
+ Oid es_lastoid; /* last oid processed (by INSERT) */
} EState;
/* ----------------
*/
typedef struct GroupState
{
- CommonScanState csstate; /* its first field is NodeTag */
- bool grp_useFirstTuple; /* first tuple not processed yet */
+ CommonScanState csstate; /* its first field is NodeTag */
+ bool grp_useFirstTuple; /* first tuple not processed yet */
bool grp_done;
HeapTuple grp_firstTuple;
} GroupState;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: makefuncs.h,v 1.10 1998/02/21 16:58:45 momjian Exp $
+ * $Id: makefuncs.h,v 1.11 1998/02/26 04:41:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include
#include
-extern Oper * makeOper(Oid opno,
+extern Oper *
+makeOper(Oid opno,
Oid opid,
Oid opresulttype,
int opsize,
FunctionCachePtr op_fcache);
-extern Var * makeVar(Index varno,
+extern Var *
+makeVar(Index varno,
AttrNumber varattno,
Oid vartype,
int16 vartypmod,
Index varnoold,
AttrNumber varoattno);
-extern Resdom * makeResdom(AttrNumber resno,
+extern Resdom *
+makeResdom(AttrNumber resno,
Oid restype,
int16 restypmod,
char *resname,
Oid reskeyop,
int resjunk);
-extern Const * makeConst(Oid consttype,
+extern Const *
+makeConst(Oid consttype,
int constlen,
Datum constvalue,
bool constisnull,
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: params.h,v 1.7 1998/02/13 03:45:24 vadim Exp $
+ * $Id: params.h,v 1.8 1998/02/26 04:41:58 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define PARAM_NUM 12
#define PARAM_NEW 13
#define PARAM_OLD 14
-#define PARAM_EXEC 15
+#define PARAM_EXEC 15
#define PARAM_INVALID 100
typedef struct ParamExecData
{
- void *execPlan; /* plan must be executed to get param value */
+ void *execPlan; /* plan must be executed to get param
+ * value */
Datum value;
bool isnull;
} ParamExecData;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parsenodes.h,v 1.48 1998/02/21 06:32:02 scrappy Exp $
+ * $Id: parsenodes.h,v 1.49 1998/02/26 04:41:59 momjian Exp $
*
*-------------------------------------------------------------------------
*/
bool unionall; /* union without unique sort */
bool hasAggs; /* has aggregates in target list */
bool hasSubLinks; /* has subquery SubLink */
-
+
char *uniqueFlag; /* NULL, '*', or Unique attribute name */
List *sortClause; /* a list of SortClause's */
* BY */
Node *havingQual; /* qualification of each group */
- List *unionClause; /* unions are linked under the previous query */
+ List *unionClause; /* unions are linked under the previous
+ * query */
/* internal to planner */
List *base_relation_list_; /* base relation list */
/* ----------------------
- * Create/Alter/Drop User Statements
+ * Create/Alter/Drop User Statements
* ----------------------
*/
typedef struct CreateUserStmt
{
- NodeTag type;
- char* user; /* PostgreSQL user login */
- char* password; /* PostgreSQL user password */
- bool* createdb; /* Can the user create databases? */
- bool* createuser; /* Can this user create users? */
- List* groupElts; /* The groups the user is a member of */
- char* validUntil; /* The time the login is valid until */
+ NodeTag type;
+ char *user; /* PostgreSQL user login */
+ char *password; /* PostgreSQL user password */
+ bool *createdb; /* Can the user create databases? */
+ bool *createuser; /* Can this user create users? */
+ List *groupElts; /* The groups the user is a member of */
+ char *validUntil; /* The time the login is valid until */
} CreateUserStmt;
-typedef CreateUserStmt AlterUserStmt;
+typedef CreateUserStmt AlterUserStmt;
typedef struct DropUserStmt
{
- NodeTag type;
- char* user; /* PostgreSQL user login */
+ NodeTag type;
+ char *user; /* PostgreSQL user login */
} DropUserStmt;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: plannodes.h,v 1.14 1998/02/13 03:45:25 vadim Exp $
+ * $Id: plannodes.h,v 1.15 1998/02/26 04:42:01 momjian Exp $
*
*-------------------------------------------------------------------------
*/
List *qual; /* Node* or List* ?? */
struct Plan *lefttree;
struct Plan *righttree;
- List *extParam; /* indices of _all_ _external_ PARAM_EXEC for
- * this plan in global es_param_exec_vals.
- * Params from setParam from initPlan-s
- * are not included, but their execParam-s
- * are here!!! */
+ List *extParam; /* indices of _all_ _external_ PARAM_EXEC
+ * for this plan in global
+ * es_param_exec_vals. Params from
+ * setParam from initPlan-s are not
+ * included, but their execParam-s are
+ * here!!! */
List *locParam; /* someones from setParam-s */
List *chgParam; /* list of changed ones from the above */
- List *initPlan; /* Init Plan nodes (un-correlated expr subselects) */
+ List *initPlan; /* Init Plan nodes (un-correlated expr
+ * subselects) */
List *subPlan; /* Other SubPlan nodes */
-
- /*
+
+ /*
* We really need in some TopPlan node to store range table and
- * resultRelation from Query there and get rid of Query itself
- * from Executor. Some other stuff like below could be put there, too.
+ * resultRelation from Query there and get rid of Query itself from
+ * Executor. Some other stuff like below could be put there, too.
*/
int nParamExec; /* Number of them in entire query. This is
* to get Executor know about how many
typedef struct Agg
{
Plan plan;
- List *aggs;
+ List *aggs;
AggState *aggstate;
} Agg;
*/
typedef struct SubPlan
{
- NodeTag type;
- Plan *plan; /* subselect plan itself */
- int plan_id; /* dummy thing because of we haven't
- * equal funcs for plan nodes... actually,
- * we could put *plan itself somewhere else
+ NodeTag type;
+ Plan *plan; /* subselect plan itself */
+ int plan_id; /* dummy thing because of we haven't equal
+ * funcs for plan nodes... actually, we
+ * could put *plan itself somewhere else
* (TopPlan node ?)... */
- List *rtable; /* range table */
- List *setParam; /* non-correlated EXPR & EXISTS subqueries
+ List *rtable; /* range table */
+ List *setParam; /* non-correlated EXPR & EXISTS subqueries
* have to set some Params for paren Plan */
- List *parParam; /* indices of corr. Vars from parent plan */
- SubLink *sublink; /* SubLink node for subselects in WHERE and HAVING */
- bool shutdown; /* shutdown plan if TRUE */
+ List *parParam; /* indices of corr. Vars from parent plan */
+ SubLink *sublink; /* SubLink node for subselects in WHERE
+ * and HAVING */
+ bool shutdown; /* shutdown plan if TRUE */
} SubPlan;
#endif /* PLANNODES_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: primnodes.h,v 1.20 1998/02/21 16:58:49 momjian Exp $
+ * $Id: primnodes.h,v 1.21 1998/02/26 04:42:02 momjian Exp $
*
*-------------------------------------------------------------------------
*/
char *aggname;
Oid basetype;
Oid aggtype;
- Node *target;
+ Node *target;
int aggno;
bool usenulls;
} Aggreg;
typedef struct SubLink
{
NodeTag type;
- SubLinkType subLinkType;
+ SubLinkType subLinkType;
bool useor;
- List *lefthand;
- List *oper;
- Node *subselect;
+ List *lefthand;
+ List *oper;
+ Node *subselect;
} SubLink;
/* ----------------
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: print.h,v 1.6 1998/01/24 22:49:28 momjian Exp $
+ * $Id: print.h,v 1.7 1998/02/26 04:42:03 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void print_keys(List *keys, List *rtable);
extern void print_tl(List *tlist, List *rtable);
extern void print_slot(TupleTableSlot *slot);
-extern void print_plan_recursive(Plan *p, Query *parsetree,
+extern void
+print_plan_recursive(Plan *p, Query *parsetree,
int indentLevel, char *label);
extern void print_plan(Plan *p, Query *parsetree);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: clauseinfo.h,v 1.6 1998/01/24 22:49:34 momjian Exp $
+ * $Id: clauseinfo.h,v 1.7 1998/02/26 04:42:08 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern bool valid_or_clause(CInfo *clauseinfo);
extern List *get_actual_clauses(List *clauseinfo_list);
-extern void get_relattvals(List *clauseinfo_list, List **attnos,
+extern void
+get_relattvals(List *clauseinfo_list, List **attnos,
List **values, List **flags);
-extern void get_joinvars(Oid relid, List *clauseinfo_list,
+extern void
+get_joinvars(Oid relid, List *clauseinfo_list,
List **attnos, List **values, List **flags);
extern List *get_opnos(List *clauseinfo_list);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: clauses.h,v 1.9 1998/02/13 03:46:54 vadim Exp $
+ * $Id: clauses.h,v 1.10 1998/02/26 04:42:13 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern bool qual_clause_p(Node *clause);
extern void fix_opid(Node *clause);
extern List *fix_opids(List *clauses);
-extern void get_relattval(Node *clause, int *relid,
+extern void
+get_relattval(Node *clause, int *relid,
AttrNumber *attno, Datum *constval, int *flag);
-extern void get_rels_atts(Node *clause, int *relid1,
+extern void
+get_rels_atts(Node *clause, int *relid1,
AttrNumber *attno1, int *relid2, AttrNumber *attno2);
extern void CommuteClause(Node *clause);
-#define is_subplan(clause) ((Node*) clause != NULL && \
+#define is_subplan(clause) ((Node*) clause != NULL && \
nodeTag((Node*) clause) == T_Expr && \
((Expr *) clause)->opType == SUBPLAN_EXPR)
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: cost.h,v 1.7 1998/01/24 22:49:41 momjian Exp $
+ * $Id: cost.h,v 1.8 1998/02/26 04:42:14 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern bool _enable_hashjoin_;
extern Cost cost_seqscan(int relid, int relpages, int reltuples);
-extern Cost cost_index(Oid indexid, int expected_indexpages, Cost selec,
+extern Cost
+cost_index(Oid indexid, int expected_indexpages, Cost selec,
int relpages, int reltuples, int indexpages,
int indextuples, bool is_injoin);
extern Cost cost_sort(List *keys, int tuples, int width, bool noread);
-extern Cost cost_nestloop(Cost outercost, Cost innercost, int outertuples,
+extern Cost
+cost_nestloop(Cost outercost, Cost innercost, int outertuples,
int innertuples, int outerpages, bool is_indexjoin);
-extern Cost cost_mergesort(Cost outercost, Cost innercost,
+extern Cost
+cost_mergesort(Cost outercost, Cost innercost,
List *outersortkeys, List *innersortkeys,
int outersize, int innersize, int outerwidth, int innerwidth);
-extern Cost cost_hashjoin(Cost outercost, Cost innercost, List *outerkeys,
+extern Cost
+cost_hashjoin(Cost outercost, Cost innercost, List *outerkeys,
List *innerkeys, int outersize, int innersize,
int outerwidth, int innerwidth);
extern int compute_rel_size(Rel *rel);
extern Cost product_selec(List *clauseinfo_list);
extern void set_rest_relselec(Query *root, List *rel_list);
extern void set_rest_selec(Query *root, List *clauseinfo_list);
-extern Cost compute_clause_selec(Query *root,
+extern Cost
+compute_clause_selec(Query *root,
Node *clause, List *or_selectivities);
#endif /* COST_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: ordering.h,v 1.7 1998/01/24 22:49:43 momjian Exp $
+ * $Id: ordering.h,v 1.8 1998/02/26 04:42:15 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include
-extern bool equal_path_path_ordering(PathOrder *path_ordering1,
+extern bool
+equal_path_path_ordering(PathOrder *path_ordering1,
PathOrder *path_ordering2);
-extern bool equal_path_merge_ordering(Oid *path_ordering,
+extern bool
+equal_path_merge_ordering(Oid *path_ordering,
MergeOrder *merge_ordering);
-extern bool equal_merge_merge_ordering(MergeOrder *merge_ordering1,
+extern bool
+equal_merge_merge_ordering(MergeOrder *merge_ordering1,
MergeOrder *merge_ordering2);
#endif /* ORDERING_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pathnode.h,v 1.6 1998/01/24 22:49:46 momjian Exp $
+ * $Id: pathnode.h,v 1.7 1998/02/26 04:42:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
extern bool path_is_cheaper(Path *path1, Path *path2);
extern Path *set_cheapest(Rel *parent_rel, List *pathlist);
-extern List * add_pathlist(Rel *parent_rel, List *unique_paths,
+extern List *
+add_pathlist(Rel *parent_rel, List *unique_paths,
List *new_paths);
extern Path *create_seqscan_path(Rel *rel);
-extern IndexPath * create_index_path(Query *root, Rel *rel, Rel *index,
+extern IndexPath *
+create_index_path(Query *root, Rel *rel, Rel *index,
List *restriction_clauses, bool is_join_scan);
-extern JoinPath * create_nestloop_path(Rel *joinrel, Rel *outer_rel,
+extern JoinPath *
+create_nestloop_path(Rel *joinrel, Rel *outer_rel,
Path *outer_path, Path *inner_path, List *keys);
-extern MergePath * create_mergesort_path(Rel *joinrel, int outersize,
+extern MergePath *
+create_mergesort_path(Rel *joinrel, int outersize,
int innersize, int outerwidth, int innerwidth, Path *outer_path,
Path *inner_path, List *keys, MergeOrder *order,
List *mergeclauses, List *outersortkeys, List *innersortkeys);
-extern HashPath * create_hashjoin_path(Rel *joinrel, int outersize,
+extern HashPath *
+create_hashjoin_path(Rel *joinrel, int outersize,
int innersize, int outerwidth, int innerwidth, Path *outer_path,
Path *inner_path, List *keys, Oid operator, List *hashclauses,
List *outerkeys, List *innerkeys);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: paths.h,v 1.7 1998/01/24 22:49:48 momjian Exp $
+ * $Id: paths.h,v 1.8 1998/02/26 04:42:17 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* indxpath.h
* routines to generate index paths
*/
-extern List * find_index_paths(Query *root, Rel *rel, List *indices,
+extern List *
+find_index_paths(Query *root, Rel *rel, List *indices,
List *clauseinfo_list,
List *joininfo_list);
* hashutils.h
* routines to deal with hash keys and clauses
*/
-extern List * group_clauses_by_hashop(List *clauseinfo_list,
+extern List *
+group_clauses_by_hashop(List *clauseinfo_list,
int inner_relid);
/*
* joinutils.h
* generic join method key/clause routines
*/
-extern List * match_pathkeys_joinkeys(List *pathkeys,
+extern List *
+match_pathkeys_joinkeys(List *pathkeys,
List *joinkeys, List *joinclauses, int which_subkey,
List **matchedJoinClausesPtr);
-extern List * extract_path_keys(List *joinkeys, List *tlist,
+extern List *
+extract_path_keys(List *joinkeys, List *tlist,
int which_subkey);
-extern Path * match_paths_joinkeys(List *joinkeys, PathOrder *ordering,
+extern Path *
+match_paths_joinkeys(List *joinkeys, PathOrder *ordering,
List *paths, int which_subkey);
-extern List * new_join_pathkeys(List *outer_pathkeys,
+extern List *
+new_join_pathkeys(List *outer_pathkeys,
List *join_rel_tlist, List *joinclauses);
/*
* mergeutils.h
* routines to deal with merge keys and clauses
*/
-extern List * group_clauses_by_order(List *clauseinfo_list,
+extern List *
+group_clauses_by_order(List *clauseinfo_list,
int inner_relid);
-extern MInfo * match_order_mergeinfo(PathOrder *ordering,
+extern MInfo *
+match_order_mergeinfo(PathOrder *ordering,
List *mergeinfo_list);
/*
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: plancat.h,v 1.7 1998/01/24 22:49:50 momjian Exp $
+ * $Id: plancat.h,v 1.8 1998/02/26 04:42:18 momjian Exp $
*
*-------------------------------------------------------------------------
*/
} IdxInfoRetval;
-extern void relation_info(Query *root,
+extern void
+relation_info(Query *root,
Oid relid,
bool *hashindex, int *pages,
int *tuples);
-extern bool index_info(Query *root,
+extern bool
+index_info(Query *root,
bool first, int relid, IdxInfoRetval *info);
-extern Cost restriction_selectivity(Oid functionObjectId,
+extern Cost
+restriction_selectivity(Oid functionObjectId,
Oid operatorObjectId,
Oid relationObjectId,
AttrNumber attributeNumber,
char *constValue,
int32 constFlag);
-extern void index_selectivity(Oid indid, Oid *classes, List *opnos,
+extern void
+index_selectivity(Oid indid, Oid *classes, List *opnos,
Oid relid, List *attnos, List *values, List *flags,
int32 nkeys, float *idxPages, float *idxSelec);
-extern Cost join_selectivity(Oid functionObjectId, Oid operatorObjectId,
+extern Cost
+join_selectivity(Oid functionObjectId, Oid operatorObjectId,
Oid relationObjectId1, AttrNumber attributeNumber1,
Oid relationObjectId2, AttrNumber attributeNumber2);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: planmain.h,v 1.10 1998/01/15 19:00:15 momjian Exp $
+ * $Id: planmain.h,v 1.11 1998/02/26 04:42:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* prototypes for plan/planmain.c
*/
-extern Plan *query_planner(Query *root,
+extern Plan *
+query_planner(Query *root,
int command_type, List *tlist, List *qual);
* prototypes for plan/createplan.c
*/
extern Plan *create_plan(Path *best_path);
-extern SeqScan *make_seqscan(List *qptlist, List *qpqual, Index scanrelid,
+extern SeqScan *
+make_seqscan(List *qptlist, List *qpqual, Index scanrelid,
Plan *lefttree);
-extern Sort *make_sort(List *tlist, Oid tempid, Plan *lefttree,
+extern Sort *
+make_sort(List *tlist, Oid tempid, Plan *lefttree,
int keycount);
extern Agg *make_agg(List *tlist, Plan *lefttree);
-extern Group *make_group(List *tlist, bool tuplePerGroup, int ngrp,
+extern Group *
+make_group(List *tlist, bool tuplePerGroup, int ngrp,
AttrNumber *grpColIdx, Sort *lefttree);
extern Unique *make_unique(List *tlist, Plan *lefttree, char *uniqueAttr);
* prototypes for plan/setrefs.c
*/
extern void set_tlist_references(Plan *plan);
-extern List *join_references(List *clauses, List *outer_tlist,
+extern List *
+join_references(List *clauses, List *outer_tlist,
List *inner_tlist);
-extern List *index_outerjoin_references(List *inner_indxqual,
+extern List *
+index_outerjoin_references(List *inner_indxqual,
List *outer_tlist, Index inner_relid);
extern void set_result_tlist_references(Result *resultNode);
extern List *set_agg_tlist_references(Agg *aggNode);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: prep.h,v 1.11 1997/12/29 01:13:23 momjian Exp $
+ * $Id: prep.h,v 1.12 1998/02/26 04:42:23 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* prototypes for preptlist.h
*/
-extern List *preprocess_targetlist(List *tlist, int command_type,
+extern List *
+preprocess_targetlist(List *tlist, int command_type,
Index result_relation, List *range_table);
-extern List *find_all_inheritors(List *unexamined_relids,
+extern List *
+find_all_inheritors(List *unexamined_relids,
List *examined_relids);
extern int first_inherit_rt_entry(List *rangetable);
extern Append *plan_union_queries(Query *parse);
#ifndef SUBSELECT_H
#define SUBSELECT_H
-extern int PlannerQueryLevel; /* level of current query */
-extern List *PlannerVarParam; /* correlation Vars to Param mapper */
-extern List *PlannerParamVar; /* to get Var from Param->paramid */
-extern List *PlannerInitPlan; /* init subplans for current query */
-extern int PlannerPlanId; /* to assigne unique ID to subquery plans */
+extern int PlannerQueryLevel; /* level of current query */
+extern List *PlannerVarParam; /* correlation Vars to Param mapper */
+extern List *PlannerParamVar; /* to get Var from Param->paramid */
+extern List *PlannerInitPlan; /* init subplans for current query */
+extern int PlannerPlanId; /* to assigne unique ID to subquery plans */
-extern List *SS_finalize_plan (Plan *plan);
-extern Node *SS_replace_correlation_vars (Node *expr);
-extern Node *SS_process_sublinks (Node *expr);
+extern List *SS_finalize_plan(Plan *plan);
+extern Node *SS_replace_correlation_vars(Node *expr);
+extern Node *SS_process_sublinks(Node *expr);
#endif /* SUBSELECT_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: tlist.h,v 1.7 1998/01/24 22:49:51 momjian Exp $
+ * $Id: tlist.h,v 1.8 1998/02/26 04:42:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern List *new_unsorted_tlist(List *targetlist);
extern List *copy_vars(List *target, List *source);
extern List *flatten_tlist(List *tlist);
-extern List * flatten_tlist_vars(List *full_tlist,
+extern List *
+flatten_tlist_vars(List *full_tlist,
List *flat_tlist);
#endif /* TLIST_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: xfunc.h,v 1.6 1998/01/24 22:49:52 momjian Exp $
+ * $Id: xfunc.h,v 1.7 1998/02/26 04:42:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* function prototypes from planner/path/xfunc.c */
extern void xfunc_trypullup(Rel *rel);
-extern int xfunc_shouldpull(Path *childpath, JoinPath *parentpath,
+extern int
+xfunc_shouldpull(Path *childpath, JoinPath *parentpath,
int whichchild, CInfo *maxcinfopt);
-extern CInfo * xfunc_pullup(Path *childpath, JoinPath *parentpath, CInfo *cinfo,
+extern CInfo *
+xfunc_pullup(Path *childpath, JoinPath *parentpath, CInfo *cinfo,
int whichchild, int clausetype);
extern Cost xfunc_rank(Expr *clause);
extern Cost xfunc_expense(Query *queryInfo, Expr *clause);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: gramparse.h,v 1.6 1997/11/26 03:43:05 momjian Exp $
+ * $Id: gramparse.h,v 1.7 1998/02/26 04:42:36 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void init_io(void);
/* from gram.y */
-extern Oid param_type(int t);
+extern Oid param_type(int t);
extern void parser_init(Oid *typev, int nargs);
extern int yyparse(void);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_agg.h,v 1.5 1998/01/20 05:04:41 momjian Exp $
+ * $Id: parse_agg.h,v 1.6 1998/02/26 04:42:39 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void AddAggToParseState(ParseState *pstate, Aggreg *aggreg);
extern void parseCheckAggregates(ParseState *pstate, Query *qry);
-extern Aggreg *ParseAgg(ParseState *pstate, char *aggname, Oid basetype,
- List *target, int precedence);
+extern Aggreg *
+ParseAgg(ParseState *pstate, char *aggname, Oid basetype,
+ List *target, int precedence);
extern void agg_error(char *caller, char *aggname, Oid basetypeID);
#endif /* PARSE_AGG_H */
-
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_clause.h,v 1.5 1997/12/29 04:31:50 momjian Exp $
+ * $Id: parse_clause.h,v 1.6 1998/02/26 04:42:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void makeRangeTable(ParseState *pstate, char *relname, List *frmList);
extern Node *transformWhereClause(ParseState *pstate, Node *a_expr);
-extern List *transformGroupClause(ParseState *pstate, List *grouplist,
- List *targetlist);
-extern List *transformSortClause(ParseState *pstate,
+extern List *
+transformGroupClause(ParseState *pstate, List *grouplist,
+ List *targetlist);
+extern List *
+transformSortClause(ParseState *pstate,
List *orderlist, List *sortClause,
List *targetlist, char *uniqueFlag);
extern List *transformUnionClause(List *unionClause, List *targetlist);
#endif /* PARSE_CLAUSE_H */
-
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_expr.h,v 1.7 1998/02/10 16:04:30 momjian Exp $
+ * $Id: parse_expr.h,v 1.8 1998/02/26 04:42:41 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Node *transformExpr(ParseState *pstate, Node *expr, int precedence);
extern Node *transformIdent(ParseState *pstate, Node *expr, int precedence);
-extern Oid exprType(Node *expr);
+extern Oid exprType(Node *expr);
extern Node *parser_typecast2(Node *expr, Oid exprType, Type tp, int16 attypmod);
#endif /* PARSE_EXPR_H */
-
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_func.h,v 1.7 1998/02/05 04:08:44 scrappy Exp $
+ * $Id: parse_func.h,v 1.8 1998/02/26 04:42:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
struct _CandidateList *next;
} *CandidateList;
-extern Node *ParseNestedFuncOrColumn(ParseState *pstate, Attr *attr,
- int *curr_resno, int precedence);
-extern Node *ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
- int *curr_resno, int precedence);
+extern Node *
+ParseNestedFuncOrColumn(ParseState *pstate, Attr *attr,
+ int *curr_resno, int precedence);
+extern Node *
+ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
+ int *curr_resno, int precedence);
extern void func_error(char *caller, char *funcname, int nargs, Oid *argtypes);
#endif /* PARSE_FUNC_H */
-
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_node.h,v 1.9 1998/02/10 04:02:47 momjian Exp $
+ * $Id: parse_node.h,v 1.10 1998/02/26 04:42:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern ParseState *make_parsestate(ParseState *parentParseState);
extern Expr *make_op(char *opname, Node *ltree, Node *rtree);
-extern Var *make_var(ParseState *pstate, Oid relid, char *refname,
- char *attrname);
-extern ArrayRef *make_array_ref(Node *expr,
+extern Var *
+make_var(ParseState *pstate, Oid relid, char *refname,
+ char *attrname);
+extern ArrayRef *
+make_array_ref(Node *expr,
List *indirection);
-extern ArrayRef *make_array_set(Expr *target_expr,
- List *upperIndexpr,
- List *lowerIndexpr,
- Expr *expr);
+extern ArrayRef *
+make_array_set(Expr *target_expr,
+ List *upperIndexpr,
+ List *lowerIndexpr,
+ Expr *expr);
extern Const *make_const(Value *value);
-
+
#endif /* PARSE_NODE_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_oper.h,v 1.3 1997/11/26 03:43:14 momjian Exp $
+ * $Id: parse_oper.h,v 1.4 1998/02/26 04:42:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
typedef HeapTuple Operator;
-extern Oid any_ordering_op(int restype);
-extern Oid oprid(Operator op);
+extern Oid any_ordering_op(int restype);
+extern Oid oprid(Operator op);
extern Operator oper(char *op, Oid arg1, Oid arg2, bool noWarnings);
extern Operator right_oper(char *op, Oid arg);
extern Operator left_oper(char *op, Oid arg);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_relation.h,v 1.6 1998/01/20 22:12:17 momjian Exp $
+ * $Id: parse_relation.h,v 1.7 1998/02/26 04:42:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include
extern RangeTblEntry *refnameRangeTableEntry(ParseState *pstate, char *refname);
-extern int refnameRangeTablePosn(ParseState *pstate,
- char *refname, int *sublevels_up);
+extern int
+refnameRangeTablePosn(ParseState *pstate,
+ char *refname, int *sublevels_up);
extern RangeTblEntry *colnameRangeTableEntry(ParseState *pstate, char *colname);
-extern RangeTblEntry *addRangeTableEntry(ParseState *pstate,
- char *relname,
- char *refname,
- bool inh,
- bool inFromCl);
-extern List *expandAll(ParseState *pstate, char *relname, char *refname,
- int *this_resno);
-extern int attnameAttNum(Relation rd, char *a);
+extern RangeTblEntry *
+addRangeTableEntry(ParseState *pstate,
+ char *relname,
+ char *refname,
+ bool inh,
+ bool inFromCl);
+extern List *
+expandAll(ParseState *pstate, char *relname, char *refname,
+ int *this_resno);
+extern int attnameAttNum(Relation rd, char *a);
extern bool attnameIsSet(Relation rd, char *name);
-extern int attnumAttNelems(Relation rd, int attid);
-extern Oid attnumTypeId(Relation rd, int attid);
-extern void handleTargetColname(ParseState *pstate, char **resname,
+extern int attnumAttNelems(Relation rd, int attid);
+extern Oid attnumTypeId(Relation rd, int attid);
+extern void
+handleTargetColname(ParseState *pstate, char **resname,
char *refname, char *colname);
#endif /* PARSE_RANGE_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_target.h,v 1.3 1997/11/26 03:43:18 momjian Exp $
+ * $Id: parse_target.h,v 1.4 1998/02/26 04:42:49 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define EXPR_COLUMN_FIRST 1
-#define EXPR_RELATION_FIRST 2
+#define EXPR_RELATION_FIRST 2
extern List *transformTargetList(ParseState *pstate, List *targetlist);
extern List *makeTargetNames(ParseState *pstate, List *cols);
#endif /* PARSE_TARGET_H */
-
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_type.h,v 1.5 1998/02/13 19:46:18 momjian Exp $
+ * $Id: parse_type.h,v 1.6 1998/02/26 04:42:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Type typeidType(Oid id);
extern Type typenameType(char *s);
extern char *typeidTypeName(Oid id);
-extern Oid typeTypeId(Type tp);
+extern Oid typeTypeId(Type tp);
extern int16 typeLen(Type t);
extern bool typeByVal(Type t);
extern char *typeTypeName(Type t);
extern char typeTypeFlag(Type t);
extern char *stringTypeString(Type tp, char *string, int16 atttypmod);
-extern Oid typeidOutfunc(Oid type_id);
-extern Oid typeidTypeRelid(Oid type_id);
-extern Oid typeTypeRelid(Type typ);
-extern Oid typeidTypElem(Oid type_id);
-extern Oid GetArrayElementType(Oid typearray);
-extern Oid typeidInfunc(Oid type_id);
+extern Oid typeidOutfunc(Oid type_id);
+extern Oid typeidTypeRelid(Oid type_id);
+extern Oid typeTypeRelid(Type typ);
+extern Oid typeidTypElem(Oid type_id);
+extern Oid GetArrayElementType(Oid typearray);
+extern Oid typeidInfunc(Oid type_id);
#endif /* PARSE_TYPE_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parser.h,v 1.2 1997/11/26 01:14:17 momjian Exp $
+ * $Id: parser.h,v 1.3 1998/02/26 04:42:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern QueryTreeList *parser(char *str, Oid *typev, int nargs);
#endif /* PARSER_H */
-
#endif
#if defined(__mips__)
-/* # undef HAS_TEST_AND_SET */
+/* # undef HAS_TEST_AND_SET */
#endif
typedef unsigned char slock_t;
#if defined(PPC)
typedef unsigned int slock_t;
+
#elif defined(__alpha__)
typedef long int slock_t;
+
#else
typedef unsigned char slock_t;
+
#endif
#if (__GLIBC__ >= 2)
-# ifdef HAVE_INT_TIMEZONE
-# undef HAVE_INT_TIMEZONE
-# endif
- checked this yet */
+#ifdef HAVE_INT_TIMEZONE
+#undef HAVE_INT_TIMEZONE
+#endif
+
+ /*
+ * checked this yet
+ */
/* #define HAVE_SIGSETJMP 1 */
#endif
#define NEED_I386_TAS_ASM
/***************************************
* Define this if you are compiling with
- * the native UNIXWARE C compiler.
+ * the native UNIXWARE C compiler.
***************************************/
-#define USE_UNIVEL_CC_ASM
+#define USE_UNIVEL_CC_ASM
typedef unsigned char slock_t;
+
/***************************************************************
- * strcasecmp() is in c89, but is not in any include file :-(
+ * strcasecmp() is in c89, but is not in any include file :-(
***************************************************************/
-int strcasecmp(char *, char *);
+int strcasecmp(char *, char *);
#ifndef BIG_ENDIAN
#define BIG_ENDIAN 4321
*
* Copyright (c) 1995, Regents of the University of California
*
- * $Id: postgres.h,v 1.12 1998/02/24 15:27:04 scrappy Exp $
+ * $Id: postgres.h,v 1.13 1998/02/26 04:39:49 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* ---------------
*/
#ifdef CYR_RECODE
-void SetCharSet();
-#endif /* CYR_RECODE */
+void SetCharSet();
+
+#endif /* CYR_RECODE */
#endif /* POSTGRES_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: locks.h,v 1.7 1998/01/24 22:49:55 momjian Exp $
+ * $Id: locks.h,v 1.8 1998/02/26 04:43:03 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/parsenodes.h"
#include "rewrite/prs2lock.h"
-extern List * matchLocks(CmdType event, RuleLock *rulelocks, int varno,
+extern List *
+matchLocks(CmdType event, RuleLock *rulelocks, int varno,
Query *parsetree);
#endif /* LOCKS_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: rewriteManip.h,v 1.6 1998/01/21 04:24:46 momjian Exp $
+ * $Id: rewriteManip.h,v 1.7 1998/02/26 04:43:08 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* RewriteManip.c */
void OffsetVarNodes(Node *node, int offset);
-void ChangeVarNodes(Node *node, int old_varno, int new_varno,
- int sublevels_up);
+void
+ChangeVarNodes(Node *node, int old_varno, int new_varno,
+ int sublevels_up);
void AddQual(Query *parsetree, Node *qual);
void AddNotQual(Query *parsetree, Node *qual);
void FixResdomTypes(List *user_tlist);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: rewriteSupport.h,v 1.7 1998/01/24 22:49:55 momjian Exp $
+ * $Id: rewriteSupport.h,v 1.8 1998/02/26 04:43:13 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern int IsDefinedRewriteRule(char *ruleName);
-extern void prs2_addToRelation(Oid relid, Oid ruleId, CmdType event_type,
+extern void
+prs2_addToRelation(Oid relid, Oid ruleId, CmdType event_type,
AttrNumber attno, bool isInstead, Node *qual,
List *actions);
extern void prs2_deleteFromRelation(Oid relid, Oid ruleId);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: rusagestub.h,v 1.1 1998/02/20 13:10:03 scrappy Exp $
+ * $Id: rusagestub.h,v 1.2 1998/02/26 04:39:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: buf_internals.h,v 1.20 1998/01/24 22:50:00 momjian Exp $
+ * $Id: buf_internals.h,v 1.21 1998/02/26 04:43:21 momjian Exp $
*
* NOTE
* If BUFFERPAGE0 is defined, then 0 will be used as a
extern BufferDesc *LocalBufferDescriptors;
extern int NLocBuffer;
-extern BufferDesc * LocalBufferAlloc(Relation reln, BlockNumber blockNum,
+extern BufferDesc *
+LocalBufferAlloc(Relation reln, BlockNumber blockNum,
bool *foundPtr);
extern int WriteLocalBuffer(Buffer buffer, bool release);
extern int FlushLocalBuffer(Buffer buffer, bool release);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: bufmgr.h,v 1.17 1998/01/24 22:50:03 momjian Exp $
+ * $Id: bufmgr.h,v 1.18 1998/02/26 04:43:22 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* prototypes for functions in bufmgr.c
*/
-extern Buffer RelationGetBufferWithBuffer(Relation relation,
+extern Buffer
+RelationGetBufferWithBuffer(Relation relation,
BlockNumber blockNumber, Buffer buffer);
extern Buffer ReadBuffer(Relation reln, BlockNumber blockNum);
extern int WriteBuffer(Buffer buffer);
extern int WriteNoReleaseBuffer(Buffer buffer);
-extern Buffer ReleaseAndReadBuffer(Buffer buffer, Relation relation,
+extern Buffer
+ReleaseAndReadBuffer(Buffer buffer, Relation relation,
BlockNumber blockNum);
extern void InitBufferPool(IPCKey key);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: bufpage.h,v 1.16 1998/01/24 22:50:05 momjian Exp $
+ * $Id: bufpage.h,v 1.17 1998/02/26 04:43:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* XXX currently all page sizes are "valid" but we only actually
* use BLCKSZ.
*
- * 01/06/98 Now does something useful. darrenk
+ * 01/06/98 Now does something useful. darrenk
*
*/
#define PageSizeIsValid(pageSize) ((pageSize) == BLCKSZ)
*/
extern void PageInit(Page page, Size pageSize, Size specialSize);
-extern OffsetNumber PageAddItem(Page page, Item item, Size size,
+extern OffsetNumber
+PageAddItem(Page page, Item item, Size size,
OffsetNumber offsetNumber, ItemIdFlags flags);
extern Page PageGetTempPage(Page page, Size specialSize);
extern void PageRestoreTempPage(Page tempPage, Page oldPage);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: ipc.h,v 1.23 1998/01/24 22:50:08 momjian Exp $
+ * $Id: ipc.h,v 1.24 1998/02/26 04:43:26 momjian Exp $
*
* NOTES
* This file is very architecture-specific. This stuff should actually
extern void quasi_exitpg(void);
extern int on_exitpg(void (*function) (), caddr_t arg);
-extern IpcSemaphoreId IpcSemaphoreCreate(IpcSemaphoreKey semKey,
+extern IpcSemaphoreId
+IpcSemaphoreCreate(IpcSemaphoreKey semKey,
int semNum, int permission, int semStartValue,
int removeOnExit, int *status);
extern void IpcSemaphoreKill(IpcSemaphoreKey key);
extern void IpcSemaphoreUnlock(IpcSemaphoreId semId, int sem, int lock);
extern int IpcSemaphoreGetCount(IpcSemaphoreId semId, int sem);
extern int IpcSemaphoreGetValue(IpcSemaphoreId semId, int sem);
-extern IpcMemoryId IpcMemoryCreate(IpcMemoryKey memKey, uint32 size,
+extern IpcMemoryId
+IpcMemoryCreate(IpcMemoryKey memKey, uint32 size,
int permission);
extern IpcMemoryId IpcMemoryIdGet(IpcMemoryKey memKey, uint32 size);
extern char *IpcMemoryAttach(IpcMemoryId memId);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: lmgr.h,v 1.9 1998/01/24 22:50:09 momjian Exp $
+ * $Id: lmgr.h,v 1.10 1998/02/26 04:43:27 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void RelationUnsetLockForWrite(Relation relation);
/* used in vaccum.c */
-extern void RelationSetLockForWritePage(Relation relation,
+extern void
+RelationSetLockForWritePage(Relation relation,
ItemPointer itemPointer);
/* used in nbtpage.c, hashpage.c */
-extern void RelationSetSingleWLockPage(Relation relation,
+extern void
+RelationSetSingleWLockPage(Relation relation,
ItemPointer itemPointer);
-extern void RelationUnsetSingleWLockPage(Relation relation,
+extern void
+RelationUnsetSingleWLockPage(Relation relation,
ItemPointer itemPointer);
-extern void RelationSetSingleRLockPage(Relation relation,
+extern void
+RelationSetSingleRLockPage(Relation relation,
ItemPointer itemPointer);
-extern void RelationUnsetSingleRLockPage(Relation relation,
+extern void
+RelationUnsetSingleRLockPage(Relation relation,
ItemPointer itemPointer);
extern void RelationSetRIntentLock(Relation relation);
extern void RelationUnsetRIntentLock(Relation relation);
/* single.c */
extern bool SingleLockReln(LockInfo linfo, LOCKT lockt, int action);
-extern bool SingleLockPage(LockInfo linfo, ItemPointer tidPtr,
+extern bool
+SingleLockPage(LockInfo linfo, ItemPointer tidPtr,
LOCKT lockt, int action);
/* proc.c */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: lock.h,v 1.10 1998/01/27 03:00:43 momjian Exp $
+ * $Id: lock.h,v 1.11 1998/02/26 04:43:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
extern void InitLocks(void);
extern void LockDisable(int status);
-extern LockTableId LockTabInit(char *tabName, MASK *conflictsP, int *prioP,
+extern LockTableId
+LockTabInit(char *tabName, MASK *conflictsP, int *prioP,
int ntypes);
extern bool LockAcquire(LockTableId tableId, LOCKTAG *lockName, LOCKT lockt);
-extern int LockResolveConflicts(LOCKTAB *ltable, LOCK *lock, LOCKT lockt,
+extern int
+LockResolveConflicts(LOCKTAB *ltable, LOCK *lock, LOCKT lockt,
TransactionId xid);
extern bool LockRelease(LockTableId tableId, LOCKTAG *lockName, LOCKT lockt);
extern void GrantLock(LOCK *lock, LOCKT lockt);
extern int LockShmemSize(void);
extern bool LockingDisabled(void);
extern bool DeadLockCheck(SHM_QUEUE *lockQueue, LOCK *findlock, bool skip_check);
+
#ifdef DEADLOCK_DEBUG
extern void DumpLocks(void);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: multilev.h,v 1.6 1998/01/23 19:53:44 scrappy Exp $
+ * $Id: multilev.h,v 1.7 1998/02/26 04:43:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define RELN_LEVEL 0
#define PAGE_LEVEL 1
#define TUPLE_LEVEL 2
-typedef int PG_LOCK_LEVEL;
+typedef int PG_LOCK_LEVEL;
/* multi.c */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: proc.h,v 1.10 1998/01/25 05:15:15 momjian Exp $
+ * $Id: proc.h,v 1.11 1998/02/26 04:43:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* make static in storage/lmgr/proc.c -- jolly */
extern void ProcQueueInit(PROC_QUEUE *queue);
-extern int ProcSleep(PROC_QUEUE *queue, SPINLOCK spinlock, int token,
+extern int
+ProcSleep(PROC_QUEUE *queue, SPINLOCK spinlock, int token,
int prio, LOCK *lock);
extern int ProcLockWakeup(PROC_QUEUE *queue, char *ltable, char *lock);
extern void ProcAddLock(SHM_QUEUE *elem);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/include/storage/s_lock.h,v 1.26 1998/02/13 17:11:55 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/include/storage/s_lock.h,v 1.27 1998/02/26 04:43:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* NEXTSTEP (mach)
* slock_t is defined as a struct mutex.
*/
-#define S_LOCK(lock) mutex_lock(lock)
+#define S_LOCK(lock) mutex_lock(lock)
-#define S_UNLOCK(lock) mutex_unlock(lock)
+#define S_UNLOCK(lock) mutex_unlock(lock)
-#define S_INIT_LOCK(lock) mutex_init(lock)
+#define S_INIT_LOCK(lock) mutex_init(lock)
/* S_LOCK_FREE should return 1 if lock is free; 0 if lock is locked */
/* For Mach, we have to delve inside the entrails of `struct mutex'. Ick! */
-#define S_LOCK_FREE(alock) ((alock)->lock == 0)
+#define S_LOCK_FREE(alock) ((alock)->lock == 0)
#endif /* next */
* assembly from his NECEWS SVR4 port, but we probably ought to retain this
* for the R3000 chips out there.
*/
-#define S_LOCK(lock) do \
+#define S_LOCK(lock) do \
{ \
while (!acquire_lock(lock)) \
; \
#define S_UNLOCK(lock) release_lock(lock)
-#define S_INIT_LOCK(lock) init_lock(lock)
+#define S_INIT_LOCK(lock) init_lock(lock)
/* S_LOCK_FREE should return 1 if lock is free; 0 if lock is locked */
-#define S_LOCK_FREE(lock) (stat_lock(lock) == UNLOCKED)
+#define S_LOCK_FREE(lock) (stat_lock(lock) == UNLOCKED)
#endif /* __sgi */
#if (defined(__alpha__) || defined(__alpha)) && !defined(linux)
-#define S_LOCK(lock) do \
+#define S_LOCK(lock) do \
{ \
while (msem_lock((lock), MSEM_IF_NOWAIT) < 0) \
; \
} while (0)
-#define S_UNLOCK(lock) msem_unlock((lock), 0)
+#define S_UNLOCK(lock) msem_unlock((lock), 0)
-#define S_INIT_LOCK(lock) msem_init((lock), MSEM_UNLOCKED)
+#define S_INIT_LOCK(lock) msem_init((lock), MSEM_UNLOCKED)
-#define S_LOCK_FREE(lock) (!(lock)->msem_state)
+#define S_LOCK_FREE(lock) (!(lock)->msem_state)
#endif /* alpha */
static int tas(slock_t *lock);
-#define S_LOCK(lock) do \
+#define S_LOCK(lock) do \
{ \
while (tas(lock)) \
; \
} while (0)
-#define S_UNLOCK(lock) (*(lock) = 0)
+#define S_UNLOCK(lock) (*(lock) = 0)
-#define S_INIT_LOCK(lock) S_UNLOCK(lock)
+#define S_INIT_LOCK(lock) S_UNLOCK(lock)
#endif /* i86pc_solaris || sparc_solaris */
#if defined(_AIX)
-#define S_LOCK(lock) do \
+#define S_LOCK(lock) do \
{ \
while (cs((int *) (lock), 0, 1)) \
; \
} while (0)
-#define S_UNLOCK(lock) (*(lock) = 0)
+#define S_UNLOCK(lock) (*(lock) = 0)
-#define S_INIT_LOCK(lock) S_UNLOCK(lock)
+#define S_INIT_LOCK(lock) S_UNLOCK(lock)
#endif /* _AIX */
static int tas(slock_t *lock);
-#define S_LOCK(lock) do \
+#define S_LOCK(lock) do \
{ \
while (tas(lock)) \
; \
} while (0)
-#define S_UNLOCK(lock) (*(lock) = clear_lock) /* struct assignment */
+#define S_UNLOCK(lock) (*(lock) = clear_lock) /* struct assignment */
-#define S_INIT_LOCK(lock) S_UNLOCK(lock)
+#define S_INIT_LOCK(lock) S_UNLOCK(lock)
-#define S_LOCK_FREE(lock) ( *(int *) (((long) (lock) + 15) & ~15) != 0)
+#define S_LOCK_FREE(lock) ( *(int *) (((long) (lock) + 15) & ~15) != 0)
#endif /* __hpux */
; \
} while (0)
-#define S_UNLOCK(lock) (*(lock) = 0)
+#define S_UNLOCK(lock) (*(lock) = 0)
-#define S_INIT_LOCK(lock) S_UNLOCK(lock)
+#define S_INIT_LOCK(lock) S_UNLOCK(lock)
static int
tas_dummy()
asm("nop");
}
-#define S_LOCK(addr) do \
+#define S_LOCK(addr) do \
{ \
while (tas(addr)) \
; \
/*
* addr should be as in the above S_LOCK routine
*/
-#define S_UNLOCK(addr) (*(addr) = 0)
+#define S_UNLOCK(addr) (*(addr) = 0)
-#define S_INIT_LOCK(addr) (*(addr) = 0)
+#define S_INIT_LOCK(addr) (*(addr) = 0)
#endif /* NEED_SPARC_TAS_ASM */
#if defined(NEED_I386_TAS_ASM)
#if defined(USE_UNIVEL_CC_ASM)
-asm void S_LOCK(char *lval)
+asm void
+S_LOCK(char *lval)
{
-% lab again;
+ %lab again;
/* Upon entry, %eax will contain the pointer to the lock byte */
- pushl %ebx
- xchgl %eax,%ebx
- movb $-1,%al
+ pushl % ebx
+ xchgl % eax, %ebx
+ movb $ - 1, %al
again:
lock
- xchgb %al,(%ebx)
- cmpb $0,%al
- jne again
- popl %ebx
+ xchgb % al, (%ebx)
+ cmpb $0, %al
+ jne again
+ popl % ebx
}
+
#else
-#define S_LOCK(lock) do \
+#define S_LOCK(lock) do \
{ \
slock_t _res; \
do \
} while (0)
#endif
-#define S_UNLOCK(lock) (*(lock) = 0)
+#define S_UNLOCK(lock) (*(lock) = 0)
-#define S_INIT_LOCK(lock) S_UNLOCK(lock)
+#define S_INIT_LOCK(lock) S_UNLOCK(lock)
#endif /* NEED_I386_TAS_ASM */
#if defined(__alpha__) && defined(linux)
-void S_LOCK(slock_t* lock);
+void S_LOCK(slock_t *lock);
#define S_UNLOCK(lock) { __asm__("mb"); *(lock) = 0; }
-#define S_INIT_LOCK(lock) S_UNLOCK(lock)
+#define S_INIT_LOCK(lock) S_UNLOCK(lock)
#endif /* defined(__alpha__) && defined(linux) */
} while (_res != 0); \
} while (0)
-#define S_UNLOCK(lock) (*(lock) = 0)
+#define S_UNLOCK(lock) (*(lock) = 0)
-#define S_INIT_LOCK(lock) S_UNLOCK(lock)
+#define S_INIT_LOCK(lock) S_UNLOCK(lock)
#endif /* defined(linux) && defined(sparc) */
");
}
-#define S_LOCK(lock) do \
+#define S_LOCK(lock) do \
{ \
while (tas(lock)) \
; \
} while (0)
-#define S_UNLOCK(lock) (*(lock) = 0)
+#define S_UNLOCK(lock) (*(lock) = 0)
-#define S_INIT_LOCK(lock) S_UNLOCK(lock)
+#define S_INIT_LOCK(lock) S_UNLOCK(lock)
#endif /* defined(linux) && defined(PPC) */
-#ifndef S_LOCK_FREE /* for those who have not already defined it */
+#ifndef S_LOCK_FREE /* for those who have not already defined
+ * it */
#define S_LOCK_FREE(lock) ((*lock) == 0)
#endif
#endif /* HAS_TEST_AND_SET */
-#endif /* S_LOCK_H */
+#endif /* S_LOCK_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: shmem.h,v 1.10 1998/01/24 22:50:13 momjian Exp $
+ * $Id: shmem.h,v 1.11 1998/02/26 04:43:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern int InitShmem(unsigned int key, unsigned int size);
extern long *ShmemAlloc(unsigned long size);
extern int ShmemIsValid(unsigned long addr);
-extern HTAB * ShmemInitHash(char *name, long init_size, long max_size,
+extern HTAB *
+ShmemInitHash(char *name, long init_size, long max_size,
HASHCTL *infoP, int hash_flags);
extern bool ShmemPIDLookup(int pid, SHMEM_OFFSET *locationPtr);
extern SHMEM_OFFSET ShmemPIDDestroy(int pid);
-extern long * ShmemInitStruct(char *name, unsigned long size,
+extern long *
+ShmemInitStruct(char *name, unsigned long size,
bool *foundPtr);
extern bool TransactionIdIsInProgress(TransactionId xid);
extern void SHMQueueElemInit(SHM_QUEUE *queue);
extern void SHMQueueDelete(SHM_QUEUE *queue);
extern void SHMQueueInsertTL(SHM_QUEUE *queue, SHM_QUEUE *elem);
-extern void SHMQueueFirst(SHM_QUEUE *queue, Pointer *nextPtrPtr,
+extern void
+SHMQueueFirst(SHM_QUEUE *queue, Pointer *nextPtrPtr,
SHM_QUEUE *nextQueue);
extern bool SHMQueueEmpty(SHM_QUEUE *queue);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: sinval.h,v 1.7 1998/01/24 22:50:15 momjian Exp $
+ * $Id: sinval.h,v 1.8 1998/02/26 04:43:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void CreateSharedInvalidationState(IPCKey key);
extern void AttachSharedInvalidationState(IPCKey key);
extern void InitSharedInvalidationState(void);
-extern void RegisterSharedInvalid(int cacheId, Index hashIndex,
+extern void
+RegisterSharedInvalid(int cacheId, Index hashIndex,
ItemPointer pointer);
extern void InvalidateSharedInvalid(void (*invalFunction) (),
void (*resetFunction) ());
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: sinvaladt.h,v 1.7 1998/01/24 22:50:17 momjian Exp $
+ * $Id: sinvaladt.h,v 1.8 1998/02/26 04:43:35 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern bool SISetDataEntry(SISeg *segP, SharedInvalidData *data);
extern void SISetProcStateInvalid(SISeg *segP);
extern bool SIDelDataEntry(SISeg *segP);
-extern void SIReadEntryData(SISeg *segP, int backendId,
+extern void
+SIReadEntryData(SISeg *segP, int backendId,
void (*invalFunction) (), void (*resetFunction) ());
extern void SIDelExpiredDataEntries(SISeg *segP);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: smgr.h,v 1.10 1998/01/24 22:50:18 momjian Exp $
+ * $Id: smgr.h,v 1.11 1998/02/26 04:43:36 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern int smgrextend(int16 which, Relation reln, char *buffer);
extern int smgropen(int16 which, Relation reln);
extern int smgrclose(int16 which, Relation reln);
-extern int smgrread(int16 which, Relation reln, BlockNumber blocknum,
+extern int
+smgrread(int16 which, Relation reln, BlockNumber blocknum,
char *buffer);
-extern int smgrwrite(int16 which, Relation reln, BlockNumber blocknum,
+extern int
+smgrwrite(int16 which, Relation reln, BlockNumber blocknum,
char *buffer);
-extern int smgrflush(int16 which, Relation reln, BlockNumber blocknum,
+extern int
+smgrflush(int16 which, Relation reln, BlockNumber blocknum,
char *buffer);
-extern int smgrblindwrt(int16 which, char *dbname, char *relname, Oid dbid,
+extern int
+smgrblindwrt(int16 which, char *dbname, char *relname, Oid dbid,
Oid relid, BlockNumber blkno, char *buffer);
extern int smgrnblocks(int16 which, Relation reln);
extern int smgrtruncate(int16 which, Relation reln, int nblocks);
extern int mdread(Relation reln, BlockNumber blocknum, char *buffer);
extern int mdwrite(Relation reln, BlockNumber blocknum, char *buffer);
extern int mdflush(Relation reln, BlockNumber blocknum, char *buffer);
-extern int mdblindwrt(char *dbstr, char *relstr, Oid dbid, Oid relid,
+extern int
+mdblindwrt(char *dbstr, char *relstr, Oid dbid, Oid relid,
BlockNumber blkno, char *buffer);
extern int mdnblocks(Relation reln);
extern int mdtruncate(Relation reln, int nblocks);
extern int mmread(Relation reln, BlockNumber blocknum, char *buffer);
extern int mmwrite(Relation reln, BlockNumber blocknum, char *buffer);
extern int mmflush(Relation reln, BlockNumber blocknum, char *buffer);
-extern int mmblindwrt(char *dbstr, char *relstr, Oid dbid, Oid relid,
+extern int
+mmblindwrt(char *dbstr, char *relstr, Oid dbid, Oid relid,
BlockNumber blkno, char *buffer);
extern int mmnblocks(Relation reln);
extern int mmcommit(void);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: dest.h,v 1.12 1998/01/24 22:50:22 momjian Exp $
+ * $Id: dest.h,v 1.13 1998/02/26 04:43:39 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void SendCopyBegin(void);
extern void ReceiveCopyBegin(void);
extern void NullCommand(CommandDest dest);
-extern void BeginCommand(char *pname, int operation, TupleDesc attinfo,
+extern void
+BeginCommand(char *pname, int operation, TupleDesc attinfo,
bool isIntoRel, bool isIntoPortal, char *tag,
CommandDest dest);
extern void UpdateCommandInfo(int operation, Oid lastoid, uint32 tuples);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pquery.h,v 1.8 1998/01/24 22:50:24 momjian Exp $
+ * $Id: pquery.h,v 1.9 1998/02/26 04:43:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern EState *CreateExecutorState(void);
-extern void ProcessPortal(char *portalName, Query *parseTree,
+extern void
+ProcessPortal(char *portalName, Query *parseTree,
Plan *plan, EState *state, TupleDesc attinfo,
CommandDest dest);
-extern void ProcessQuery(Query *parsetree, Plan *plan, char *argv[],
+extern void
+ProcessQuery(Query *parsetree, Plan *plan, char *argv[],
Oid *typev, int nargs, CommandDest dest);
#endif /* pqueryIncluded */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: tcopprot.h,v 1.10 1998/01/24 22:50:26 momjian Exp $
+ * $Id: tcopprot.h,v 1.11 1998/02/26 04:43:41 momjian Exp $
*
* OLD COMMENTS
* This file was created so that other c files could get the two
#ifndef BOOTSTRAP_INCLUDE
-extern List * pg_parse_and_plan(char *query_string, Oid *typev, int nargs,
- QueryTreeList **queryListP, CommandDest dest);
+extern List *
+pg_parse_and_plan(char *query_string, Oid *typev, int nargs,
+ QueryTreeList **queryListP, CommandDest dest);
extern void pg_exec_query(char *query_string, char **argv, Oid *typev, int nargs);
-extern void pg_exec_query_dest(char *query_string, char **argv, Oid *typev,
- int nargs, CommandDest dest);
+extern void
+pg_exec_query_dest(char *query_string, char **argv, Oid *typev,
+ int nargs, CommandDest dest);
#endif /* BOOTSTRAP_HEADER */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: acl.h,v 1.16 1998/02/25 13:09:49 scrappy Exp $
+ * $Id: acl.h,v 1.17 1998/02/26 04:43:43 momjian Exp $
*
* NOTES
* For backward-compatability purposes we have to allow there
extern char *aclmakepriv(char *old_privlist, char new_priv);
extern char *aclmakeuser(char *user_type, char *user);
-extern ChangeACLStmt * makeAclStmt(char *privs, List *rel_list, char *grantee,
+extern ChangeACLStmt *
+makeAclStmt(char *privs, List *rel_list, char *grantee,
char grant_or_revoke);
/*
extern int32 pg_aclcheck(char *relname, char *usename, AclMode mode);
extern int32 pg_ownercheck(char *usename, char *value, int cacheid);
-extern int32 pg_func_ownercheck(char *usename, char *funcname,
+extern int32
+pg_func_ownercheck(char *usename, char *funcname,
int nargs, Oid *arglist);
-extern int32 pg_aggr_ownercheck(char *usename, char *aggname,
+extern int32
+pg_aggr_ownercheck(char *usename, char *aggname,
Oid basetypeID);
#endif /* ACL_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: array.h,v 1.10 1998/02/13 19:46:22 momjian Exp $
+ * $Id: array.h,v 1.11 1998/02/26 04:43:45 momjian Exp $
*
* NOTES
* XXX the data array should be LONGALIGN'd -- notice that the array
extern char *array_in(char *string, Oid element_type, int16 typmod);
extern char *array_out(ArrayType *v, Oid element_type);
extern char *array_dims(ArrayType *v, bool *isNull);
-extern Datum array_ref(ArrayType *array, int n, int indx[], int reftype,
+extern Datum
+array_ref(ArrayType *array, int n, int indx[], int reftype,
int elmlen, int arraylen, bool *isNull);
-extern Datum array_clip(ArrayType *array, int n, int upperIndx[],
+extern Datum
+array_clip(ArrayType *array, int n, int upperIndx[],
int lowerIndx[], int reftype, int len, bool *isNull);
-extern char * array_set(ArrayType *array, int n, int indx[], char *dataPtr,
+extern char *
+array_set(ArrayType *array, int n, int indx[], char *dataPtr,
int reftype, int elmlen, int arraylen, bool *isNull);
-extern char * array_assgn(ArrayType *array, int n, int upperIndx[],
+extern char *
+array_assgn(ArrayType *array, int n, int upperIndx[],
int lowerIndx[], ArrayType *newArr, int reftype,
int len, bool *isNull);
extern int array_eq(ArrayType *array1, ArrayType *array2);
-extern int _LOtransfer(char **destfd, int size, int nitems, char **srcfd,
+extern int
+_LOtransfer(char **destfd, int size, int nitems, char **srcfd,
int isSrcLO, int isDestLO);
extern char *_array_newLO(int *fd, int flag);
/*
* prototypes for functions defined in chunk.c
*/
-extern char * _ChunkArray(int fd, FILE *afd, int ndim, int dim[], int baseSize,
+extern char *
+_ChunkArray(int fd, FILE *afd, int ndim, int dim[], int baseSize,
int *nbytes, char *chunkfile);
-extern int _ReadChunkArray(int st[], int endp[], int bsize, int fp,
+extern int
+_ReadChunkArray(int st[], int endp[], int bsize, int fp,
char *destfp, ArrayType *array, int isDestLO, bool *isNull);
-extern struct varlena * _ReadChunkArray1El(int st[], int bsize, int fp,
+extern struct varlena *
+_ReadChunkArray1El(int st[], int bsize, int fp,
ArrayType *array, bool *isNull);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: builtins.h,v 1.36 1998/02/10 16:04:36 momjian Exp $
+ * $Id: builtins.h,v 1.37 1998/02/26 04:43:48 momjian Exp $
*
* NOTES
* This should normally only be included by fmgr.h.
extern bool oideqint4(Oid arg1, int32 arg2);
extern bool int4eqoid(int32 arg1, Oid arg2);
extern text *oid_text(Oid arg1);
-extern Oid text_oid(text *arg1);
+extern Oid text_oid(text *arg1);
/* regexp.c */
extern bool char2regexeq(uint16 arg1, struct varlena * p);
extern text *text_substr(text *string, int32 m, int32 n);
extern struct varlena *byteain(char *inputText);
-extern char *byteaout(struct varlena *vlena);
+extern char *byteaout(struct varlena * vlena);
extern int32 byteaGetSize(struct varlena * v);
extern int32 byteaGetByte(struct varlena * v, int32 n);
extern int32 byteaGetBit(struct varlena * v, int32 n);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: catcache.h,v 1.10 1998/02/23 17:44:22 scrappy Exp $
+ * $Id: catcache.h,v 1.11 1998/02/26 04:43:53 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern struct catcache *Caches;
extern GlobalMemory CacheCxt;
-extern void CatalogCacheIdInvalidate(int cacheId, Index hashIndex,
+extern void
+CatalogCacheIdInvalidate(int cacheId, Index hashIndex,
ItemPointer pointer);
extern void ResetSystemCache(void);
extern void SystemCacheRelationFlushed(Oid relId);
-extern CatCache * InitSysCache(char *relname, char *indname, int id, int nkeys,
+extern CatCache *
+InitSysCache(char *relname, char *indname, int id, int nkeys,
int key[], HeapTuple (*iScanfuncP) ());
-extern HeapTuple SearchSysCache(struct catcache * cache, Datum v1, Datum v2,
+extern HeapTuple
+SearchSysCache(struct catcache * cache, Datum v1, Datum v2,
Datum v3, Datum v4);
-extern void RelationInvalidateCatalogCacheTuple(Relation relation,
+extern void
+RelationInvalidateCatalogCacheTuple(Relation relation,
HeapTuple tuple, void (*function) ());
#endif /* CATCACHE_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: datum.h,v 1.6 1998/01/24 22:50:36 momjian Exp $
+ * $Id: datum.h,v 1.7 1998/02/26 04:43:57 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* return true if thwo datums are equal, false otherwise.
* XXX : See comments in the code for restrictions!
*/
-extern bool datumIsEqual(Datum value1, Datum value2, Oid type,
+extern bool
+datumIsEqual(Datum value1, Datum value2, Oid type,
bool byVal, Size len);
#endif /* DATUM_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: dt.h,v 1.27 1998/02/13 17:12:07 scrappy Exp $
+ * $Id: dt.h,v 1.28 1998/02/26 04:43:58 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* so actually restrict them to within [0,31] for now.
* - thomas 97/06/19
* Not all of these fields are used for masks in DecodeDateDelta
- * so allow some larger than 31. - thomas 1997-11-17
+ * so allow some larger than 31. - thomas 1997-11-17
*/
#define DTK_NUMBER 0
extern bool datetime_ge(DateTime *dt1, DateTime *dt2);
extern bool datetime_gt(DateTime *dt1, DateTime *dt2);
extern bool datetime_finite(DateTime *datetime);
-extern int datetime_cmp(DateTime *dt1, DateTime *dt2);
+extern int datetime_cmp(DateTime *dt1, DateTime *dt2);
extern DateTime *datetime_smaller(DateTime *dt1, DateTime *dt2);
extern DateTime *datetime_larger(DateTime *dt1, DateTime *dt2);
extern bool timespan_ge(TimeSpan *span1, TimeSpan *span2);
extern bool timespan_gt(TimeSpan *span1, TimeSpan *span2);
extern bool timespan_finite(TimeSpan *span);
-extern int timespan_cmp(TimeSpan *span1, TimeSpan *span2);
+extern int timespan_cmp(TimeSpan *span1, TimeSpan *span2);
extern TimeSpan *timespan_smaller(TimeSpan *span1, TimeSpan *span2);
extern TimeSpan *timespan_larger(TimeSpan *span1, TimeSpan *span2);
extern void GetCurrentTime(struct tm * tm);
extern DateTime SetDateTime(DateTime datetime);
-extern int tm2datetime(struct tm * tm, double fsec, int *tzp, DateTime *dt);
-extern int datetime2tm(DateTime dt, int *tzp, struct tm * tm, double *fsec, char **tzn);
-extern int timespan2tm(TimeSpan span, struct tm * tm, float8 *fsec);
-extern int tm2timespan(struct tm * tm, double fsec, TimeSpan *span);
+extern int tm2datetime(struct tm * tm, double fsec, int *tzp, DateTime *dt);
+extern int datetime2tm(DateTime dt, int *tzp, struct tm * tm, double *fsec, char **tzn);
+extern int timespan2tm(TimeSpan span, struct tm * tm, float8 *fsec);
+extern int tm2timespan(struct tm * tm, double fsec, TimeSpan *span);
extern void j2date(int jd, int *year, int *month, int *day);
-extern int date2j(int year, int month, int day);
+extern int date2j(int year, int month, int day);
extern double time2t(const int hour, const int min, const double sec);
-extern int ParseDateTime(char *timestr, char *lowstr,
+extern int
+ParseDateTime(char *timestr, char *lowstr,
char *field[], int ftype[], int maxfields, int *numfields);
-extern int DecodeDateTime(char *field[], int ftype[],
+extern int
+DecodeDateTime(char *field[], int ftype[],
int nf, int *dtype, struct tm * tm, double *fsec, int *tzp);
-extern int DecodeTimeOnly(char *field[], int ftype[], int nf,
+extern int
+DecodeTimeOnly(char *field[], int ftype[], int nf,
int *dtype, struct tm * tm, double *fsec);
-extern int DecodeDateDelta(char *field[], int ftype[],
+extern int
+DecodeDateDelta(char *field[], int ftype[],
int nf, int *dtype, struct tm * tm, double *fsec);
-extern int EncodeDateOnly(struct tm * tm, int style, char *str);
-extern int EncodeTimeOnly(struct tm * tm, double fsec, int style, char *str);
-extern int EncodeDateTime(struct tm * tm, double fsec, int *tzp, char **tzn, int style, char *str);
-extern int EncodeTimeSpan(struct tm * tm, double fsec, int style, char *str);
+extern int EncodeDateOnly(struct tm * tm, int style, char *str);
+extern int EncodeTimeOnly(struct tm * tm, double fsec, int style, char *str);
+extern int EncodeDateTime(struct tm * tm, double fsec, int *tzp, char **tzn, int style, char *str);
+extern int EncodeTimeSpan(struct tm * tm, double fsec, int style, char *str);
-#endif /* DT_H */
+#endif /* DT_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: exc.h,v 1.11 1998/01/24 22:50:41 momjian Exp $
+ * $Id: exc.h,v 1.12 1998/02/26 04:43:59 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* prototypes for functions in exc.c
*/
extern void EnableExceptionHandling(bool on);
-extern void ExcRaise(Exception *excP,
+extern void
+ExcRaise(Exception *excP,
ExcDetail detail,
ExcData data,
ExcMessage message);
/*
* prototypes for functions in excabort.c
*/
-extern void ExcAbort(const Exception *excP, ExcDetail detail, ExcData data,
+extern void
+ExcAbort(const Exception *excP, ExcDetail detail, ExcData data,
ExcMessage message);
#endif /* EXC_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: geo_decls.h,v 1.18 1998/02/03 16:01:06 thomas Exp $
+ * $Id: geo_decls.h,v 1.19 1998/02/26 04:44:00 momjian Exp $
*
* NOTE
* These routines do *not* use the float types from adt/.
extern double circle_dt(CIRCLE *circle1, CIRCLE *circle2);
/* geo_selfuncs.c */
-extern float64 areasel(Oid opid, Oid relid, AttrNumber attno,
+extern float64
+areasel(Oid opid, Oid relid, AttrNumber attno,
char *value, int32 flag);
-extern float64 areajoinsel(Oid opid, Oid relid, AttrNumber attno,
+extern float64
+areajoinsel(Oid opid, Oid relid, AttrNumber attno,
char *value, int32 flag);
#endif /* GEO_DECLS_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: hsearch.h,v 1.7 1998/01/24 22:50:45 momjian Exp $
+ * $Id: hsearch.h,v 1.8 1998/02/26 04:44:01 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern HTAB *hash_create(int nelem, HASHCTL *info, int flags);
extern void hash_destroy(HTAB *hashp);
extern void hash_stats(char *where, HTAB *hashp);
-extern long * hash_search(HTAB *hashp, char *keyPtr, HASHACTION action,
+extern long *
+hash_search(HTAB *hashp, char *keyPtr, HASHACTION action,
bool *foundPtr);
extern long *hash_seq(HTAB *hashp);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: lselect.h,v 1.9 1998/01/24 22:50:46 momjian Exp $
+ * $Id: lselect.h,v 1.10 1998/02/26 04:44:06 momjian Exp $
*
*-------------------------------------------------------------------------
*/
} LeftistContextData;
typedef LeftistContextData *LeftistContext;
-extern struct leftist * lmerge(struct leftist * pt, struct leftist * qt,
+extern struct leftist *
+lmerge(struct leftist * pt, struct leftist * qt,
LeftistContext context);
-extern HeapTuple gettuple(struct leftist ** treep, short *devnum,
+extern HeapTuple
+gettuple(struct leftist ** treep, short *devnum,
LeftistContext context);
-extern void puttuple(struct leftist ** treep, HeapTuple newtuple, short devnum,
+extern void
+puttuple(struct leftist ** treep, HeapTuple newtuple, short devnum,
LeftistContext context);
extern int tuplecmp(HeapTuple ltup, HeapTuple rtup, LeftistContext context);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: lsyscache.h,v 1.9 1998/02/10 16:04:38 momjian Exp $
+ * $Id: lsyscache.h,v 1.10 1998/02/26 04:44:07 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern int16 get_atttypmod(Oid relid, AttrNumber attnum);
extern RegProcedure get_opcode(Oid opid);
extern char *get_opname(Oid opid);
-extern bool op_mergesortable(Oid opid, Oid ltype, Oid rtype,
+extern bool
+op_mergesortable(Oid opid, Oid ltype, Oid rtype,
Oid *leftOp, Oid *rightOp);
extern Oid op_hashjoinable(Oid opid, Oid ltype, Oid rtype);
extern Oid get_commutator(Oid opid);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: mcxt.h,v 1.9 1998/01/24 22:50:50 momjian Exp $
+ * $Id: mcxt.h,v 1.10 1998/02/26 04:44:07 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
extern void EnableMemoryContext(bool on);
extern Pointer MemoryContextAlloc(MemoryContext context, Size size);
-extern Pointer MemoryContextRealloc(MemoryContext context,
+extern Pointer
+MemoryContextRealloc(MemoryContext context,
Pointer pointer,
Size size);
extern void MemoryContextFree(MemoryContext context, Pointer pointer);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: memutils.h,v 1.13 1998/01/24 22:50:51 momjian Exp $
+ * $Id: memutils.h,v 1.14 1998/02/26 04:44:08 momjian Exp $
*
* NOTES
* some of the information in this file will be moved to
(((long)(LEN) + (sizeof (double) - 1)) & ~(sizeof (double) -1))
#else
#define DOUBLEALIGN(LEN) INTALIGN(LEN)
-#define MAXALIGN(LEN) INTALIGN(LEN)
+#define MAXALIGN(LEN) INTALIGN(LEN)
#endif
/*****************************************************************************
extern bool AllocSetContains(AllocSet set, AllocPointer pointer);
extern AllocPointer AllocSetAlloc(AllocSet set, Size size);
extern void AllocSetFree(AllocSet set, AllocPointer pointer);
-extern AllocPointer AllocSetRealloc(AllocSet set, AllocPointer pointer,
+extern AllocPointer
+AllocSetRealloc(AllocSet set, AllocPointer pointer,
Size size);
extern void AllocSetDump(AllocSet set);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: portal.h,v 1.8 1998/01/24 22:50:52 momjian Exp $
+ * $Id: portal.h,v 1.9 1998/02/26 04:44:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void EnablePortalManager(bool on);
extern Portal GetPortalByName(char *name);
extern Portal BlankPortalAssignName(char *name);
-extern void PortalSetQuery(Portal portal, QueryDesc *queryDesc,
+extern void
+PortalSetQuery(Portal portal, QueryDesc *queryDesc,
TupleDesc attinfo, EState *state,
void (*cleanup) (Portal portal));
extern QueryDesc *PortalGetQueryDesc(Portal portal);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: rel.h,v 1.16 1998/01/24 22:50:54 momjian Exp $
+ * $Id: rel.h,v 1.17 1998/02/26 04:44:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern IndexStrategy RelationGetIndexStrategy(Relation relation);
-extern void RelationSetIndexSupport(Relation relation, IndexStrategy strategy,
+extern void
+RelationSetIndexSupport(Relation relation, IndexStrategy strategy,
RegProcedure *support);
#endif /* REL_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: rel2.h,v 1.5 1998/01/24 22:50:55 momjian Exp $
+ * $Id: rel2.h,v 1.6 1998/02/26 04:44:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern IndexStrategy RelationGetIndexStrategy(Relation relation);
-extern void RelationSetIndexSupport(Relation relation, IndexStrategy strategy,
+extern void
+RelationSetIndexSupport(Relation relation, IndexStrategy strategy,
RegProcedure *support);
#endif /* TMP_REL2_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: syscache.h,v 1.9 1998/01/24 22:50:57 momjian Exp $
+ * $Id: syscache.h,v 1.10 1998/02/26 04:44:11 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void zerocaches(void);
extern void InitCatalogCache(void);
-extern HeapTuple SearchSysCacheTuple(int cacheId, Datum key1, Datum key2,
+extern HeapTuple
+SearchSysCacheTuple(int cacheId, Datum key1, Datum key2,
Datum key3, Datum key4);
-extern int32 SearchSysCacheStruct(int cacheId, char *returnStruct,
+extern int32
+SearchSysCacheStruct(int cacheId, char *returnStruct,
Datum key1, Datum key2, Datum key3, Datum key4);
-extern void * SearchSysCacheGetAttribute(int cacheId,
+extern void *
+SearchSysCacheGetAttribute(int cacheId,
AttrNumber attributeNumber,
Datum key1,
Datum key2,
#include
-void ECPGdebug(int, FILE *);
-bool ECPGconnect(const char * dbname);
-bool ECPGdo(int, char *, ...);
-bool ECPGcommit(int);
-bool ECPGrollback(int);
-bool ECPGfinish();
-bool ECPGstatus();
+void ECPGdebug(int, FILE *);
+bool ECPGconnect(const char *dbname);
+bool ECPGdo(int, char *,...);
+bool ECPGcommit(int);
+bool ECPGrollback(int);
+bool ECPGfinish();
+bool ECPGstatus();
-void ECPGlog(const char * format, ...);
+void ECPGlog(const char *format,...);
#ifdef LIBPQ_FE_H
-bool ECPGsetdb(PGconn *);
+bool ECPGsetdb(PGconn *);
+
#endif
/* Here are some methods used by the lib. */
/* Returns a pointer to a string containing a simple type name. */
-const char * ECPGtype_name(enum ECPGttype);
+const char *ECPGtype_name(enum ECPGttype);
/* A generic varchar type. */
-struct ECPGgeneric_varchar {
- int len;
- char arr[1];
+struct ECPGgeneric_varchar
+{
+ int len;
+ char arr[1];
};
/* print an error message */
-void sqlprint(void);
+void sqlprint(void);
/* define this for simplicity as well as compatibility */
-#define SQLCODE sqlca.sqlcode
+#define SQLCODE sqlca.sqlcode
*/
#include
-enum ECPGttype {
- ECPGt_char = 1, ECPGt_unsigned_char, ECPGt_short, ECPGt_unsigned_short,
- ECPGt_int, ECPGt_unsigned_int, ECPGt_long, ECPGt_unsigned_long,
- ECPGt_bool,
- ECPGt_float, ECPGt_double,
- ECPGt_varchar, ECPGt_varchar2,
- ECPGt_array,
- ECPGt_record,
- ECPGt_EOIT, /* End of insert types. */
- ECPGt_EORT /* End of result types. */
+enum ECPGttype
+{
+ ECPGt_char = 1, ECPGt_unsigned_char, ECPGt_short, ECPGt_unsigned_short,
+ ECPGt_int, ECPGt_unsigned_int, ECPGt_long, ECPGt_unsigned_long,
+ ECPGt_bool,
+ ECPGt_float, ECPGt_double,
+ ECPGt_varchar, ECPGt_varchar2,
+ ECPGt_array,
+ ECPGt_record,
+ ECPGt_EOIT, /* End of insert types. */
+ ECPGt_EORT /* End of result types. */
};
#define IS_SIMPLE_TYPE(type) ((type) >= ECPGt_char && (type) <= ECPGt_varchar2)
#ifndef POSTGRES_SQLCA_H
#define POSTGRES_SQLCA_H
-struct sqlca {
- int sqlcode;
- struct {
- int sqlerrml;
- char sqlerrmc[1000];
- } sqlerrm;
-} sqlca;
+struct sqlca
+{
+ int sqlcode;
+ struct
+ {
+ int sqlerrml;
+ char sqlerrmc[1000];
+ } sqlerrm;
+} sqlca;
+
#endif
in the argument quoted with \.
*/
static
-char *
+char *
quote_postgres(char *arg)
{
char *res = (char *) malloc(2 * strlen(arg) + 1);
type = va_arg(ap, enum ECPGttype);
/*
- * Now, if the type is one of the fill in types then we take the argument
- * and enter that in the string at the first %s position. Then if there
- * are any more fill in types we fill in at the next and so on.
+ * Now, if the type is one of the fill in types then we take the
+ * argument and enter that in the string at the first %s position.
+ * Then if there are any more fill in types we fill in at the next and
+ * so on.
*/
while (type != ECPGt_EOIT)
{
char *p;
char buff[20];
- /* Some special treatment is needed for records since we want their
- contents to arrive in a comma-separated list on insert (I think). */
+ /*
+ * Some special treatment is needed for records since we want
+ * their contents to arrive in a comma-separated list on insert (I
+ * think).
+ */
value = va_arg(ap, void *);
varcharsize = va_arg(ap, long);
case ECPGt_unsigned_char:
{
/* set slen to string length if type is char * */
- int slen = (varcharsize == 0) ? strlen((char *) value) : varcharsize;
-
+ int slen = (varcharsize == 0) ? strlen((char *) value) : varcharsize;
+
newcopy = (char *) malloc(slen + 1);
strncpy(newcopy, (char *) value, slen);
newcopy[slen] = '\0';
break;
}
- /* Now tobeinserted points to an area that is to be inserted at
- the first %s
+ /*
+ * Now tobeinserted points to an area that is to be inserted at
+ * the first %s
*/
newcopy = (char *) malloc(strlen(copiedquery)
+ strlen(tobeinserted)
strcpy(newcopy, copiedquery);
if ((p = strstr(newcopy, ";;")) == NULL)
{
- /* We have an argument but we dont have the matched up string
- in the string
+
+ /*
+ * We have an argument but we dont have the matched up string
+ * in the string
*/
register_error(-1, "Too many arguments line %d.", lineno);
return false;
else
{
strcpy(p, tobeinserted);
- /* The strange thing in the second argument is the rest of the
- string from the old string */
+
+ /*
+ * The strange thing in the second argument is the rest of the
+ * string from the old string
+ */
strcat(newcopy,
copiedquery
+ (p - newcopy)
+ 2 /* Length of ;; */ );
}
- /* Now everything is safely copied to the newcopy. Lets free the
- oldcopy and let the copiedquery get the value from the newcopy.
+ /*
+ * Now everything is safely copied to the newcopy. Lets free the
+ * oldcopy and let the copiedquery get the value from the newcopy.
*/
if (mallocedval != NULL)
{
x;
case PGRES_TUPLES_OK:
- /* XXX Cheap Hack. For now, we see only the last group
- * of tuples. This is clearly not the right
- * way to do things !!
+
+ /*
+ * XXX Cheap Hack. For now, we see only the last group of
+ * tuples. This is clearly not the right way to do things
+ * !!
*/
m = PQnfields(results);
char *pval = PQgetvalue(results, 0, x);
- /*long int * res_int;
- char ** res_charstar;
- char * res_char;
- int res_len; */
+ /*
+ * long int * res_int; char ** res_charstar; char *
+ * res_char; int res_len;
+ */
char *scan_length;
ECPGlog("ECPGdo line %d: RESULT: %s\n", lineno, pval ? pval : "");
strncpy((char *) value, pval, varcharsize);
}
break;
-
+
case ECPGt_varchar:
{
struct ECPGgeneric_varchar *var =
}
/* print out an error message */
-void sqlprint(void)
+void
+sqlprint(void)
{
sqlca.sqlerrm.sqlerrmc[sqlca.sqlerrm.sqlerrml] = '\0';
- printf ("sql error %s\n", sqlca.sqlerrm.sqlerrmc);
+ printf("sql error %s\n", sqlca.sqlerrm.sqlerrmc);
}
const char *
ECPGtype_name(enum ECPGttype typ)
{
- switch (typ)
- {
- case ECPGt_char: return "char";
- case ECPGt_unsigned_char: return "unsigned char";
- case ECPGt_short: return "short";
- case ECPGt_unsigned_short: return "unsigned short";
- case ECPGt_int: return "int";
- case ECPGt_unsigned_int: return "unsigned int";
- case ECPGt_long: return "long";
- case ECPGt_unsigned_long: return "unsigned long";
- case ECPGt_float: return "float";
- case ECPGt_double: return "double";
- case ECPGt_bool: return "bool";
- default:
- abort();
- }
+ switch (typ)
+ {
+ case ECPGt_char:return "char";
+ case ECPGt_unsigned_char:
+ return "unsigned char";
+ case ECPGt_short:
+ return "short";
+ case ECPGt_unsigned_short:
+ return "unsigned short";
+ case ECPGt_int:
+ return "int";
+ case ECPGt_unsigned_int:
+ return "unsigned int";
+ case ECPGt_long:
+ return "long";
+ case ECPGt_unsigned_long:
+ return "unsigned long";
+ case ECPGt_float:
+ return "float";
+ case ECPGt_double:
+ return "double";
+ case ECPGt_bool:
+ return "bool";
+ default:
+ abort();
+ }
}
#include
#if HAVE_GETOPT_H
-# include
+#include
#else
-# include
+#include
#endif
#include
#if defined(HAVE_STRING_H)
-# include
+#include
#else
-# include
+#include
#endif
#include "extern.h"
int
main(int argc, char *const argv[])
{
- char c, out_option = 0;
+ char c,
+ out_option = 0;
int fnr;
while ((c = getopt(argc, argv, "vdo:")) != EOF)
}
}
- if (optind >= argc) /* no files specified */
+ if (optind >= argc) /* no files specified */
usage(argv[0]);
else
{
/* after the options there must not be anything but filenames */
for (fnr = optind; fnr < argc; fnr++)
{
- char *filename, *ptr2ext;
- int ext = 0;
+ char *filename,
+ *ptr2ext;
+ int ext = 0;
filename = mm_alloc(strlen(argv[fnr]) + 4);
ptr2ext = strrchr(filename, '.');
/* no extension or extension not equal .pgc */
if (ptr2ext == NULL || strcmp(ptr2ext, ".pgc") != 0)
- {
+ {
if (ptr2ext == NULL)
- ext = 1; /* we need this information a while later */
+ ext = 1; /* we need this information a while later */
ptr2ext = filename + strlen(filename);
ptr2ext[0] = '.';
}
ptr2ext[1] = 'c';
ptr2ext[2] = '\0';
- if (out_option == 0) /* calculate the output name */
+ if (out_option == 0)/* calculate the output name */
{
yyout = fopen(filename, "w");
if (yyout == NULL)
}
}
- if (ext == 1)
+ if (ext == 1)
{
/* no extension => add .pgc */
ptr2ext = strrchr(filename, '.');
/* variables */
-extern int debugging, braces_open;
-extern char * yytext;
-extern int yylineno, yyleng;
-extern FILE *yyin, *yyout;
+extern int debugging,
+ braces_open;
+extern char *yytext;
+extern int yylineno,
+ yyleng;
+extern FILE *yyin,
+ *yyout;
/* functions */
extern void lex_init(void);
-extern char * input_filename;
-extern int yyparse(void);
+extern char *input_filename;
+extern int yyparse(void);
extern void *mm_alloc(size_t), *mm_realloc(void *, size_t);
#include "type.h"
/* malloc + error check */
-void *mm_alloc(size_t size)
+void *
+mm_alloc(size_t size)
{
- void *ptr = malloc(size);
+ void *ptr = malloc(size);
- if (ptr == NULL)
- {
- fprintf(stderr, "Out of memory\n");
- exit(1);
- }
+ if (ptr == NULL)
+ {
+ fprintf(stderr, "Out of memory\n");
+ exit(1);
+ }
- return (ptr);
+ return (ptr);
}
/* realloc + error check */
-void *mm_realloc(void * ptr, size_t size)
+void *
+mm_realloc(void *ptr, size_t size)
{
- ptr = realloc(ptr, size);
+ ptr = realloc(ptr, size);
- if (ptr == NULL)
- {
- fprintf(stderr, "Out of memory\n");
- exit(1);
- }
+ if (ptr == NULL)
+ {
+ fprintf(stderr, "Out of memory\n");
+ exit(1);
+ }
- return (ptr);
+ return (ptr);
}
/* Constructors
/* The NAME argument is copied. The type argument is preserved as a pointer. */
struct ECPGrecord_member *
-ECPGmake_record_member(char *name, struct ECPGtype *type, struct ECPGrecord_member **start)
+ECPGmake_record_member(char *name, struct ECPGtype * type, struct ECPGrecord_member ** start)
{
- struct ECPGrecord_member *ptr, *ne =
- (struct ECPGrecord_member *) mm_alloc(sizeof(struct ECPGrecord_member));
+ struct ECPGrecord_member *ptr,
+ *ne =
+ (struct ECPGrecord_member *) mm_alloc(sizeof(struct ECPGrecord_member));
- ne->name = strdup(name);
- ne->typ = type;
- ne->next = NULL;
+ ne->name = strdup(name);
+ ne->typ = type;
+ ne->next = NULL;
- for (ptr = *start; ptr && ptr->next; ptr = ptr->next);
+ for (ptr = *start; ptr && ptr->next; ptr = ptr->next);
- if (ptr)
- ptr->next=ne;
- else
- *start=ne;
- return ne;
+ if (ptr)
+ ptr->next = ne;
+ else
+ *start = ne;
+ return ne;
}
struct ECPGtype *
ECPGmake_simple_type(enum ECPGttype typ, long siz)
{
- struct ECPGtype *ne = (struct ECPGtype *) mm_alloc(sizeof(struct ECPGtype));
+ struct ECPGtype *ne = (struct ECPGtype *) mm_alloc(sizeof(struct ECPGtype));
- ne->typ = typ;
- ne->size = siz;
- ne->u.element = 0;
+ ne->typ = typ;
+ ne->size = siz;
+ ne->u.element = 0;
- return ne;
+ return ne;
}
struct ECPGtype *
ECPGmake_varchar_type(enum ECPGttype typ, long siz)
{
- struct ECPGtype *ne = ECPGmake_simple_type(typ, 1);
+ struct ECPGtype *ne = ECPGmake_simple_type(typ, 1);
- ne->size = siz;
+ ne->size = siz;
- return ne;
+ return ne;
}
struct ECPGtype *
-ECPGmake_array_type(struct ECPGtype *typ, long siz)
+ECPGmake_array_type(struct ECPGtype * typ, long siz)
{
- struct ECPGtype *ne = ECPGmake_simple_type(ECPGt_array, siz);
+ struct ECPGtype *ne = ECPGmake_simple_type(ECPGt_array, siz);
- ne->size = siz;
- ne->u.element = typ;
+ ne->size = siz;
+ ne->u.element = typ;
- return ne;
+ return ne;
}
struct ECPGtype *
-ECPGmake_record_type(struct ECPGrecord_member *rm)
+ECPGmake_record_type(struct ECPGrecord_member * rm)
{
- struct ECPGtype *ne = ECPGmake_simple_type(ECPGt_record, 1);
+ struct ECPGtype *ne = ECPGmake_simple_type(ECPGt_record, 1);
- ne->u.members = rm;
+ ne->u.members = rm;
- return ne;
+ return ne;
}
/* Dump a type.
The type is dumped as:
- type-tag - enum ECPGttype
+ type-tag - enum ECPGttype
reference-to-variable - void *
- size - long size of this field (if varchar)
- arrsize - long number of elements in the arr
- offset - offset to the next element
+ size - long size of this field (if varchar)
+ arrsize - long number of elements in the arr
+ offset - offset to the next element
Where:
type-tag is one of the simple types or varchar.
reference-to-variable can be a reference to a struct element.
size is the maxsize in case it is a varchar. Otherwise it is the size of
the variable (required to do array fetches of records).
*/
-void ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
- long varcharsize,
- long arrsiz, const char *siz, const char *prefix);
-void ECPGdump_a_record(FILE *o, const char *name, long arrsiz,
- struct ECPGtype *typ, const char *offset, const char *prefix);
+void
+ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
+ long varcharsize,
+ long arrsiz, const char *siz, const char *prefix);
+void
+ECPGdump_a_record(FILE *o, const char *name, long arrsiz,
+ struct ECPGtype * typ, const char *offset, const char *prefix);
void
-ECPGdump_a_type(FILE *o, const char *name, struct ECPGtype *typ, const char *prefix)
+ECPGdump_a_type(FILE *o, const char *name, struct ECPGtype * typ, const char *prefix)
{
- if (IS_SIMPLE_TYPE(typ->typ))
- {
- ECPGdump_a_simple(o, name, typ->typ, typ->size, 0, 0, prefix);
- }
- else if (typ->typ == ECPGt_array)
- {
- if (IS_SIMPLE_TYPE(typ->u.element->typ))
- ECPGdump_a_simple(o, name, typ->u.element->typ,
- typ->u.element->size, typ->size, 0, prefix);
- else if (typ->u.element->typ == ECPGt_array)
- {
- abort(); /* Array of array, */
- }
- else if (typ->u.element->typ == ECPGt_record)
- {
- /* Array of records. */
- ECPGdump_a_record(o, name, typ->size, typ->u.element, 0, prefix);
- }
- else
- {
- abort();
- }
- }
- else if (typ->typ == ECPGt_record)
- {
- ECPGdump_a_record(o, name, 0, typ, 0, prefix);
- }
- else
- {
- abort();
- }
+ if (IS_SIMPLE_TYPE(typ->typ))
+ {
+ ECPGdump_a_simple(o, name, typ->typ, typ->size, 0, 0, prefix);
+ }
+ else if (typ->typ == ECPGt_array)
+ {
+ if (IS_SIMPLE_TYPE(typ->u.element->typ))
+ ECPGdump_a_simple(o, name, typ->u.element->typ,
+ typ->u.element->size, typ->size, 0, prefix);
+ else if (typ->u.element->typ == ECPGt_array)
+ {
+ abort(); /* Array of array, */
+ }
+ else if (typ->u.element->typ == ECPGt_record)
+ {
+ /* Array of records. */
+ ECPGdump_a_record(o, name, typ->size, typ->u.element, 0, prefix);
+ }
+ else
+ {
+ abort();
+ }
+ }
+ else if (typ->typ == ECPGt_record)
+ {
+ ECPGdump_a_record(o, name, 0, typ, 0, prefix);
+ }
+ else
+ {
+ abort();
+ }
}
string, it represents the offset needed if we are in an array of records. */
void
ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
- long varcharsize,
- long arrsiz,
- const char *siz,
- const char *prefix)
+ long varcharsize,
+ long arrsiz,
+ const char *siz,
+ const char *prefix)
{
- switch (typ)
- {
- case ECPGt_char:
- if (varcharsize == 0) /* pointer */
- fprintf(o, "\n\tECPGt_char,%s%s,%ldL,%ldL,%s, ", prefix ? prefix : "", name, varcharsize, arrsiz,
- siz == NULL ? "sizeof(char)" : siz);
- else
- fprintf(o, "\n\tECPGt_char,&%s%s,%ldL,%ldL,%s, ", prefix ? prefix : "", name, varcharsize, arrsiz,
- siz == NULL ? "sizeof(char)" : siz);
- break;
- case ECPGt_unsigned_char:
- if (varcharsize == 0) /* pointer */
- fprintf(o, "\n\tECPGt_unsigned_char,%s%s,%ldL,%ldL,%s, ", prefix ? prefix : "", name, varcharsize, arrsiz,
- siz == NULL ? "sizeof(char)" : siz);
- else
- fprintf(o, "\n\tECPGt_unsigned_char,&%s%s,%ldL,%ldL,%s, ", prefix ? prefix : "", name, varcharsize, arrsiz,
- siz == NULL ? "sizeof(unsigned char)" : siz);
- break;
- case ECPGt_short:
- fprintf(o, "\n\tECPGt_short,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
- siz == NULL ? "sizeof(short)" : siz);
- break;
- case ECPGt_unsigned_short:
- fprintf(o,
- "\n\tECPGt_unsigned_short,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
- siz == NULL ? "sizeof(unsigned short)" : siz);
- break;
- case ECPGt_int:
- fprintf(o, "\n\tECPGt_int,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
- siz == NULL ? "sizeof(int)" : siz);
- break;
- case ECPGt_unsigned_int:
- fprintf(o, "\n\tECPGt_unsigned_int,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
- siz == NULL ? "sizeof(unsigned int)" : siz);
- break;
- case ECPGt_long:
- fprintf(o, "\n\tECPGt_long,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
- siz == NULL ? "sizeof(long)" : siz);
- break;
- case ECPGt_unsigned_long:
- fprintf(o, "\n\tECPGt_unsigned_int,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
- siz == NULL ? "sizeof(unsigned int)" : siz);
- break;
- case ECPGt_float:
- fprintf(o, "\n\tECPGt_float,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
- siz == NULL ? "sizeof(float)" : siz);
- break;
- case ECPGt_double:
- fprintf(o, "\n\tECPGt_double,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
- siz == NULL ? "sizeof(double)" : siz);
- break;
- case ECPGt_bool:
- fprintf(o, "\n\tECPGt_bool,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
- siz == NULL ? "sizeof(bool)" : siz);
- break;
- case ECPGt_varchar:
- case ECPGt_varchar2:
- if (siz == NULL)
- fprintf(o, "\n\tECPGt_varchar,&%s%s,%ldL,%ldL,sizeof(struct varchar_%s), ",
- prefix ? prefix : "", name,
- varcharsize,
- arrsiz, name);
- else
- fprintf(o, "\n\tECPGt_varchar,&%s%s,%ldL,%ldL,%s, ",
- prefix ? prefix : "", name,
- varcharsize,
- arrsiz, siz);
- break;
- default:
- abort();
- }
+ switch (typ)
+ {
+ case ECPGt_char:
+ if (varcharsize == 0) /* pointer */
+ fprintf(o, "\n\tECPGt_char,%s%s,%ldL,%ldL,%s, ", prefix ? prefix : "", name, varcharsize, arrsiz,
+ siz == NULL ? "sizeof(char)" : siz);
+ else
+ fprintf(o, "\n\tECPGt_char,&%s%s,%ldL,%ldL,%s, ", prefix ? prefix : "", name, varcharsize, arrsiz,
+ siz == NULL ? "sizeof(char)" : siz);
+ break;
+ case ECPGt_unsigned_char:
+ if (varcharsize == 0) /* pointer */
+ fprintf(o, "\n\tECPGt_unsigned_char,%s%s,%ldL,%ldL,%s, ", prefix ? prefix : "", name, varcharsize, arrsiz,
+ siz == NULL ? "sizeof(char)" : siz);
+ else
+ fprintf(o, "\n\tECPGt_unsigned_char,&%s%s,%ldL,%ldL,%s, ", prefix ? prefix : "", name, varcharsize, arrsiz,
+ siz == NULL ? "sizeof(unsigned char)" : siz);
+ break;
+ case ECPGt_short:
+ fprintf(o, "\n\tECPGt_short,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(short)" : siz);
+ break;
+ case ECPGt_unsigned_short:
+ fprintf(o,
+ "\n\tECPGt_unsigned_short,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(unsigned short)" : siz);
+ break;
+ case ECPGt_int:
+ fprintf(o, "\n\tECPGt_int,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(int)" : siz);
+ break;
+ case ECPGt_unsigned_int:
+ fprintf(o, "\n\tECPGt_unsigned_int,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(unsigned int)" : siz);
+ break;
+ case ECPGt_long:
+ fprintf(o, "\n\tECPGt_long,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(long)" : siz);
+ break;
+ case ECPGt_unsigned_long:
+ fprintf(o, "\n\tECPGt_unsigned_int,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(unsigned int)" : siz);
+ break;
+ case ECPGt_float:
+ fprintf(o, "\n\tECPGt_float,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(float)" : siz);
+ break;
+ case ECPGt_double:
+ fprintf(o, "\n\tECPGt_double,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(double)" : siz);
+ break;
+ case ECPGt_bool:
+ fprintf(o, "\n\tECPGt_bool,&%s%s,0L,%ldL,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(bool)" : siz);
+ break;
+ case ECPGt_varchar:
+ case ECPGt_varchar2:
+ if (siz == NULL)
+ fprintf(o, "\n\tECPGt_varchar,&%s%s,%ldL,%ldL,sizeof(struct varchar_%s), ",
+ prefix ? prefix : "", name,
+ varcharsize,
+ arrsiz, name);
+ else
+ fprintf(o, "\n\tECPGt_varchar,&%s%s,%ldL,%ldL,%s, ",
+ prefix ? prefix : "", name,
+ varcharsize,
+ arrsiz, siz);
+ break;
+ default:
+ abort();
+ }
}
/* Penetrate a record and dump the contents. */
void
-ECPGdump_a_record(FILE *o, const char *name, long arrsiz, struct ECPGtype *typ, const char *offsetarg, const char *prefix)
+ECPGdump_a_record(FILE *o, const char *name, long arrsiz, struct ECPGtype * typ, const char *offsetarg, const char *prefix)
{
- /* If offset is NULL, then this is the first recursive level. If not then
- we are in a record in a record and the offset is used as offset.
- */
- struct ECPGrecord_member *p;
- char obuf[BUFSIZ];
- char pbuf[BUFSIZ];
- const char *offset;
-
- if (offsetarg == NULL)
- {
- sprintf(obuf, "sizeof(%s)", name);
- offset = obuf;
- }
- else
- {
- offset = offsetarg;
- }
-
- sprintf(pbuf, "%s%s.", prefix ? prefix : "", name);
- prefix = pbuf;
-
- for (p = typ->u.members; p; p=p->next)
- {
+
+ /*
+ * If offset is NULL, then this is the first recursive level. If not
+ * then we are in a record in a record and the offset is used as
+ * offset.
+ */
+ struct ECPGrecord_member *p;
+ char obuf[BUFSIZ];
+ char pbuf[BUFSIZ];
+ const char *offset;
+
+ if (offsetarg == NULL)
+ {
+ sprintf(obuf, "sizeof(%s)", name);
+ offset = obuf;
+ }
+ else
+ {
+ offset = offsetarg;
+ }
+
+ sprintf(pbuf, "%s%s.", prefix ? prefix : "", name);
+ prefix = pbuf;
+
+ for (p = typ->u.members; p; p = p->next)
+ {
#if 0
- if (IS_SIMPLE_TYPE(p->typ->typ))
- {
- sprintf(buf, "%s.%s", name, p->name);
- ECPGdump_a_simple(o, buf, p->typ->typ, p->typ->size,
- arrsiz, offset);
- }
- else if (p->typ->typ == ECPGt_array)
- {
- int i;
-
- for (i = 0; i < p->typ->size; i++)
- {
- if (IS_SIMPLE_TYPE(p->typ->u.element->typ))
- {
- /* sprintf(buf, "%s.%s[%d]", name, p->name, i); */
- sprintf(buf, "%s.%s", name, p->name);
- ECPGdump_a_simple(o, buf, p->typ->u.element->typ, p->typ->u.element->size,
- p->typ->u.element->size, offset);
- }
- else if (p->typ->u.element->typ == ECPGt_array)
- {
- /* Array within an array. NOT implemented. */
- abort();
- }
- else if (p->typ->u.element->typ == ECPGt_record)
- {
- /* Record within array within record. NOT implemented yet. */
- abort();
- }
- else
- {
- /* Unknown type */
- abort();
- }
- }
- }
- else if (p->typ->typ == ECPGt_record)
- {
- /* Record within a record */
- sprintf(buf, "%s.%s", name, p->name);
- ECPGdump_a_record(o, buf, arrsiz, p->typ, offset);
- }
- else
- {
- /* Unknown type */
- abort();
- }
+ if (IS_SIMPLE_TYPE(p->typ->typ))
+ {
+ sprintf(buf, "%s.%s", name, p->name);
+ ECPGdump_a_simple(o, buf, p->typ->typ, p->typ->size,
+ arrsiz, offset);
+ }
+ else if (p->typ->typ == ECPGt_array)
+ {
+ int i;
+
+ for (i = 0; i < p->typ->size; i++)
+ {
+ if (IS_SIMPLE_TYPE(p->typ->u.element->typ))
+ {
+ /* sprintf(buf, "%s.%s[%d]", name, p->name, i); */
+ sprintf(buf, "%s.%s", name, p->name);
+ ECPGdump_a_simple(o, buf, p->typ->u.element->typ, p->typ->u.element->size,
+ p->typ->u.element->size, offset);
+ }
+ else if (p->typ->u.element->typ == ECPGt_array)
+ {
+ /* Array within an array. NOT implemented. */
+ abort();
+ }
+ else if (p->typ->u.element->typ == ECPGt_record)
+ {
+
+ /*
+ * Record within array within record. NOT implemented
+ * yet.
+ */
+ abort();
+ }
+ else
+ {
+ /* Unknown type */
+ abort();
+ }
+ }
+ }
+ else if (p->typ->typ == ECPGt_record)
+ {
+ /* Record within a record */
+ sprintf(buf, "%s.%s", name, p->name);
+ ECPGdump_a_record(o, buf, arrsiz, p->typ, offset);
+ }
+ else
+ {
+ /* Unknown type */
+ abort();
+ }
#endif
ECPGdump_a_type(o, p->name, p->typ, prefix);
- }
+ }
}
anyway. Lets implement that last! */
void
-ECPGfree_record_member(struct ECPGrecord_member *rm)
+ECPGfree_record_member(struct ECPGrecord_member * rm)
{
- while (rm)
- {
- struct ECPGrecord_member *p = rm;
-
- rm = rm->next;
- free(p->name);
- free(p);
- }
+ while (rm)
+ {
+ struct ECPGrecord_member *p = rm;
+
+ rm = rm->next;
+ free(p->name);
+ free(p);
+ }
}
void
-ECPGfree_type(struct ECPGtype *typ)
+ECPGfree_type(struct ECPGtype * typ)
{
- if (!IS_SIMPLE_TYPE(typ->typ))
- {
- if (typ->typ == ECPGt_array)
- {
- if (IS_SIMPLE_TYPE(typ->u.element->typ))
- free(typ->u.element);
- else if (typ->u.element->typ == ECPGt_array)
- abort(); /* Array of array, */
- else if (typ->u.element->typ == ECPGt_record)
- /* Array of records. */
- ECPGfree_record_member(typ->u.members);
- else
- abort();
- }
- else if (typ->typ == ECPGt_record)
- {
- ECPGfree_record_member(typ->u.members);
- }
- else
- {
- abort();
- }
- }
- free(typ);
+ if (!IS_SIMPLE_TYPE(typ->typ))
+ {
+ if (typ->typ == ECPGt_array)
+ {
+ if (IS_SIMPLE_TYPE(typ->u.element->typ))
+ free(typ->u.element);
+ else if (typ->u.element->typ == ECPGt_array)
+ abort(); /* Array of array, */
+ else if (typ->u.element->typ == ECPGt_record)
+ /* Array of records. */
+ ECPGfree_record_member(typ->u.members);
+ else
+ abort();
+ }
+ else if (typ->typ == ECPGt_record)
+ {
+ ECPGfree_record_member(typ->u.members);
+ }
+ else
+ {
+ abort();
+ }
+ }
+ free(typ);
}
#include
struct ECPGtype;
-struct ECPGrecord_member {
- char * name;
- struct ECPGtype * typ;
- struct ECPGrecord_member * next;
+struct ECPGrecord_member
+{
+ char *name;
+ struct ECPGtype *typ;
+ struct ECPGrecord_member *next;
};
-struct ECPGtype {
- enum ECPGttype typ;
- long size; /* For array it is the number of elements.
- * For varchar it is the maxsize of the area.
- */
- union {
- struct ECPGtype * element; /* For an array this is the type of the
- * element */
+struct ECPGtype
+{
+ enum ECPGttype typ;
+ long size; /* For array it is the number of elements.
+ * For varchar it is the maxsize of the
+ * area. */
+ union
+ {
+ struct ECPGtype *element; /* For an array this is the type
+ * of the element */
- struct ECPGrecord_member * members;
- /* A pointer to a list of members. */
- } u;
+ struct ECPGrecord_member *members;
+ /* A pointer to a list of members. */
+ } u;
};
/* Everything is malloced. */
-struct ECPGrecord_member * ECPGmake_record_member(char *, struct ECPGtype *, struct ECPGrecord_member **);
-struct ECPGtype * ECPGmake_simple_type(enum ECPGttype, long);
-struct ECPGtype * ECPGmake_varchar_type(enum ECPGttype, long);
-struct ECPGtype * ECPGmake_array_type(struct ECPGtype *, long);
-struct ECPGtype * ECPGmake_record_type(struct ECPGrecord_member *);
+struct ECPGrecord_member *ECPGmake_record_member(char *, struct ECPGtype *, struct ECPGrecord_member **);
+struct ECPGtype *ECPGmake_simple_type(enum ECPGttype, long);
+struct ECPGtype *ECPGmake_varchar_type(enum ECPGttype, long);
+struct ECPGtype *ECPGmake_array_type(struct ECPGtype *, long);
+struct ECPGtype *ECPGmake_record_type(struct ECPGrecord_member *);
/* Frees a type. */
-void ECPGfree_record_member(struct ECPGrecord_member *);
-void ECPGfree_type(struct ECPGtype *);
+void ECPGfree_record_member(struct ECPGrecord_member *);
+void ECPGfree_type(struct ECPGtype *);
/* Dump a type.
The type is dumped as:
type-tag is one of the simple types or varchar.
reference-to-variable can be a reference to a struct element.
arrsize is the size of the array in case of array fetches. Otherwise 0.
- size is the maxsize in case it is a varchar. Otherwise it is the size of
- the variable (required to do array fetches of records).
+ size is the maxsize in case it is a varchar. Otherwise it is the size of
+ the variable (required to do array fetches of records).
*/
-void ECPGdump_a_type(FILE *, const char * name, struct ECPGtype *, const char *);
+void ECPGdump_a_type(FILE *, const char *name, struct ECPGtype *, const char *);
/* A simple struct to keep a variable and its type. */
-struct ECPGtemp_type {
- struct ECPGtype * typ;
- const char * name;
+struct ECPGtemp_type
+{
+ struct ECPGtype *typ;
+ const char *name;
};
-extern const char * ECPGtype_name(enum ECPGttype typ);
+extern const char *ECPGtype_name(enum ECPGttype typ);
/* some stuff for whenever statements */
-enum WHEN {
- W_NOTHING,
- W_CONTINUE,
- W_BREAK,
- W_SQLPRINT,
- W_GOTO,
- W_DO,
- W_STOP
+enum WHEN
+{
+ W_NOTHING,
+ W_CONTINUE,
+ W_BREAK,
+ W_SQLPRINT,
+ W_GOTO,
+ W_DO,
+ W_STOP
};
struct when
-{
- enum WHEN code;
- char * str;
+{
+ enum WHEN code;
+ char *str;
};
#include
/* exec sql begin declare section */
- /* VARSIZE */struct varchar_uid { int len; char arr[200]; } uid;
- struct varchar_name { int len; char arr[200]; } name;
- short value;
+ /* VARSIZE */ struct varchar_uid
+{
+ int len;
+ char arr[200];
+} uid;
+struct varchar_name
+{
+ int len;
+ char arr[200];
+} name;
+short value;
+
/* exec sql end declare section */
#include "sqlca.h"
-#define DBCP(x,y) strcpy(x.arr,y);x.len = strlen(x.arr)
-#define LENFIX(x) x.len=strlen(x.arr)
-#define STRFIX(x) x.arr[x.len]='\0'
-#define SQLCODE sqlca.sqlcode
+#define DBCP(x,y) strcpy(x.arr,y);x.len = strlen(x.arr)
+#define LENFIX(x) x.len=strlen(x.arr)
+#define STRFIX(x) x.arr[x.len]='\0'
+#define SQLCODE sqlca.sqlcode
void
-db_error (char *msg)
+db_error(char *msg)
{
sqlca.sqlerrm.sqlerrmc[sqlca.sqlerrm.sqlerrml] = '\0';
- printf ("%s: db error %s\n", msg, sqlca.sqlerrm.sqlerrmc);
- exit (1);
+ printf("%s: db error %s\n", msg, sqlca.sqlerrm.sqlerrmc);
+ exit(1);
}
int
-main ()
+main()
{
- strcpy (uid.arr, "test/test");
- LENFIX (uid);
+ strcpy(uid.arr, "test/test");
+ LENFIX(uid);
ECPGconnect("kom");
if (SQLCODE)
- db_error ("connect");
+ db_error("connect");
- strcpy (name.arr, "opt1");
- LENFIX (name);
+ strcpy(name.arr, "opt1");
+ LENFIX(name);
+
+ ECPGdo(__LINE__, "declare cur cursor for select name , value from pace_test ", ECPGt_EOIT, ECPGt_EORT);
+ if (SQLCODE)
+ db_error("declare");
- ECPGdo(__LINE__, "declare cur cursor for select name , value from pace_test ", ECPGt_EOIT, ECPGt_EORT );
- if (SQLCODE) db_error ("declare");
-
if (SQLCODE)
- db_error ("open");
+ db_error("open");
- while (1) {
- ECPGdo(__LINE__, "fetch in cur ", ECPGt_EOIT, ECPGt_varchar,&name,200,0,sizeof(struct varchar_name), ECPGt_short,&value,0,0,sizeof(short), ECPGt_EORT );
+ while (1)
+ {
+ ECPGdo(__LINE__, "fetch in cur ", ECPGt_EOIT, ECPGt_varchar, &name, 200, 0, sizeof(struct varchar_name), ECPGt_short, &value, 0, 0, sizeof(short), ECPGt_EORT);
if (SQLCODE)
break;
- STRFIX (name);
- printf ("%s\t%d\n", name.arr, value);
+ STRFIX(name);
+ printf("%s\t%d\n", name.arr, value);
}
if (SQLCODE < 0)
- db_error ("fetch");
+ db_error("fetch");
- ECPGdo(__LINE__, "close cur ", ECPGt_EOIT, ECPGt_EORT );
- if (SQLCODE) db_error ("close");
+ ECPGdo(__LINE__, "close cur ", ECPGt_EOIT, ECPGt_EORT);
+ if (SQLCODE)
+ db_error("close");
ECPGcommit(__LINE__);
- if (SQLCODE) db_error ("commit");
+ if (SQLCODE)
+ db_error("commit");
return (0);
}
exec sql begin declare section;
-VARCHAR uid[200 /* VARSIZE */];
-varchar name[200];
-short value;
+VARCHAR uid[200 /* VARSIZE */ ];
+varchar name[200];
+short value;
exec sql end declare section;
exec sql include sqlca;
-#define DBCP(x,y) strcpy(x.arr,y);x.len = strlen(x.arr)
-#define LENFIX(x) x.len=strlen(x.arr)
-#define STRFIX(x) x.arr[x.len]='\0'
-#define SQLCODE sqlca.sqlcode
+#define DBCP(x,y) strcpy(x.arr,y);x.len = strlen(x.arr)
+#define LENFIX(x) x.len=strlen(x.arr)
+#define STRFIX(x) x.arr[x.len]='\0'
+#define SQLCODE sqlca.sqlcode
void
-db_error (char *msg)
+db_error(char *msg)
{
sqlca.sqlerrm.sqlerrmc[sqlca.sqlerrm.sqlerrml] = '\0';
- printf ("%s: db error %s\n", msg, sqlca.sqlerrm.sqlerrmc);
- exit (1);
+ printf("%s: db error %s\n", msg, sqlca.sqlerrm.sqlerrmc);
+ exit(1);
}
int
-main ()
+main()
{
- strcpy (uid.arr, "test/test");
- LENFIX (uid);
+ strcpy(uid.arr, "test/test");
+ LENFIX(uid);
+
+ exec sql connect 'kom';
- exec sql connect 'kom';
if (SQLCODE)
- db_error ("connect");
+ db_error("connect");
+
+ strcpy(name.arr, "opt1");
+ LENFIX(name);
- strcpy (name.arr, "opt1");
- LENFIX (name);
+ exec sql declare cur cursor for
+ select name,
+ value from pace_test;
- exec sql declare cur cursor for
- select name, value from pace_test;
- if (SQLCODE) db_error ("declare");
+ if (SQLCODE)
+ db_error("declare");
exec sql open cur;
+
if (SQLCODE)
- db_error ("open");
+ db_error("open");
+
+ while (1)
+ {
+ exec sql fetch in cur into:name,
+ : value;
- while (1) {
- exec sql fetch in cur into :name, :value;
if (SQLCODE)
break;
- STRFIX (name);
- printf ("%s\t%d\n", name.arr, value);
+ STRFIX(name);
+ printf("%s\t%d\n", name.arr, value);
}
if (SQLCODE < 0)
- db_error ("fetch");
+ db_error("fetch");
exec sql close cur;
- if (SQLCODE) db_error ("close");
- exec sql commit;
- if (SQLCODE) db_error ("commit");
+
+ if (SQLCODE)
+ db_error("close");
+ exec sql commit;
+
+ if (SQLCODE)
+ db_error("commit");
return (0);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/libpgtcl/Attic/pgtclCmds.c,v 1.20 1998/02/11 19:13:54 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/libpgtcl/Attic/pgtclCmds.c,v 1.21 1998/02/26 04:44:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static inline char *
translate_escape(char *p, int isArray)
{
- char c,
+ char c,
*q,
*s;
{
int literal,
last;
- char *p;
+ char *p;
if (!value)
{
#ifdef TCL_ARRAYS
for (i = 0; i < PQnfields(result); i++)
{
- Tcl_AppendElement(interp, PQgetvalue(result,tupno,i));
+ Tcl_AppendElement(interp, PQgetvalue(result, tupno, i));
}
#else
/* Tcl_AppendResult(interp, PQgetvalue(result,tupno,0),NULL); */
for (column = 0; column < ncols; column++)
{
- Tcl_SetVar2(interp, argv[3], info[column].cname,
- PQgetvalue(result, tupno, column), 0);
+ Tcl_SetVar2(interp, argv[3], info[column].cname,
+ PQgetvalue(result, tupno, column), 0);
}
Tcl_SetVar2(interp, argv[3], ".command", "update", 0);
if ((r = Tcl_Eval(interp, argv[4])) != TCL_OK && r != TCL_CONTINUE)
{
- if (r == TCL_BREAK) {
- /* I suppose that memory used by info and result must be released */
- free(info); PQclear(result);Tcl_UnsetVar(interp, argv[3], 0);
+ if (r == TCL_BREAK)
+ {
+
+ /*
+ * I suppose that memory used by info and result must be
+ * released
+ */
+ free(info);
+ PQclear(result);
+ Tcl_UnsetVar(interp, argv[3], 0);
return TCL_OK;
}
if (r == TCL_ERROR)
Tcl_AddErrorInfo(interp, msg);
}
/* also, releasing memory used by info and result */
- free(info); PQclear(result);Tcl_UnsetVar(interp, argv[3], 0);
+ free(info);
+ PQclear(result);
+ Tcl_UnsetVar(interp, argv[3], 0);
return r;
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/libpgtcl/Attic/pgtclId.c,v 1.6 1997/09/08 21:55:24 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/libpgtcl/Attic/pgtclId.c,v 1.7 1998/02/26 04:44:53 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* Get back the connection from the Id
*/
-PGconn *
+PGconn *
PgGetConnectionId(Pg_clientData * cd, char *id)
{
Tcl_HashEntry *hent;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-auth.c,v 1.14 1998/01/29 03:24:03 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-auth.c,v 1.15 1998/02/26 04:44:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
int
fe_sendauth(AuthRequest areq, PGconn *conn, const char *hostname,
- const char *password, char *PQerrormsg)
+ const char *password, char *PQerrormsg)
{
switch (areq)
{
- case AUTH_REQ_OK:
- break;
+ case AUTH_REQ_OK:
+ break;
- case AUTH_REQ_KRB4:
+ case AUTH_REQ_KRB4:
#ifdef KRB4
if (pg_krb4_sendauth(PQerrormsg, conn->sock, &conn->laddr.in,
&conn->raddr.in,
}
break;
#else
- (void)sprintf(PQerrormsg,
- "fe_sendauth: krb4 authentication not supported\n");
- return (STATUS_ERROR);
+ (void) sprintf(PQerrormsg,
+ "fe_sendauth: krb4 authentication not supported\n");
+ return (STATUS_ERROR);
#endif
- case AUTH_REQ_KRB5:
+ case AUTH_REQ_KRB5:
#ifdef KRB5
if (pg_krb5_sendauth(PQerrormsg, conn->sock, &conn->laddr.in,
&conn->raddr.in,
}
break;
#else
- (void)sprintf(PQerrormsg,
- "fe_sendauth: krb5 authentication not supported\n");
- return (STATUS_ERROR);
+ (void) sprintf(PQerrormsg,
+ "fe_sendauth: krb5 authentication not supported\n");
+ return (STATUS_ERROR);
#endif
- case AUTH_REQ_PASSWORD:
- case AUTH_REQ_CRYPT:
- if (pg_password_sendauth(conn, password, areq) != STATUS_OK)
- {
- (void)sprintf(PQerrormsg,
- "fe_sendauth: error sending password authentication\n");
- return (STATUS_ERROR);
- }
+ case AUTH_REQ_PASSWORD:
+ case AUTH_REQ_CRYPT:
+ if (pg_password_sendauth(conn, password, areq) != STATUS_OK)
+ {
+ (void) sprintf(PQerrormsg,
+ "fe_sendauth: error sending password authentication\n");
+ return (STATUS_ERROR);
+ }
- break;
+ break;
- default:
- (void)sprintf(PQerrormsg,
- "fe_sendauth: authentication type %u not supported\n",areq);
- return (STATUS_ERROR);
- }
+ default:
+ (void) sprintf(PQerrormsg,
+ "fe_sendauth: authentication type %u not supported\n", areq);
+ return (STATUS_ERROR);
+ }
return (STATUS_OK);
}
* name the user has authenticated to the system
* if there is an error, return the error message in PQerrormsg
*/
-char *
+char *
fe_getauthname(char *PQerrormsg)
{
char *name = (char *) NULL;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-connect.c,v 1.62 1998/01/31 21:27:28 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-connect.c,v 1.63 1998/02/26 04:44:59 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static int conninfo_parse(const char *conninfo, char *errorMessage);
static char *conninfo_getval(char *keyword);
static void conninfo_free(void);
-void PQsetenv(PGconn *conn);
+void PQsetenv(PGconn *conn);
#define NOTIFYLIST_INITIAL_SIZE 10
#define NOTIFYLIST_GROWBY 10
{
/* common user-interface settings */
- { "PGDATESTYLE", "datestyle" },
- { "PGTZ", "timezone" },
+ {
+ "PGDATESTYLE", "datestyle"
+ },
+ {
+ "PGTZ", "timezone"
+ },
/* internal performance-related settings */
- { "PGCOSTHEAP", "cost_heap" },
- { "PGCOSTINDEX", "cost_index" },
- { "PGRPLANS", "r_plans" },
- { "PGGEQO", "geqo" },
- { NULL }
+ {
+ "PGCOSTHEAP", "cost_heap"
+ },
+ {
+ "PGCOSTINDEX", "cost_index"
+ },
+ {
+ "PGRPLANS", "r_plans"
+ },
+ {
+ "PGGEQO", "geqo"
+ },
+ {
+ NULL
+ }
};
/* ----------------
{
PGconn *conn;
char errorMessage[ERROR_MSG_LENGTH];
- char* tmp;
+ char *tmp;
+
/* ----------
* Allocate memory for the conn structure
* ----------
tmp = conninfo_getval("port");
conn->pgport = tmp ? strdup(tmp) : NULL;
tmp = conninfo_getval("tty");
- conn->pgtty = tmp ? strdup(tmp) : NULL;
+ conn->pgtty = tmp ? strdup(tmp) : NULL;
tmp = conninfo_getval("options");
conn->pgoptions = tmp ? strdup(tmp) : NULL;
tmp = conninfo_getval("user");
*
* ----------------
*/
-PGconn *
+PGconn *
PQsetdbLogin(const char *pghost, const char *pgport, const char *pgoptions, const char *pgtty, const char *dbName, const char *login, const char *pwd)
{
PGconn *conn;
conn->dbName = strdup(conn->pguser);
/*
- * if the database name is surrounded by double-quotes,
- * then don't convert case
+ * if the database name is surrounded by double-quotes, then
+ * don't convert case
*/
if (*conn->dbName == '"')
{
{
struct hostent *hp;
- StartupPacket sp;
- AuthRequest areq;
+ StartupPacket sp;
+ AuthRequest areq;
int laddrlen = sizeof(SockAddr);
int portno,
family,
* Initialize the startup packet.
*/
- MemSet((char *)&sp, 0, sizeof (StartupPacket));
+ MemSet((char *) &sp, 0, sizeof(StartupPacket));
- sp.protoVersion = (ProtocolVersion)htonl(PG_PROTOCOL_LATEST);
+ sp.protoVersion = (ProtocolVersion) htonl(PG_PROTOCOL_LATEST);
strncpy(sp.user, conn->pguser, SM_USER);
strncpy(sp.database, conn->dbName, SM_DATABASE);
conn->pghost);
goto connect_errReturn;
}
- } else
+ }
+ else
hp = NULL;
#if FALSE
/* Send the startup packet. */
- if (packetSend(conn, (char *)&sp, sizeof(StartupPacket)) != STATUS_OK)
+ if (packetSend(conn, (char *) &sp, sizeof(StartupPacket)) != STATUS_OK)
{
sprintf(conn->errorMessage,
"connectDB() -- couldn't send complete packet: errno=%d\n%s\n", errno, strerror(errno));
do
{
- int beresp;
+ int beresp;
if ((beresp = pqGetc(conn->Pfin, conn->Pfdebug)) == EOF)
{
- (void)sprintf(conn->errorMessage,
- "connectDB() -- error getting authentication request\n");
+ (void) sprintf(conn->errorMessage,
+ "connectDB() -- error getting authentication request\n");
goto connect_errReturn;
}
if (beresp == 'E')
{
- pqGets(conn->errorMessage, sizeof (conn->errorMessage),
- conn->Pfin, conn->Pfdebug);
+ pqGets(conn->errorMessage, sizeof(conn->errorMessage),
+ conn->Pfin, conn->Pfdebug);
goto connect_errReturn;
}
if (beresp != 'R')
{
- (void)sprintf(conn->errorMessage,
- "connectDB() -- expected authentication request\n");
+ (void) sprintf(conn->errorMessage,
+ "connectDB() -- expected authentication request\n");
goto connect_errReturn;
}
/* Get the type of request. */
- if (pqGetInt((int *)&areq, 4, conn->Pfin, conn->Pfdebug))
+ if (pqGetInt((int *) &areq, 4, conn->Pfin, conn->Pfdebug))
{
- (void)sprintf(conn->errorMessage,
- "connectDB() -- error getting authentication request type\n");
+ (void) sprintf(conn->errorMessage,
+ "connectDB() -- error getting authentication request type\n");
goto connect_errReturn;
}
/* Get the password salt if there is one. */
if (areq == AUTH_REQ_CRYPT &&
- pqGetnchar(conn->salt, sizeof (conn->salt),
- conn->Pfin, conn->Pfdebug))
+ pqGetnchar(conn->salt, sizeof(conn->salt),
+ conn->Pfin, conn->Pfdebug))
{
- (void)sprintf(conn->errorMessage,
- "connectDB() -- error getting password salt\n");
+ (void) sprintf(conn->errorMessage,
+ "connectDB() -- error getting password salt\n");
goto connect_errReturn;
}
/* Respond to the request. */
if (fe_sendauth(areq, conn, conn->pghost, conn->pgpass,
- conn->errorMessage) != STATUS_OK)
+ conn->errorMessage) != STATUS_OK)
goto connect_errReturn;
}
while (areq != AUTH_REQ_OK);
PQsetenv(PGconn *conn)
{
struct EnvironmentOptions *eo;
- char setQuery[80]; /* mjl: size okay? XXX */
+ char setQuery[80]; /* mjl: size okay? XXX */
for (eo = EnvironmentOptions; eo->envName; eo++)
{
else
sprintf(setQuery, "SET %s = '%.60s'", eo->pgName, val);
#ifdef CONNECTDEBUG
-printf("Use environment variable %s to send %s\n", eo->envName, setQuery);
+ printf("Use environment variable %s to send %s\n", eo->envName, setQuery);
#endif
res = PQexec(conn, setQuery);
- PQclear(res); /* Don't care? */
+ PQclear(res); /* Don't care? */
}
}
-} /* PQsetenv() */
+} /* PQsetenv() */
/*
* freePGconn
}
/* =========== accessor functions for PGconn ========= */
-char *
+char *
PQdb(PGconn *conn)
{
if (!conn)
return conn->dbName;
}
-char *
+char *
PQuser(PGconn *conn)
{
if (!conn)
return conn->pguser;
}
-char *
+char *
PQhost(PGconn *conn)
{
if (!conn)
return conn->pghost;
}
-char *
+char *
PQoptions(PGconn *conn)
{
if (!conn)
return conn->pgoptions;
}
-char *
+char *
PQtty(PGconn *conn)
{
if (!conn)
return conn->pgtty;
}
-char *
+char *
PQport(PGconn *conn)
{
if (!conn)
return conn->status;
}
-char *
+char *
PQerrorMessage(PGconn *conn)
{
if (!conn)
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: fe-connect.h,v 1.7 1998/01/29 03:24:36 scrappy Exp $
+ * $Id: fe-connect.h,v 1.8 1998/02/26 04:45:02 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*----------------------------------------------------------------
*/
-int packetSend(PGconn *conn, const char *buf, size_t len);
+int packetSend(PGconn *conn, const char *buf, size_t len);
#endif /* FE_CONNECT_H */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-exec.c,v 1.46 1998/01/26 01:42:35 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-exec.c,v 1.47 1998/02/26 04:45:07 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
/* hmm, no response from the backend-end, that's bad */
(void) sprintf(reason, "PQexec() -- Request was sent to backend"
- ", but backend closed the channel before responding."
- "\n\tThis probably means the backend terminated abnormally"
- " before or while processing the request.\n");
- conn->status = CONNECTION_BAD; /* No more connection to backend */
+ ", but backend closed the channel before responding."
+ "\n\tThis probably means the backend terminated abnormally"
+ " before or while processing the request.\n");
+ conn->status = CONNECTION_BAD; /* No more connection to
+ * backend */
*result_p = (PGresult *) NULL;
done = true;
}
/*
returns NULL if the field_num is invalid
*/
-char *
+char *
PQfname(PGresult *res, int field_num)
{
if (!res)
return 0;
}
-char *
+char *
PQcmdStatus(PGresult *res)
{
if (!res)
if res is not binary, a null-terminated ASCII string is returned.
*/
-char *
+char *
PQgetvalue(PGresult *res, int tup_num, int field_num)
{
if (!res)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-misc.c,v 1.9 1998/01/26 01:42:36 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-misc.c,v 1.10 1998/02/26 04:45:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
int
pqGetnchar(char *s, int len, FILE *f, FILE *debug)
{
- int status;
+ int status;
status = pqGetNBytes(s, len, f);
int
pqGets(char *s, int len, FILE *f, FILE *debug)
{
- int status;
+ int status;
status = pqGetString(s, len, f);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: libpq-fe.h,v 1.26 1998/02/24 06:04:55 scrappy Exp $
+ * $Id: libpq-fe.h,v 1.27 1998/02/26 04:45:15 momjian Exp $
*
*-------------------------------------------------------------------------
*/
FILE *Pfin;
FILE *Pfout;
FILE *Pfdebug;
- int sock; /* The socket */
- SockAddr laddr; /* Local address */
- SockAddr raddr; /* Remote address */
- char salt[2];
+ int sock; /* The socket */
+ SockAddr laddr; /* Local address */
+ SockAddr raddr; /* Remote address */
+ char salt[2];
int asyncNotifyWaiting;
Dllist *notifyList;
char *pguser; /* Postgres username of user who is
extern PGconn *PQconnectdb(const char *conninfo);
extern PQconninfoOption *PQconndefaults(void);
extern PGconn *PQsetdbLogin(const char *pghost, const char *pgport, const char *pgoptions,
- const char *pgtty, const char *dbName, const char *login, const char *pwd);
+ const char *pgtty, const char *dbName, const char *login, const char *pwd);
#define PQsetdb(M_PGHOST,M_PGPORT,M_PGOPT,M_PGTTY,M_DBNAME) PQsetdbLogin(M_PGHOST, M_PGPORT, M_PGOPT, M_PGTTY, M_DBNAME, NULL, NULL)
/* close the current connection and free the PGconn data structure */
extern void PQfinish(PGconn *conn);
- *
+ *
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose, without fee, and without a written
* agreement is hereby granted, provided that the above copyright notice and
* this paragraph and the following two paragraphs appear in all copies or in
* any new file that contains a substantial portion of this file.
- *
+ *
* IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
* SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE
* AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
+ *
* THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE
* AUTHOR HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
* ENHANCEMENTS, OR MODIFICATIONS.
- *
+ *
* subject to the same terms and conditions as above.
- *
+ *
*/
/* taken from fileobject.c */
#define BUF(v) PyString_AS_STRING((PyStringObject *)(v))
-#define CHECK_OPEN 1
-#define CHECK_CLOSE 2
+#define CHECK_OPEN 1
+#define CHECK_CLOSE 2
#define MAX_BUFFER_SIZE 8192 /* maximum transaction size */
#ifndef NO_DIRECT
-#define DIRECT_ACCESS 1 /* enables direct access functions */
+#define DIRECT_ACCESS 1 /* enables direct access functions */
#endif /* NO_DIRECT */
#ifndef NO_LARGE
-#define LARGE_OBJECTS 1 /* enables large objects support */
+#define LARGE_OBJECTS 1 /* enables large objects support */
#endif /* NO_LARGE */
#ifndef NO_DEF_VAR
-#define DEFAULT_VARS 1 /* enables default variables use */
+#define DEFAULT_VARS 1 /* enables default variables use */
#endif /* NO_DEF_VAR */
/* --------------------------------------------------------------------- */
#ifdef DEFAULT_VARS
-PyObject *pg_default_host; /* default database host */
-PyObject *pg_default_base; /* default database name */
-PyObject *pg_default_opt; /* default connection options */
-PyObject *pg_default_tty; /* default debug tty */
-PyObject *pg_default_port; /* default connection port */
+PyObject *pg_default_host; /* default database host */
+PyObject *pg_default_base; /* default database name */
+PyObject *pg_default_opt; /* default connection options */
+PyObject *pg_default_tty; /* default debug tty */
+PyObject *pg_default_port; /* default connection port */
#endif /* DEFAULT_VARS */
typedef struct
{
PyObject_HEAD
- int valid; /* validity flag */
- PGconn *cnx; /* PostGres connection handle */
-} pgobject;
+ int valid; /* validity flag */
+ PGconn *cnx; /* PostGres connection handle */
+} pgobject;
staticforward PyTypeObject PgType;
typedef struct
{
PyObject_HEAD
- PGresult *last_result; /* last result content */
-} pgqueryobject;
+ PGresult *last_result; /* last result content */
+} pgqueryobject;
staticforward PyTypeObject PgQueryType;
{
PyObject_HEAD
pgobject * pgcnx;
- Oid lo_oid;
- int lo_fd;
-} pglargeobject;
+ Oid lo_oid;
+ int lo_fd;
+} pglargeobject;
staticforward PyTypeObject PglargeType;
/* pglargeobject initialisation (from pgobject) */
/* creates large object */
-static PyObject *
+static PyObject *
pg_locreate(pgobject * self, PyObject * args)
{
- int mode;
- pglargeobject *npglo;
+ int mode;
+ pglargeobject *npglo;
/* gets arguments */
if (!PyArg_ParseTuple(args, "i", &mode))
{
PyErr_SetString(PyExc_TypeError,
- "locreate(mode), with mode (integer).");
+ "locreate(mode), with mode (integer).");
return NULL;
}
static PyObject *
pg_getlo(pgobject * self, PyObject * args)
{
- int lo_oid;
- pglargeobject *npglo;
+ int lo_oid;
+ pglargeobject *npglo;
/* gets arguments */
if (!PyArg_ParseTuple(args, "i", &lo_oid))
static PyObject *
pg_loimport(pgobject * self, PyObject * args)
{
- char *name;
- pglargeobject *npglo;
+ char *name;
+ pglargeobject *npglo;
/* gets arguments */
if (!PyArg_ParseTuple(args, "s", &name))
static PyObject *
pglarge_open(pglargeobject * self, PyObject * args)
{
- int mode, fd;
+ int mode,
+ fd;
/* check validity */
if (!check_lo(self, CHECK_CLOSE))
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
- "method close() takes no parameters.");
+ "method close() takes no parameters.");
return NULL;
}
static PyObject *
pglarge_read(pglargeobject * self, PyObject * args)
{
- int size;
- PyObject *buffer;
+ int size;
+ PyObject *buffer;
/* checks validity */
if (!check_lo(self, CHECK_OPEN))
static PyObject *
pglarge_write(pglargeobject * self, PyObject * args)
{
- PyObject *buffer;
- int size;
+ PyObject *buffer;
+ int size;
/* checks validity */
if (!check_lo(self, CHECK_OPEN))
if (!PyArg_ParseTuple(args, "s", &buffer))
{
PyErr_SetString(PyExc_TypeError,
- "write(buffer), with buffer (sized string).");
+ "write(buffer), with buffer (sized string).");
return NULL;
}
/* sends query */
if ((size = lo_write(self->pgcnx->cnx, self->lo_fd, (char *) BUF(buffer),
- PyString_Size(buffer))) < PyString_Size(buffer))
+ PyString_Size(buffer))) < PyString_Size(buffer))
{
PyErr_SetString(PyExc_IOError, "buffer truncated during write.");
return NULL;
static PyObject *
pglarge_lseek(pglargeobject * self, PyObject * args)
{
- int ret, offset, whence;
+ int ret,
+ offset,
+ whence;
/* checks validity */
if (!check_lo(self, CHECK_OPEN))
if (!PyArg_ParseTuple(args, "ii", offset, whence))
{
PyErr_SetString(PyExc_TypeError,
- "lseek(offset, whence), with offset and whence (integers).");
+ "lseek(offset, whence), with offset and whence (integers).");
return NULL;
}
static PyObject *
pglarge_size(pglargeobject * self, PyObject * args)
{
- int start, end;
+ int start,
+ end;
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
- "method size() takes no parameters.");
+ "method size() takes no parameters.");
return NULL;
}
}
/* move back to start position */
- if ((start = lo_lseek(self->pgcnx->cnx,self->lo_fd,start,SEEK_SET)) == -1)
+ if ((start = lo_lseek(self->pgcnx->cnx, self->lo_fd, start, SEEK_SET)) == -1)
{
PyErr_SetString(PyExc_IOError,
- "error while moving back to first position.");
+ "error while moving back to first position.");
return NULL;
}
static PyObject *
pglarge_tell(pglargeobject * self, PyObject * args)
{
- int start;
+ int start;
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
- "method tell() takes no parameters.");
+ "method tell() takes no parameters.");
return NULL;
}
static PyObject *
pglarge_export(pglargeobject * self, PyObject * args)
{
- char *name;
+ char *name;
/* checks validity */
if (!check_lo(self, CHECK_CLOSE))
if (!PyArg_ParseTuple(args, "s", &name))
{
PyErr_SetString(PyExc_TypeError,
- "export(filename), with filename (string).");
+ "export(filename), with filename (string).");
return NULL;
}
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
- "method unlink() takes no parameters.");
+ "method unlink() takes no parameters.");
return NULL;
}
/* large object methods */
static struct PyMethodDef pglarge_methods[] = {
- {"open", (PyCFunction) pglarge_open, 1}, /* opens large object */
- {"close", (PyCFunction) pglarge_close, 1},/* closes large object */
- {"read", (PyCFunction) pglarge_read, 1}, /* reads from large object */
- {"write", (PyCFunction) pglarge_write, 1},/* writes to large object */
- {"seek", (PyCFunction) pglarge_lseek, 1},/* seeks position */
- {"size", (PyCFunction) pglarge_size, 1}, /* gives object size */
- {"tell", (PyCFunction) pglarge_tell, 1}, /* gives position in lobj */
- {"export", (PyCFunction) pglarge_export, 1},/* exports to unix file */
- {"unlink", (PyCFunction) pglarge_unlink, 1},/* deletes a large object */
- {NULL, NULL} /* sentinel */
+ {"open", (PyCFunction) pglarge_open, 1}, /* opens large object */
+ {"close", (PyCFunction) pglarge_close, 1}, /* closes large object */
+ {"read", (PyCFunction) pglarge_read, 1}, /* reads from large object */
+ {"write", (PyCFunction) pglarge_write, 1}, /* writes to large object */
+ {"seek", (PyCFunction) pglarge_lseek, 1}, /* seeks position */
+ {"size", (PyCFunction) pglarge_size, 1}, /* gives object size */
+ {"tell", (PyCFunction) pglarge_tell, 1}, /* gives position in lobj */
+ {"export", (PyCFunction) pglarge_export, 1}, /* exports to unix file */
+ {"unlink", (PyCFunction) pglarge_unlink, 1}, /* deletes a large
+ * object */
+ {NULL, NULL} /* sentinel */
};
/* get attribute */
/* attributes list */
if (!strcmp(name, "__members__"))
{
- PyObject *list = PyList_New(3);
+ PyObject *list = PyList_New(3);
if (list)
{
/* object type definition */
staticforward PyTypeObject PglargeType = {
PyObject_HEAD_INIT(&PyType_Type)
- 0, /* ob_size */
- "pglarge", /* tp_name */
- sizeof(pglargeobject), /* tp_basicsize */
- 0, /* tp_itemsize */
+ 0, /* ob_size */
+ "pglarge", /* tp_name */
+ sizeof(pglargeobject), /* tp_basicsize */
+ 0, /* tp_itemsize */
/* methods */
- (destructor) pglarge_dealloc, /* tp_dealloc */
- 0, /* tp_print */
- (getattrfunc) pglarge_getattr, /* tp_getattr */
- 0, /* tp_setattr */
- 0, /* tp_compare */
- 0, /* tp_repr */
- 0, /* tp_as_number */
- 0, /* tp_as_sequence */
- 0, /* tp_as_mapping */
- 0, /* tp_hash */
+ (destructor) pglarge_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ (getattrfunc) pglarge_getattr, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
};
#endif /* LARGE_OBJECTS */
static PyObject *
pgconnect(pgobject * self, PyObject * args, PyObject * dict)
{
- char *pghost, *pgopt, *pgtty, *pgdbname;
- int pgport;
- char port_buffer[20];
- PyObject *temp;
- pgobject *npgobj;
- PGconn *test_cnx;
+ char *pghost,
+ *pgopt,
+ *pgtty,
+ *pgdbname;
+ int pgport;
+ char port_buffer[20];
+ PyObject *temp;
+ pgobject *npgobj;
+ PGconn *test_cnx;
pghost = pgopt = pgtty = pgdbname = NULL;
pgport = -1;
/* parses standard arguments */
if (!PyArg_ParseTuple(args, "|zzlzz",
- &pgdbname, &pghost, &pgport, &pgopt, &pgtty))
+ &pgdbname, &pghost, &pgport, &pgopt, &pgtty))
{
PyErr_Clear();
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_TypeError,
- "connect(dbname, host, port, opt, tty), "
+ "connect(dbname, host, port, opt, tty), "
"with args (opt., strings or None).");
return NULL;
}
if (pghost)
{
PyErr_SetString(PyExc_SyntaxError,
- "Duplicate argument definition.");
+ "Duplicate argument definition.");
return NULL;
}
if (!PyString_Check(temp))
{
PyErr_SetString(PyExc_TypeError,
- "'Host' argument must be a string.");
+ "'Host' argument must be a string.");
return NULL;
}
if (pgport != -1)
{
PyErr_SetString(PyExc_SyntaxError,
- "Duplicate argument definition.");
+ "Duplicate argument definition.");
return NULL;
}
if (!PyInt_Check(temp))
{
PyErr_SetString(PyExc_TypeError,
- "'Port' argument must be an integer.");
+ "'Port' argument must be an integer.");
return NULL;
}
if (pgtty)
{
PyErr_SetString(PyExc_SyntaxError,
- "Duplicate argument definition.");
+ "Duplicate argument definition.");
return NULL;
}
if (!PyString_Check(temp))
{
PyErr_SetString(PyExc_TypeError,
- "'opt' argument must be a string.");
+ "'opt' argument must be a string.");
return NULL;
}
if (pgtty)
{
PyErr_SetString(PyExc_SyntaxError,
- "Duplicate argument definition.");
+ "Duplicate argument definition.");
return NULL;
}
if (!PyString_Check(temp))
{
PyErr_SetString(PyExc_TypeError,
- "'tty' argument must be a string.");
+ "'tty' argument must be a string.");
return NULL;
}
if (pgdbname)
{
PyErr_SetString(PyExc_SyntaxError,
- "Duplicate argument definition.");
+ "Duplicate argument definition.");
return NULL;
}
if (!PyString_Check(temp))
{
PyErr_SetString(PyExc_TypeError,
- "'dbname' argument must be a string.");
+ "'dbname' argument must be a string.");
return NULL;
}
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
- "method reset() takes no parameters.");
+ "method reset() takes no parameters.");
return NULL;
}
static PyObject *
pg_listfields(pgqueryobject * self, PyObject * args)
{
- int i, n;
- char *name;
- PyObject *fieldstuple, *str;
+ int i,
+ n;
+ char *name;
+ PyObject *fieldstuple,
+ *str;
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
- "method listfields() takes no parameters.");
+ "method listfields() takes no parameters.");
return NULL;
}
static PyObject *
pg_fieldname(pgqueryobject * self, PyObject * args)
{
- int i;
- char *name;
+ int i;
+ char *name;
/* gets args */
if (!PyArg_ParseTuple(args, "i", &i))
{
PyErr_SetString(PyExc_TypeError,
- "fieldname(number), with number(integer).");
+ "fieldname(number), with number(integer).");
return NULL;
}
static PyObject *
pg_fieldnum(pgqueryobject * self, PyObject * args)
{
- char *name;
- int num;
+ char *name;
+ int num;
/* gets args */
if (!PyArg_ParseTuple(args, "s", &name))
static PyObject *
pg_getresult(pgqueryobject * self, PyObject * args)
{
- PyObject *rowtuple, *reslist, *str;
- int i, j, m, n;
+ PyObject *rowtuple,
+ *reslist,
+ *str;
+ int i,
+ j,
+ m,
+ n;
/* checks args (args == NULL for an internal call) */
if ((args != NULL) && (!PyArg_ParseTuple(args, "")))
{
PyErr_SetString(PyExc_SyntaxError,
- "method getresult() takes no parameters.");
+ "method getresult() takes no parameters.");
return NULL;
}
static PyObject *
pg_getnotify(pgobject * self, PyObject * args)
{
- PGnotify *notify;
- PGresult *result;
- PyObject *notify_result, *temp;
+ PGnotify *notify;
+ PGresult *result;
+ PyObject *notify_result,
+ *temp;
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
- "method getnotify() takes no parameters.");
+ "method getnotify() takes no parameters.");
return NULL;
}
/* gets notify and builds result */
- /* notifies only come back as result of a query, so I send an empty query */
+
+ /*
+ * notifies only come back as result of a query, so I send an empty
+ * query
+ */
result = PQexec(self->cnx, " ");
if ((notify = PQnotifies(self->cnx)) != NULL)
static PyObject *
pg_query(pgobject * self, PyObject * args)
{
- char *query;
- PGresult *result;
- PyObject *rowtuple, *reslist, *str;
- pgqueryobject *npgobj;
- int i, j, m, n, status;
+ char *query;
+ PGresult *result;
+ PyObject *rowtuple,
+ *reslist,
+ *str;
+ pgqueryobject *npgobj;
+ int i,
+ j,
+ m,
+ n,
+ status;
/* get query args */
if (!PyArg_ParseTuple(args, "s", &query))
break;
case PGRES_BAD_RESPONSE:
PyErr_SetString(PGError,
- "unexpected responsed received from server.");
+ "unexpected responsed received from server.");
break;
case PGRES_FATAL_ERROR:
PyErr_SetString(PGError,
- "server fatal error. "
- "Please report to your db administrator.");
+ "server fatal error. "
+ "Please report to your db administrator.");
break;
case PGRES_NONFATAL_ERROR:
PyErr_SetString(PGError, "server (non fatal) error.");
break;
- case PGRES_COMMAND_OK: /* no data will be received */
+ case PGRES_COMMAND_OK: /* no data will be received */
case PGRES_COPY_OUT:
case PGRES_COPY_IN:
Py_INCREF(Py_None);
return Py_None;
default:
PyErr_SetString(PGError, "internal error: "
- "unknown result status.");
+ "unknown result status.");
break;
}
static PyObject *
pg_putline(pgobject * self, PyObject * args)
{
- char *line;
+ char *line;
/* reads args */
if (!PyArg_ParseTuple(args, "s", &line))
static PyObject *
pg_getline(pgobject * self, PyObject * args)
{
- char *line;
- PyObject *str;
- int ret;
+ char *line;
+ PyObject *str;
+ int ret;
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
- "method getline() takes no parameters.");
+ "method getline() takes no parameters.");
return NULL;
}
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
- "method endcopy() takes no parameters.");
+ "method endcopy() takes no parameters.");
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
+
#endif /* DIRECT_ACCESS */
static PyObject *
-pg_print(pgqueryobject *self, FILE *fp, int flags)
+pg_print(pgqueryobject * self, FILE *fp, int flags)
{
- PQprintOpt op;
+ PQprintOpt op;
memset(&op, 0, sizeof(op));
- op.align = 1;
+ op.align = 1;
op.header = 1;
op.fieldSep = "|";
op.pager = 1;
static PyObject *
pg_inserttable(pgobject * self, PyObject * args)
{
- PGresult *result;
- char *table, *buffer, *temp;
- char temp_buffer[256];
- PyObject *list, *sublist, *item;
- PyObject *(*getitem) (PyObject *, int);
- PyObject *(*getsubitem) (PyObject *, int);
- int i, j;
+ PGresult *result;
+ char *table,
+ *buffer,
+ *temp;
+ char temp_buffer[256];
+ PyObject *list,
+ *sublist,
+ *item;
+ PyObject *(*getitem) (PyObject *, int);
+ PyObject *(*getsubitem) (PyObject *, int);
+ int i,
+ j;
/* gets arguments */
if (!PyArg_ParseTuple(args, "sO:filter", &table, &list))
{
PyErr_SetString(PyExc_TypeError,
- "tableinsert(table, content), with table (string) "
- "and content (list).");
+ "tableinsert(table, content), with table (string) "
+ "and content (list).");
return NULL;
}
else
{
PyErr_SetString(PyExc_TypeError,
- "second arg must be some kind of array.");
+ "second arg must be some kind of array.");
return NULL;
}
if (!PyTuple_Check(sublist) && !PyList_Check(sublist))
{
PyErr_SetString(PyExc_TypeError,
- "second arg must contain some kind of arrays.");
+ "second arg must contain some kind of arrays.");
return NULL;
}
}
PyArg_ParseTuple(item, "s", &temp);
else if (PyInt_Check(item))
{
- int k;
+ int k;
PyArg_ParseTuple(item, "i", &k);
sprintf(temp_buffer, "%d", k);
}
else if (PyLong_Check(item))
{
- long k;
+ long k;
PyArg_ParseTuple(item, "l", &k);
sprintf(temp_buffer, "%ld", k);
}
else if (PyFloat_Check(item))
{
- double k;
+ double k;
PyArg_ParseTuple(item, "d", &k);
sprintf(temp_buffer, "%g", k);
{
free(buffer);
PyErr_SetString(PyExc_ValueError,
- "items must be strings, integers, "
- "longs or double (real).");
+ "items must be strings, integers, "
+ "longs or double (real).");
return NULL;
}
/* connection object methods */
static struct PyMethodDef pgobj_methods[] = {
- {"query", (PyCFunction) pg_query, 1}, /* query method */
- {"reset", (PyCFunction) pg_reset, 1}, /* connection reset */
- {"getnotify", (PyCFunction) pg_getnotify, 1}, /* checks for notify */
- {"inserttable", (PyCFunction) pg_inserttable, 1}, /* table insert */
+ {"query", (PyCFunction) pg_query, 1}, /* query method */
+ {"reset", (PyCFunction) pg_reset, 1}, /* connection reset */
+ {"getnotify", (PyCFunction) pg_getnotify, 1}, /* checks for notify */
+ {"inserttable", (PyCFunction) pg_inserttable, 1}, /* table insert */
#ifdef DIRECT_ACCESS
- {"putline", (PyCFunction) pg_putline, 1}, /* direct access: putline */
- {"getline", (PyCFunction) pg_getline, 1}, /* direct access: getline */
- {"endcopy", (PyCFunction) pg_endcopy, 1}, /* direct access: endcopy */
+ {"putline", (PyCFunction) pg_putline, 1}, /* direct access: putline */
+ {"getline", (PyCFunction) pg_getline, 1}, /* direct access: getline */
+ {"endcopy", (PyCFunction) pg_endcopy, 1}, /* direct access: endcopy */
#endif /* DIRECT_ACCESS */
#ifdef LARGE_OBJECTS
- {"locreate", (PyCFunction) pg_locreate, 1}, /* creates large object */
- {"getlo", (PyCFunction) pg_getlo, 1}, /* get lo from oid */
- {"loimport", (PyCFunction) pg_loimport, 1}, /* imports lo from file */
+ {"locreate", (PyCFunction) pg_locreate, 1}, /* creates large object */
+ {"getlo", (PyCFunction) pg_getlo, 1}, /* get lo from oid */
+ {"loimport", (PyCFunction) pg_loimport, 1}, /* imports lo from file */
#endif /* LARGE_OBJECTS */
{NULL, NULL} /* sentinel */
/* attributes list */
if (!strcmp(name, "__members__"))
{
- PyObject *list = PyList_New(8);
+ PyObject *list = PyList_New(8);
if (list)
{
/* query object methods */
static struct PyMethodDef pgquery_methods[] = {
- {"getresult", (PyCFunction) pg_getresult, 1}, /* get last result */
- {"fieldname", (PyCFunction) pg_fieldname, 1}, /* get field name */
- {"fieldnum", (PyCFunction) pg_fieldnum, 1}, /* get field number */
- {"listfields", (PyCFunction) pg_listfields, 1}, /* list fields names */
+ {"getresult", (PyCFunction) pg_getresult, 1}, /* get last result */
+ {"fieldname", (PyCFunction) pg_fieldname, 1}, /* get field name */
+ {"fieldnum", (PyCFunction) pg_fieldnum, 1}, /* get field number */
+ {"listfields", (PyCFunction) pg_listfields, 1}, /* list fields names */
{NULL, NULL} /* sentinel */
};
sizeof(pgqueryobject), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
- (destructor) pg_querydealloc,/* tp_dealloc */
+ (destructor) pg_querydealloc, /* tp_dealloc */
(printfunc) pg_print, /* tp_print */
- (getattrfunc) pg_querygetattr,/* tp_getattr */
+ (getattrfunc) pg_querygetattr, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
#ifdef DEFAULT_VARS
/* gets default host */
-PyObject *
-pggetdefhost(PyObject *self, PyObject *args)
+PyObject *
+pggetdefhost(PyObject * self, PyObject * args)
{
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
- "method get_defhost() takes no parameter.");
+ "method get_defhost() takes no parameter.");
return NULL;
}
}
/* sets default host */
-PyObject *
-pgsetdefhost(PyObject * self, PyObject *args)
+PyObject *
+pgsetdefhost(PyObject * self, PyObject * args)
{
- char *temp = NULL;
- PyObject *old;
+ char *temp = NULL;
+ PyObject *old;
/* gets arguments */
if (!PyArg_ParseTuple(args, "z", &temp))
{
PyErr_SetString(PyExc_TypeError,
- "set_defhost(name), with name (string/None).");
+ "set_defhost(name), with name (string/None).");
return NULL;
}
}
/* gets default base */
-PyObject *
-pggetdefbase(PyObject * self, PyObject *args)
+PyObject *
+pggetdefbase(PyObject * self, PyObject * args)
{
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
- "method get_defbase() takes no parameter.");
+ "method get_defbase() takes no parameter.");
return NULL;
}
}
/* sets default base */
-PyObject *
-pgsetdefbase(PyObject * self, PyObject *args)
+PyObject *
+pgsetdefbase(PyObject * self, PyObject * args)
{
- char *temp = NULL;
- PyObject *old;
+ char *temp = NULL;
+ PyObject *old;
/* gets arguments */
if (!PyArg_ParseTuple(args, "z", &temp))
{
PyErr_SetString(PyExc_TypeError,
- "set_defbase(name), with name (string/None).");
+ "set_defbase(name), with name (string/None).");
return NULL;
}
}
/* gets default options */
-PyObject *
-pggetdefopt(PyObject * self, PyObject *args)
+PyObject *
+pggetdefopt(PyObject * self, PyObject * args)
{
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
- "method get_defopt() takes no parameter.");
+ "method get_defopt() takes no parameter.");
return NULL;
}
}
/* sets default opt */
-PyObject *
-pgsetdefopt(PyObject * self, PyObject *args)
+PyObject *
+pgsetdefopt(PyObject * self, PyObject * args)
{
- char *temp = NULL;
- PyObject *old;
+ char *temp = NULL;
+ PyObject *old;
/* gets arguments */
if (!PyArg_ParseTuple(args, "z", &temp))
{
PyErr_SetString(PyExc_TypeError,
- "set_defopt(name), with name (string/None).");
+ "set_defopt(name), with name (string/None).");
return NULL;
}
}
/* gets default tty */
-PyObject *
-pggetdeftty(PyObject * self, PyObject *args)
+PyObject *
+pggetdeftty(PyObject * self, PyObject * args)
{
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
- "method get_deftty() takes no parameter.");
+ "method get_deftty() takes no parameter.");
return NULL;
}
}
/* sets default tty */
-PyObject *
-pgsetdeftty(PyObject * self, PyObject *args)
+PyObject *
+pgsetdeftty(PyObject * self, PyObject * args)
{
- char *temp = NULL;
- PyObject *old;
+ char *temp = NULL;
+ PyObject *old;
/* gets arguments */
if (!PyArg_ParseTuple(args, "z", &temp))
{
PyErr_SetString(PyExc_TypeError,
- "set_deftty(name), with name (string/None).");
+ "set_deftty(name), with name (string/None).");
return NULL;
}
}
/* gets default port */
-PyObject *
-pggetdefport(PyObject * self, PyObject *args)
+PyObject *
+pggetdefport(PyObject * self, PyObject * args)
{
- char *temp;
+ char *temp;
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
- "method get_defport() takes no parameter.");
+ "method get_defport() takes no parameter.");
return NULL;
}
}
/* sets default port */
-PyObject *
-pgsetdefport(PyObject * self, PyObject *args)
+PyObject *
+pgsetdefport(PyObject * self, PyObject * args)
{
- long int port = -2;
- char buffer[64], *temp;
- PyObject *old;
+ long int port = -2;
+ char buffer[64],
+ *temp;
+ PyObject *old;
/* gets arguments */
if ((!PyArg_ParseTuple(args, "l", &port)) || (port < -1))
{
PyErr_SetString(PyExc_TypeError, "set_defport(port), with port "
- "(positive integer/-1).");
+ "(positive integer/-1).");
return NULL;
}
/* List of functions defined in the module */
static struct PyMethodDef pg_methods[] = {
- {"connect", (PyCFunction) pgconnect, 3},/* connect to a postgres database */
+ {"connect", (PyCFunction) pgconnect, 3}, /* connect to a postgres
+ * database */
#ifdef DEFAULT_VARS
- {"get_defhost", pggetdefhost, 1}, /* gets default host */
- {"set_defhost", pgsetdefhost, 1}, /* sets default host */
- {"get_defbase", pggetdefbase, 1}, /* gets default base */
- {"set_defbase", pgsetdefbase, 1}, /* sets default base */
- {"get_defopt", pggetdefopt, 1}, /* gets default options */
- {"set_defopt", pgsetdefopt, 1}, /* sets default options */
- {"get_deftty", pggetdeftty, 1}, /* gets default debug tty */
- {"set_deftty", pgsetdeftty, 1}, /* sets default debug tty */
- {"get_defport", pggetdefport, 1}, /* gets default port */
- {"set_defport", pgsetdefport, 1}, /* sets default port */
+ {"get_defhost", pggetdefhost, 1}, /* gets default host */
+ {"set_defhost", pgsetdefhost, 1}, /* sets default host */
+ {"get_defbase", pggetdefbase, 1}, /* gets default base */
+ {"set_defbase", pgsetdefbase, 1}, /* sets default base */
+ {"get_defopt", pggetdefopt, 1}, /* gets default options */
+ {"set_defopt", pgsetdefopt, 1}, /* sets default options */
+ {"get_deftty", pggetdeftty, 1}, /* gets default debug tty */
+ {"set_deftty", pgsetdeftty, 1}, /* sets default debug tty */
+ {"get_defport", pggetdefport, 1}, /* gets default port */
+ {"set_defport", pgsetdefport, 1}, /* sets default port */
#endif /* DEFAULT_VARS */
{NULL, NULL} /* sentinel */
};
-static char pg__doc__[] = "Python interface to PostgreSQL DB";
+static char pg__doc__[] = "Python interface to PostgreSQL DB";
/* Initialization function for the module */
void
initpg(void)
{
- PyObject *mod, *dict;
+ PyObject *mod,
+ *dict;
/* Create the module and add the functions */
mod = Py_InitModule4("pg", pg_methods, pg__doc__, NULL, PYTHON_API_VERSION);
#ifdef DEFAULT_VARS
/* prepares default values */
- Py_INCREF(Py_None); pg_default_host = Py_None;
- Py_INCREF(Py_None); pg_default_base = Py_None;
- Py_INCREF(Py_None); pg_default_opt = Py_None;
- Py_INCREF(Py_None); pg_default_port = Py_None;
- Py_INCREF(Py_None); pg_default_tty = Py_None;
+ Py_INCREF(Py_None);
+ pg_default_host = Py_None;
+ Py_INCREF(Py_None);
+ pg_default_base = Py_None;
+ Py_INCREF(Py_None);
+ pg_default_opt = Py_None;
+ Py_INCREF(Py_None);
+ pg_default_port = Py_None;
+ Py_INCREF(Py_None);
+ pg_default_tty = Py_None;
#endif /* DEFAULT_VARS */
/* Check for errors */
* procedural language (PL)
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/tcl/pltcl.c,v 1.1 1998/02/11 14:07:59 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/pl/tcl/pltcl.c,v 1.2 1998/02/26 04:46:10 momjian Exp $
*
- * This software is copyrighted by Jan Wieck - Hamburg.
+ * This software is copyrighted by Jan Wieck - Hamburg.
*
- * The author hereby grants permission to use, copy, modify,
- * distribute, and license this software and its documentation
- * for any purpose, provided that existing copyright notices are
- * retained in all copies and that this notice is included
- * verbatim in any distributions. No written agreement, license,
- * or royalty fee is required for any of the authorized uses.
- * Modifications to this software may be copyrighted by their
- * author and need not follow the licensing terms described
- * here, provided that the new terms are clearly indicated on
- * the first page of each file where they apply.
+ * The author hereby grants permission to use, copy, modify,
+ * distribute, and license this software and its documentation
+ * for any purpose, provided that existing copyright notices are
+ * retained in all copies and that this notice is included
+ * verbatim in any distributions. No written agreement, license,
+ * or royalty fee is required for any of the authorized uses.
+ * Modifications to this software may be copyrighted by their
+ * author and need not follow the licensing terms described
+ * here, provided that the new terms are clearly indicated on
+ * the first page of each file where they apply.
*
- * IN NO EVENT SHALL THE AUTHOR OR DISTRIBUTORS BE LIABLE TO ANY
- * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR
- * CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS
- * SOFTWARE, ITS DOCUMENTATION, OR ANY DERIVATIVES THEREOF, EVEN
- * IF THE AUTHOR HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
+ * IN NO EVENT SHALL THE AUTHOR OR DISTRIBUTORS BE LIABLE TO ANY
+ * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR
+ * CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS
+ * SOFTWARE, ITS DOCUMENTATION, OR ANY DERIVATIVES THEREOF, EVEN
+ * IF THE AUTHOR HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
*
- * THE AUTHOR AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
- * PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE IS PROVIDED ON
- * AN "AS IS" BASIS, AND THE AUTHOR AND DISTRIBUTORS HAVE NO
- * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
- * ENHANCEMENTS, OR MODIFICATIONS.
+ * THE AUTHOR AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+ * PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE IS PROVIDED ON
+ * AN "AS IS" BASIS, AND THE AUTHOR AND DISTRIBUTORS HAVE NO
+ * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
+ * ENHANCEMENTS, OR MODIFICATIONS.
*
**********************************************************************/
/**********************************************************************
* The information we cache about loaded procedures
**********************************************************************/
-typedef struct pltcl_proc_desc {
- char *proname;
- FmgrInfo result_in_func;
- Oid result_in_elem;
- int result_in_len;
- int nargs;
- FmgrInfo arg_out_func[MAXFMGRARGS];
- Oid arg_out_elem[MAXFMGRARGS];
- int arg_out_len[MAXFMGRARGS];
- int arg_is_rel[MAXFMGRARGS];
-} pltcl_proc_desc;
+typedef struct pltcl_proc_desc
+{
+ char *proname;
+ FmgrInfo result_in_func;
+ Oid result_in_elem;
+ int result_in_len;
+ int nargs;
+ FmgrInfo arg_out_func[MAXFMGRARGS];
+ Oid arg_out_elem[MAXFMGRARGS];
+ int arg_out_len[MAXFMGRARGS];
+ int arg_is_rel[MAXFMGRARGS];
+} pltcl_proc_desc;
/**********************************************************************
* The information we cache about prepared and saved plans
**********************************************************************/
-typedef struct pltcl_query_desc {
- char qname[20];
- void *plan;
- int nargs;
- Oid *argtypes;
- FmgrInfo *arginfuncs;
- Oid *argtypelems;
- Datum *argvalues;
- int *arglen;
-} pltcl_query_desc;
+typedef struct pltcl_query_desc
+{
+ char qname[20];
+ void *plan;
+ int nargs;
+ Oid *argtypes;
+ FmgrInfo *arginfuncs;
+ Oid *argtypelems;
+ Datum *argvalues;
+ int *arglen;
+} pltcl_query_desc;
/************************************************************
* It's ugly - Jan
************************************************************/
#if defined(nextstep)
-#define sigjmp_buf jmp_buf
+#define sigjmp_buf jmp_buf
#define sigsetjmp(x,y) setjmp(x)
#define siglongjmp longjmp
#endif
-extern sigjmp_buf Warn_restart; /* in tcop/postgres.c */
+extern sigjmp_buf Warn_restart; /* in tcop/postgres.c */
/**********************************************************************
* Global data
**********************************************************************/
-static int pltcl_firstcall = 1;
-static int pltcl_call_level = 0;
-static int pltcl_restart_in_progress = 0;
-static Tcl_Interp *pltcl_hold_interp = NULL;
-static Tcl_Interp *pltcl_safe_interp = NULL;
-static Tcl_HashTable *pltcl_proc_hash = NULL;
-static Tcl_HashTable *pltcl_query_hash = NULL;
+static int pltcl_firstcall = 1;
+static int pltcl_call_level = 0;
+static int pltcl_restart_in_progress = 0;
+static Tcl_Interp *pltcl_hold_interp = NULL;
+static Tcl_Interp *pltcl_safe_interp = NULL;
+static Tcl_HashTable *pltcl_proc_hash = NULL;
+static Tcl_HashTable *pltcl_query_hash = NULL;
/**********************************************************************
* Forward declarations
#ifdef PLTCL_UNKNOWN_SUPPORT
static void pltcl_init_load_unknown(void);
-#endif /* PLTCL_UNKNOWN_SUPPORT */
-Datum pltcl_call_handler(FmgrInfo *proinfo,
- FmgrValues *proargs, bool *isNull);
+#endif /* PLTCL_UNKNOWN_SUPPORT */
+
+Datum
+pltcl_call_handler(FmgrInfo *proinfo,
+ FmgrValues *proargs, bool *isNull);
-static Datum pltcl_func_handler(FmgrInfo *proinfo,
- FmgrValues *proargs, bool *isNull);
+static Datum
+pltcl_func_handler(FmgrInfo *proinfo,
+ FmgrValues *proargs, bool *isNull);
static HeapTuple pltcl_trigger_handler(FmgrInfo *proinfo);
-static int pltcl_elog(ClientData cdata, Tcl_Interp *interp,
- int argc, char *argv[]);
-static int pltcl_quote(ClientData cdata, Tcl_Interp *interp,
- int argc, char *argv[]);
-
-static int pltcl_SPI_exec(ClientData cdata, Tcl_Interp *interp,
- int argc, char *argv[]);
-static int pltcl_SPI_prepare(ClientData cdata, Tcl_Interp *interp,
- int argc, char *argv[]);
-static int pltcl_SPI_execp(ClientData cdata, Tcl_Interp *interp,
- int argc, char *argv[]);
-
-static void pltcl_set_tuple_values(Tcl_Interp *interp, char *arrayname,
- int tupno, HeapTuple tuple, TupleDesc tupdesc);
-static void pltcl_build_tuple_argument(HeapTuple tuple, TupleDesc tupdesc,
- Tcl_DString *retval);
-
+static int
+pltcl_elog(ClientData cdata, Tcl_Interp * interp,
+ int argc, char *argv[]);
+static int
+pltcl_quote(ClientData cdata, Tcl_Interp * interp,
+ int argc, char *argv[]);
+
+static int
+pltcl_SPI_exec(ClientData cdata, Tcl_Interp * interp,
+ int argc, char *argv[]);
+static int
+pltcl_SPI_prepare(ClientData cdata, Tcl_Interp * interp,
+ int argc, char *argv[]);
+static int
+pltcl_SPI_execp(ClientData cdata, Tcl_Interp * interp,
+ int argc, char *argv[]);
+
+static void
+pltcl_set_tuple_values(Tcl_Interp * interp, char *arrayname,
+ int tupno, HeapTuple tuple, TupleDesc tupdesc);
+static void
+pltcl_build_tuple_argument(HeapTuple tuple, TupleDesc tupdesc,
+ Tcl_DString * retval);
+
/**********************************************************************
* pltcl_init_all() - Initialize all
**********************************************************************/
static void
pltcl_init_all(void)
{
- Tcl_HashEntry *hashent;
- Tcl_HashSearch hashsearch;
- pltcl_proc_desc *prodesc;
- pltcl_query_desc *querydesc;
-
- /************************************************************
- * Do initialization only once
- ************************************************************/
- if (!pltcl_firstcall) return;
-
- /************************************************************
- * Create the dummy hold interpreter to prevent close of
- * stdout and stderr on DeleteInterp
- ************************************************************/
- if (pltcl_hold_interp == NULL) {
- if ((pltcl_hold_interp = Tcl_CreateInterp()) == NULL) {
- elog(ERROR, "pltcl: internal error - cannot create 'hold' "
- "interpreter");
- }
- }
-
- /************************************************************
- * Destroy the existing safe interpreter
- ************************************************************/
- if (pltcl_safe_interp != NULL) {
- Tcl_DeleteInterp(pltcl_safe_interp);
- pltcl_safe_interp = NULL;
- }
-
- /************************************************************
- * Free the proc hash table
- ************************************************************/
- if (pltcl_proc_hash != NULL) {
- hashent = Tcl_FirstHashEntry(pltcl_proc_hash, &hashsearch);
- while (hashent != NULL) {
- prodesc = (pltcl_proc_desc *)Tcl_GetHashValue(hashent);
- free(prodesc->proname);
- free(prodesc);
- hashent = Tcl_NextHashEntry(&hashsearch);
- }
- Tcl_DeleteHashTable(pltcl_proc_hash);
- free(pltcl_proc_hash);
- pltcl_proc_hash = NULL;
- }
-
- /************************************************************
- * Free the prepared query hash table
- ************************************************************/
- if (pltcl_query_hash != NULL) {
- hashent = Tcl_FirstHashEntry(pltcl_query_hash, &hashsearch);
- while (hashent != NULL) {
- querydesc = (pltcl_query_desc *)Tcl_GetHashValue(hashent);
- free(querydesc->argtypes);
- free(querydesc);
- hashent = Tcl_NextHashEntry(&hashsearch);
- }
- Tcl_DeleteHashTable(pltcl_query_hash);
- free(pltcl_query_hash);
- pltcl_query_hash = NULL;
- }
-
- /************************************************************
- * Now recreate a new safe interpreter
- ************************************************************/
- pltcl_init_safe_interp();
-
- pltcl_firstcall = 0;
- return;
+ Tcl_HashEntry *hashent;
+ Tcl_HashSearch hashsearch;
+ pltcl_proc_desc *prodesc;
+ pltcl_query_desc *querydesc;
+
+ /************************************************************
+ * Do initialization only once
+ ************************************************************/
+ if (!pltcl_firstcall)
+ return;
+
+ /************************************************************
+ * Create the dummy hold interpreter to prevent close of
+ * stdout and stderr on DeleteInterp
+ ************************************************************/
+ if (pltcl_hold_interp == NULL)
+ {
+ if ((pltcl_hold_interp = Tcl_CreateInterp()) == NULL)
+ {
+ elog(ERROR, "pltcl: internal error - cannot create 'hold' "
+ "interpreter");
+ }
+ }
+
+ /************************************************************
+ * Destroy the existing safe interpreter
+ ************************************************************/
+ if (pltcl_safe_interp != NULL)
+ {
+ Tcl_DeleteInterp(pltcl_safe_interp);
+ pltcl_safe_interp = NULL;
+ }
+
+ /************************************************************
+ * Free the proc hash table
+ ************************************************************/
+ if (pltcl_proc_hash != NULL)
+ {
+ hashent = Tcl_FirstHashEntry(pltcl_proc_hash, &hashsearch);
+ while (hashent != NULL)
+ {
+ prodesc = (pltcl_proc_desc *) Tcl_GetHashValue(hashent);
+ free(prodesc->proname);
+ free(prodesc);
+ hashent = Tcl_NextHashEntry(&hashsearch);
+ }
+ Tcl_DeleteHashTable(pltcl_proc_hash);
+ free(pltcl_proc_hash);
+ pltcl_proc_hash = NULL;
+ }
+
+ /************************************************************
+ * Free the prepared query hash table
+ ************************************************************/
+ if (pltcl_query_hash != NULL)
+ {
+ hashent = Tcl_FirstHashEntry(pltcl_query_hash, &hashsearch);
+ while (hashent != NULL)
+ {
+ querydesc = (pltcl_query_desc *) Tcl_GetHashValue(hashent);
+ free(querydesc->argtypes);
+ free(querydesc);
+ hashent = Tcl_NextHashEntry(&hashsearch);
+ }
+ Tcl_DeleteHashTable(pltcl_query_hash);
+ free(pltcl_query_hash);
+ pltcl_query_hash = NULL;
+ }
+
+ /************************************************************
+ * Now recreate a new safe interpreter
+ ************************************************************/
+ pltcl_init_safe_interp();
+
+ pltcl_firstcall = 0;
+ return;
}
/**********************************************************************
- * pltcl_init_safe_interp() - Create the safe Tcl interpreter
+ * pltcl_init_safe_interp() - Create the safe Tcl interpreter
**********************************************************************/
static void
pltcl_init_safe_interp(void)
{
- /************************************************************
- * Create the interpreter as a safe slave of the hold interp.
- ************************************************************/
- if ((pltcl_safe_interp =
- Tcl_CreateSlave(pltcl_hold_interp, "safe", 1)) == NULL) {
- elog(ERROR,
- "pltcl: internal error - cannot create 'safe' interpreter");
- }
-
- /************************************************************
- * Enable debugging output from the Tcl bytecode compiler
- * To see the trace, the interpreter must be created unsafe
- * USE ONLY FOR DEBUGGING!!!
- ************************************************************/
- /*
- Tcl_SetVar(pltcl_safe_interp, "tcl_traceCompile", "1", 0);
- */
-
- /************************************************************
- * Initialize the proc and query hash tables
- ************************************************************/
- pltcl_proc_hash = (Tcl_HashTable *)malloc(sizeof(Tcl_HashTable));
- pltcl_query_hash = (Tcl_HashTable *)malloc(sizeof(Tcl_HashTable));
- Tcl_InitHashTable(pltcl_proc_hash, TCL_STRING_KEYS);
- Tcl_InitHashTable(pltcl_query_hash, TCL_STRING_KEYS);
-
- /************************************************************
- * Install the commands for SPI support in the safe interpreter
- ************************************************************/
- Tcl_CreateCommand(pltcl_safe_interp, "elog",
- pltcl_elog, NULL, NULL);
- Tcl_CreateCommand(pltcl_safe_interp, "quote",
- pltcl_quote, NULL, NULL);
-
- Tcl_CreateCommand(pltcl_safe_interp, "spi_exec",
- pltcl_SPI_exec, NULL, NULL);
- Tcl_CreateCommand(pltcl_safe_interp, "spi_prepare",
- pltcl_SPI_prepare, NULL, NULL);
- Tcl_CreateCommand(pltcl_safe_interp, "spi_execp",
- pltcl_SPI_execp, NULL, NULL);
+ /************************************************************
+ * Create the interpreter as a safe slave of the hold interp.
+ ************************************************************/
+ if ((pltcl_safe_interp =
+ Tcl_CreateSlave(pltcl_hold_interp, "safe", 1)) == NULL)
+ {
+ elog(ERROR,
+ "pltcl: internal error - cannot create 'safe' interpreter");
+ }
+
+ /************************************************************
+ * Enable debugging output from the Tcl bytecode compiler
+ * To see the trace, the interpreter must be created unsafe
+ * USE ONLY FOR DEBUGGING!!!
+ ************************************************************/
+
+ /*
+ * Tcl_SetVar(pltcl_safe_interp, "tcl_traceCompile", "1", 0);
+ */
+
+ /************************************************************
+ * Initialize the proc and query hash tables
+ ************************************************************/
+ pltcl_proc_hash = (Tcl_HashTable *) malloc(sizeof(Tcl_HashTable));
+ pltcl_query_hash = (Tcl_HashTable *) malloc(sizeof(Tcl_HashTable));
+ Tcl_InitHashTable(pltcl_proc_hash, TCL_STRING_KEYS);
+ Tcl_InitHashTable(pltcl_query_hash, TCL_STRING_KEYS);
+
+ /************************************************************
+ * Install the commands for SPI support in the safe interpreter
+ ************************************************************/
+ Tcl_CreateCommand(pltcl_safe_interp, "elog",
+ pltcl_elog, NULL, NULL);
+ Tcl_CreateCommand(pltcl_safe_interp, "quote",
+ pltcl_quote, NULL, NULL);
+
+ Tcl_CreateCommand(pltcl_safe_interp, "spi_exec",
+ pltcl_SPI_exec, NULL, NULL);
+ Tcl_CreateCommand(pltcl_safe_interp, "spi_prepare",
+ pltcl_SPI_prepare, NULL, NULL);
+ Tcl_CreateCommand(pltcl_safe_interp, "spi_execp",
+ pltcl_SPI_execp, NULL, NULL);
#ifdef PLTCL_UNKNOWN_SUPPORT
- /************************************************************
- * Try to load the unknown procedure from pltcl_modules
- ************************************************************/
- if (SPI_connect() != SPI_OK_CONNECT) {
- elog(ERROR, "pltcl_init_safe_interp(): SPI_connect failed");
- }
- pltcl_init_load_unknown();
- if (SPI_finish() != SPI_OK_FINISH) {
- elog(ERROR, "pltcl_init_safe_interp(): SPI_finish failed");
- }
-#endif /* PLTCL_UNKNOWN_SUPPORT */
+ /************************************************************
+ * Try to load the unknown procedure from pltcl_modules
+ ************************************************************/
+ if (SPI_connect() != SPI_OK_CONNECT)
+ {
+ elog(ERROR, "pltcl_init_safe_interp(): SPI_connect failed");
+ }
+ pltcl_init_load_unknown();
+ if (SPI_finish() != SPI_OK_FINISH)
+ {
+ elog(ERROR, "pltcl_init_safe_interp(): SPI_finish failed");
+ }
+#endif /* PLTCL_UNKNOWN_SUPPORT */
}
static void
pltcl_init_load_unknown(void)
{
- int spi_rc;
- int tcl_rc;
- Tcl_DString unknown_src;
- char *part;
- int i;
- int fno;
-
- /************************************************************
- * Check if table pltcl_modules exists
- ************************************************************/
- spi_rc = SPI_exec("select 1 from pg_class "
- "where relname = 'pltcl_modules'", 1);
- if (spi_rc != SPI_OK_SELECT) {
- elog(ERROR, "pltcl_init_load_unknown(): select from pg_class failed");
- }
- if (SPI_processed == 0) {
- return;
- }
-
- /************************************************************
- * Read all the row's from it where modname = 'unknown' in
- * the order of modseq
- ************************************************************/
- Tcl_DStringInit(&unknown_src);
-
- spi_rc = SPI_exec("select modseq, modsrc from pltcl_modules "
- "where modname = 'unknown' "
- "order by modseq", 0);
- if (spi_rc != SPI_OK_SELECT) {
- elog(ERROR, "pltcl_init_load_unknown(): select from pltcl_modules "
- "failed");
- }
-
- /************************************************************
- * If there's nothing, module unknown doesn't exist
- ************************************************************/
- if (SPI_processed == 0) {
- Tcl_DStringFree(&unknown_src);
- elog(NOTICE, "pltcl: Module unknown not found in pltcl_modules");
- return;
- }
-
- /************************************************************
- * There is a module named unknown. Resemble the
- * source from the modsrc attributes and evaluate
- * it in the safe interpreter
- ************************************************************/
- fno = SPI_fnumber(SPI_tuptable->tupdesc, "modsrc");
-
- for (i = 0; i < SPI_processed; i++) {
- part = SPI_getvalue(SPI_tuptable->vals[i],
- SPI_tuptable->tupdesc, fno);
- if (part != NULL) {
- Tcl_DStringAppend(&unknown_src, part, -1);
- pfree(part);
- }
- }
- tcl_rc = Tcl_GlobalEval(pltcl_safe_interp, Tcl_DStringValue(&unknown_src));
- Tcl_DStringFree(&unknown_src);
+ int spi_rc;
+ int tcl_rc;
+ Tcl_DString unknown_src;
+ char *part;
+ int i;
+ int fno;
+
+ /************************************************************
+ * Check if table pltcl_modules exists
+ ************************************************************/
+ spi_rc = SPI_exec("select 1 from pg_class "
+ "where relname = 'pltcl_modules'", 1);
+ if (spi_rc != SPI_OK_SELECT)
+ {
+ elog(ERROR, "pltcl_init_load_unknown(): select from pg_class failed");
+ }
+ if (SPI_processed == 0)
+ {
+ return;
+ }
+
+ /************************************************************
+ * Read all the row's from it where modname = 'unknown' in
+ * the order of modseq
+ ************************************************************/
+ Tcl_DStringInit(&unknown_src);
+
+ spi_rc = SPI_exec("select modseq, modsrc from pltcl_modules "
+ "where modname = 'unknown' "
+ "order by modseq", 0);
+ if (spi_rc != SPI_OK_SELECT)
+ {
+ elog(ERROR, "pltcl_init_load_unknown(): select from pltcl_modules "
+ "failed");
+ }
+
+ /************************************************************
+ * If there's nothing, module unknown doesn't exist
+ ************************************************************/
+ if (SPI_processed == 0)
+ {
+ Tcl_DStringFree(&unknown_src);
+ elog(NOTICE, "pltcl: Module unknown not found in pltcl_modules");
+ return;
+ }
+
+ /************************************************************
+ * There is a module named unknown. Resemble the
+ * source from the modsrc attributes and evaluate
+ * it in the safe interpreter
+ ************************************************************/
+ fno = SPI_fnumber(SPI_tuptable->tupdesc, "modsrc");
+
+ for (i = 0; i < SPI_processed; i++)
+ {
+ part = SPI_getvalue(SPI_tuptable->vals[i],
+ SPI_tuptable->tupdesc, fno);
+ if (part != NULL)
+ {
+ Tcl_DStringAppend(&unknown_src, part, -1);
+ pfree(part);
+ }
+ }
+ tcl_rc = Tcl_GlobalEval(pltcl_safe_interp, Tcl_DStringValue(&unknown_src));
+ Tcl_DStringFree(&unknown_src);
}
-#endif /* PLTCL_UNKNOWN_SUPPORT */
+#endif /* PLTCL_UNKNOWN_SUPPORT */
/**********************************************************************
* PL/Tcl procedures.
**********************************************************************/
Datum
-pltcl_call_handler(FmgrInfo *proinfo,
- FmgrValues *proargs,
- bool *isNull)
+pltcl_call_handler(FmgrInfo *proinfo,
+ FmgrValues *proargs,
+ bool *isNull)
{
- Datum retval;
-
- /************************************************************
- * Initialize interpreters on first call
- ************************************************************/
- if (pltcl_firstcall) {
- pltcl_init_all();
- }
-
- /************************************************************
- * Connect to SPI manager
- ************************************************************/
- if (SPI_connect() != SPI_OK_CONNECT) {
- elog(ERROR, "pltcl: cannot connect to SPI manager");
- }
- /************************************************************
- * Keep track about the nesting of Tcl-SPI-Tcl-... calls
- ************************************************************/
- pltcl_call_level++;
-
- /************************************************************
- * Determine if called as function or trigger and
- * call appropriate subhandler
- ************************************************************/
- if (CurrentTriggerData == NULL) {
- retval = pltcl_func_handler(proinfo, proargs, isNull);
- } else {
- retval = (Datum)pltcl_trigger_handler(proinfo);
- }
-
- pltcl_call_level--;
-
- /************************************************************
- * Disconnect from SPI manager
- ************************************************************/
- if (SPI_finish() != SPI_OK_FINISH) {
- elog(ERROR, "pltcl: SPI_finish() failed");
- }
-
- return retval;
+ Datum retval;
+
+ /************************************************************
+ * Initialize interpreters on first call
+ ************************************************************/
+ if (pltcl_firstcall)
+ {
+ pltcl_init_all();
+ }
+
+ /************************************************************
+ * Connect to SPI manager
+ ************************************************************/
+ if (SPI_connect() != SPI_OK_CONNECT)
+ {
+ elog(ERROR, "pltcl: cannot connect to SPI manager");
+ }
+ /************************************************************
+ * Keep track about the nesting of Tcl-SPI-Tcl-... calls
+ ************************************************************/
+ pltcl_call_level++;
+
+ /************************************************************
+ * Determine if called as function or trigger and
+ * call appropriate subhandler
+ ************************************************************/
+ if (CurrentTriggerData == NULL)
+ {
+ retval = pltcl_func_handler(proinfo, proargs, isNull);
+ }
+ else
+ {
+ retval = (Datum) pltcl_trigger_handler(proinfo);
+ }
+
+ pltcl_call_level--;
+
+ /************************************************************
+ * Disconnect from SPI manager
+ ************************************************************/
+ if (SPI_finish() != SPI_OK_FINISH)
+ {
+ elog(ERROR, "pltcl: SPI_finish() failed");
+ }
+
+ return retval;
}
* pltcl_func_handler() - Handler for regular function calls
**********************************************************************/
static Datum
-pltcl_func_handler(FmgrInfo *proinfo,
- FmgrValues *proargs,
- bool *isNull)
+pltcl_func_handler(FmgrInfo *proinfo,
+ FmgrValues *proargs,
+ bool *isNull)
{
- int i;
- char internal_proname[512];
- char *stroid;
- Tcl_HashEntry *hashent;
- int hashnew;
- pltcl_proc_desc *prodesc;
- Tcl_DString tcl_cmd;
- Tcl_DString list_tmp;
- int tcl_rc;
- Datum retval;
- sigjmp_buf save_restart;
-
- /************************************************************
- * Build our internal proc name from the functions Oid
- ************************************************************/
- stroid = oidout(proinfo->fn_oid);
- strcpy(internal_proname, "__PLTcl_proc_");
- strcat(internal_proname, stroid);
- pfree(stroid);
-
- /************************************************************
- * Lookup the internal proc name in the hashtable
- ************************************************************/
- hashent = Tcl_FindHashEntry(pltcl_proc_hash, internal_proname);
- if (hashent == NULL) {
- /************************************************************
- * If we haven't found it in the hashtable, we analyze
- * the functions arguments and returntype and store
- * the in-/out-functions in the prodesc block and create
- * a new hashtable entry for it.
- *
- * Then we load the procedure into the safe interpreter.
- ************************************************************/
- HeapTuple procTup;
- HeapTuple typeTup;
- Form_pg_proc procStruct;
- TypeTupleForm typeStruct;
- Tcl_DString proc_internal_def;
- Tcl_DString proc_internal_body;
- char proc_internal_args[4096];
- char *proc_source;
- char buf[512];
-
- /************************************************************
- * Allocate a new procedure description block
- ************************************************************/
- prodesc = (pltcl_proc_desc *)malloc(sizeof(pltcl_proc_desc));
- prodesc->proname = malloc(strlen(internal_proname) + 1);
- strcpy(prodesc->proname, internal_proname);
-
- /************************************************************
- * Lookup the pg_proc tuple by Oid
- ************************************************************/
- procTup = SearchSysCacheTuple(PROOID,
- ObjectIdGetDatum(proinfo->fn_oid),
- 0, 0, 0);
- if (!HeapTupleIsValid(procTup)) {
- free(prodesc->proname);
- free(prodesc);
- elog(ERROR, "pltcl: cache lookup from pg_proc failed");
- }
- procStruct = (Form_pg_proc) GETSTRUCT(procTup);
-
- /************************************************************
- * Get the required information for input conversion of the
- * return value.
- ************************************************************/
- typeTup = SearchSysCacheTuple(TYPOID,
- ObjectIdGetDatum(procStruct->prorettype),
- 0, 0, 0);
- if (!HeapTupleIsValid(typeTup)) {
- free(prodesc->proname);
- free(prodesc);
- elog(ERROR, "pltcl: cache lookup for return type failed");
- }
- typeStruct = (TypeTupleForm) GETSTRUCT(typeTup);
-
- if (typeStruct->typrelid != InvalidOid) {
- free(prodesc->proname);
- free(prodesc);
- elog(ERROR, "pltcl: return types of tuples not supported yet");
- }
-
- fmgr_info(typeStruct->typinput, &(prodesc->result_in_func));
- prodesc->result_in_elem = (Oid) (typeStruct->typelem);
- prodesc->result_in_len = typeStruct->typlen;
-
- /************************************************************
- * Get the required information for output conversion
- * of all procedure arguments
- ************************************************************/
- prodesc->nargs = proinfo->fn_nargs;
- proc_internal_args[0] = '\0';
- for (i = 0; i < proinfo->fn_nargs; i++) {
- typeTup = SearchSysCacheTuple(TYPOID,
- ObjectIdGetDatum(procStruct->proargtypes[i]),
- 0, 0, 0);
- if (!HeapTupleIsValid(typeTup)) {
- free(prodesc->proname);
- free(prodesc);
- elog(ERROR, "pltcl: cache lookup for argument type failed");
- }
- typeStruct = (TypeTupleForm) GETSTRUCT(typeTup);
-
- if (typeStruct->typrelid != InvalidOid) {
- prodesc->arg_is_rel[i] = 1;
- if (i > 0) {
- strcat(proc_internal_args, " ");
+ int i;
+ char internal_proname[512];
+ char *stroid;
+ Tcl_HashEntry *hashent;
+ int hashnew;
+ pltcl_proc_desc *prodesc;
+ Tcl_DString tcl_cmd;
+ Tcl_DString list_tmp;
+ int tcl_rc;
+ Datum retval;
+ sigjmp_buf save_restart;
+
+ /************************************************************
+ * Build our internal proc name from the functions Oid
+ ************************************************************/
+ stroid = oidout(proinfo->fn_oid);
+ strcpy(internal_proname, "__PLTcl_proc_");
+ strcat(internal_proname, stroid);
+ pfree(stroid);
+
+ /************************************************************
+ * Lookup the internal proc name in the hashtable
+ ************************************************************/
+ hashent = Tcl_FindHashEntry(pltcl_proc_hash, internal_proname);
+ if (hashent == NULL)
+ {
+ /************************************************************
+ * If we haven't found it in the hashtable, we analyze
+ * the functions arguments and returntype and store
+ * the in-/out-functions in the prodesc block and create
+ * a new hashtable entry for it.
+ *
+ * Then we load the procedure into the safe interpreter.
+ ************************************************************/
+ HeapTuple procTup;
+ HeapTuple typeTup;
+ Form_pg_proc procStruct;
+ TypeTupleForm typeStruct;
+ Tcl_DString proc_internal_def;
+ Tcl_DString proc_internal_body;
+ char proc_internal_args[4096];
+ char *proc_source;
+ char buf[512];
+
+ /************************************************************
+ * Allocate a new procedure description block
+ ************************************************************/
+ prodesc = (pltcl_proc_desc *) malloc(sizeof(pltcl_proc_desc));
+ prodesc->proname = malloc(strlen(internal_proname) + 1);
+ strcpy(prodesc->proname, internal_proname);
+
+ /************************************************************
+ * Lookup the pg_proc tuple by Oid
+ ************************************************************/
+ procTup = SearchSysCacheTuple(PROOID,
+ ObjectIdGetDatum(proinfo->fn_oid),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(procTup))
+ {
+ free(prodesc->proname);
+ free(prodesc);
+ elog(ERROR, "pltcl: cache lookup from pg_proc failed");
}
- sprintf(buf, "__PLTcl_Tup_%d", i + 1);
- strcat(proc_internal_args, buf);
- continue;
- } else {
- prodesc->arg_is_rel[i] = 0;
- }
-
- fmgr_info(typeStruct->typoutput, &(prodesc->arg_out_func[i]));
- prodesc->arg_out_elem[i] = (Oid) (typeStruct->typelem);
- prodesc->arg_out_len[i] = typeStruct->typlen;
-
- if (i > 0) {
- strcat(proc_internal_args, " ");
- }
- sprintf(buf, "%d", i + 1);
- strcat(proc_internal_args, buf);
- }
-
- /************************************************************
- * Create the tcl command to define the internal
- * procedure
- ************************************************************/
- Tcl_DStringInit(&proc_internal_def);
- Tcl_DStringInit(&proc_internal_body);
- Tcl_DStringAppendElement(&proc_internal_def, "proc");
- Tcl_DStringAppendElement(&proc_internal_def, internal_proname);
- Tcl_DStringAppendElement(&proc_internal_def, proc_internal_args);
-
- /************************************************************
- * prefix procedure body with
- * upvar #0 GD
- * and with appropriate upvars for tuple arguments
- ************************************************************/
- Tcl_DStringAppend(&proc_internal_body, "upvar #0 ", -1);
- Tcl_DStringAppend(&proc_internal_body, internal_proname, -1);
- Tcl_DStringAppend(&proc_internal_body, " GD\n", -1);
- for (i = 0; i < proinfo->fn_nargs; i++) {
- if (!prodesc->arg_is_rel[i]) continue;
- sprintf(buf, "array set %d $__PLTcl_Tup_%d\n", i + 1, i + 1);
- Tcl_DStringAppend(&proc_internal_body, buf, -1);
- }
- proc_source = textout(&(procStruct->prosrc));
- Tcl_DStringAppend(&proc_internal_body, proc_source, -1);
- pfree(proc_source);
- Tcl_DStringAppendElement(&proc_internal_def,
- Tcl_DStringValue(&proc_internal_body));
- Tcl_DStringFree(&proc_internal_body);
-
- /************************************************************
- * Create the procedure in the safe interpreter
- ************************************************************/
- tcl_rc = Tcl_GlobalEval(pltcl_safe_interp,
- Tcl_DStringValue(&proc_internal_def));
- Tcl_DStringFree(&proc_internal_def);
- if (tcl_rc != TCL_OK) {
- free(prodesc->proname);
- free(prodesc);
- elog(ERROR, "pltcl: cannot create internal procedure %s - %s",
- internal_proname, pltcl_safe_interp->result);
- }
-
- /************************************************************
- * Add the proc description block to the hashtable
- ************************************************************/
- hashent = Tcl_CreateHashEntry(pltcl_proc_hash,
- prodesc->proname, &hashnew);
- Tcl_SetHashValue(hashent, (ClientData)prodesc);
- } else {
- /************************************************************
- * Found the proc description block in the hashtable
- ************************************************************/
- prodesc = (pltcl_proc_desc *)Tcl_GetHashValue(hashent);
- }
-
- /************************************************************
- * Create the tcl command to call the internal
- * proc in the safe interpreter
- ************************************************************/
- Tcl_DStringInit(&tcl_cmd);
- Tcl_DStringInit(&list_tmp);
- Tcl_DStringAppendElement(&tcl_cmd, internal_proname);
-
- /************************************************************
- * Catch elog(ERROR) during build of the Tcl command
- ************************************************************/
- memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
- if (sigsetjmp(Warn_restart, 1) != 0) {
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- Tcl_DStringFree(&tcl_cmd);
+ procStruct = (Form_pg_proc) GETSTRUCT(procTup);
+
+ /************************************************************
+ * Get the required information for input conversion of the
+ * return value.
+ ************************************************************/
+ typeTup = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(procStruct->prorettype),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(typeTup))
+ {
+ free(prodesc->proname);
+ free(prodesc);
+ elog(ERROR, "pltcl: cache lookup for return type failed");
+ }
+ typeStruct = (TypeTupleForm) GETSTRUCT(typeTup);
+
+ if (typeStruct->typrelid != InvalidOid)
+ {
+ free(prodesc->proname);
+ free(prodesc);
+ elog(ERROR, "pltcl: return types of tuples not supported yet");
+ }
+
+ fmgr_info(typeStruct->typinput, &(prodesc->result_in_func));
+ prodesc->result_in_elem = (Oid) (typeStruct->typelem);
+ prodesc->result_in_len = typeStruct->typlen;
+
+ /************************************************************
+ * Get the required information for output conversion
+ * of all procedure arguments
+ ************************************************************/
+ prodesc->nargs = proinfo->fn_nargs;
+ proc_internal_args[0] = '\0';
+ for (i = 0; i < proinfo->fn_nargs; i++)
+ {
+ typeTup = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(procStruct->proargtypes[i]),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(typeTup))
+ {
+ free(prodesc->proname);
+ free(prodesc);
+ elog(ERROR, "pltcl: cache lookup for argument type failed");
+ }
+ typeStruct = (TypeTupleForm) GETSTRUCT(typeTup);
+
+ if (typeStruct->typrelid != InvalidOid)
+ {
+ prodesc->arg_is_rel[i] = 1;
+ if (i > 0)
+ {
+ strcat(proc_internal_args, " ");
+ }
+ sprintf(buf, "__PLTcl_Tup_%d", i + 1);
+ strcat(proc_internal_args, buf);
+ continue;
+ }
+ else
+ {
+ prodesc->arg_is_rel[i] = 0;
+ }
+
+ fmgr_info(typeStruct->typoutput, &(prodesc->arg_out_func[i]));
+ prodesc->arg_out_elem[i] = (Oid) (typeStruct->typelem);
+ prodesc->arg_out_len[i] = typeStruct->typlen;
+
+ if (i > 0)
+ {
+ strcat(proc_internal_args, " ");
+ }
+ sprintf(buf, "%d", i + 1);
+ strcat(proc_internal_args, buf);
+ }
+
+ /************************************************************
+ * Create the tcl command to define the internal
+ * procedure
+ ************************************************************/
+ Tcl_DStringInit(&proc_internal_def);
+ Tcl_DStringInit(&proc_internal_body);
+ Tcl_DStringAppendElement(&proc_internal_def, "proc");
+ Tcl_DStringAppendElement(&proc_internal_def, internal_proname);
+ Tcl_DStringAppendElement(&proc_internal_def, proc_internal_args);
+
+ /************************************************************
+ * prefix procedure body with
+ * upvar #0 GD
+ * and with appropriate upvars for tuple arguments
+ ************************************************************/
+ Tcl_DStringAppend(&proc_internal_body, "upvar #0 ", -1);
+ Tcl_DStringAppend(&proc_internal_body, internal_proname, -1);
+ Tcl_DStringAppend(&proc_internal_body, " GD\n", -1);
+ for (i = 0; i < proinfo->fn_nargs; i++)
+ {
+ if (!prodesc->arg_is_rel[i])
+ continue;
+ sprintf(buf, "array set %d $__PLTcl_Tup_%d\n", i + 1, i + 1);
+ Tcl_DStringAppend(&proc_internal_body, buf, -1);
+ }
+ proc_source = textout(&(procStruct->prosrc));
+ Tcl_DStringAppend(&proc_internal_body, proc_source, -1);
+ pfree(proc_source);
+ Tcl_DStringAppendElement(&proc_internal_def,
+ Tcl_DStringValue(&proc_internal_body));
+ Tcl_DStringFree(&proc_internal_body);
+
+ /************************************************************
+ * Create the procedure in the safe interpreter
+ ************************************************************/
+ tcl_rc = Tcl_GlobalEval(pltcl_safe_interp,
+ Tcl_DStringValue(&proc_internal_def));
+ Tcl_DStringFree(&proc_internal_def);
+ if (tcl_rc != TCL_OK)
+ {
+ free(prodesc->proname);
+ free(prodesc);
+ elog(ERROR, "pltcl: cannot create internal procedure %s - %s",
+ internal_proname, pltcl_safe_interp->result);
+ }
+
+ /************************************************************
+ * Add the proc description block to the hashtable
+ ************************************************************/
+ hashent = Tcl_CreateHashEntry(pltcl_proc_hash,
+ prodesc->proname, &hashnew);
+ Tcl_SetHashValue(hashent, (ClientData) prodesc);
+ }
+ else
+ {
+ /************************************************************
+ * Found the proc description block in the hashtable
+ ************************************************************/
+ prodesc = (pltcl_proc_desc *) Tcl_GetHashValue(hashent);
+ }
+
+ /************************************************************
+ * Create the tcl command to call the internal
+ * proc in the safe interpreter
+ ************************************************************/
+ Tcl_DStringInit(&tcl_cmd);
+ Tcl_DStringInit(&list_tmp);
+ Tcl_DStringAppendElement(&tcl_cmd, internal_proname);
+
+ /************************************************************
+ * Catch elog(ERROR) during build of the Tcl command
+ ************************************************************/
+ memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
+ if (sigsetjmp(Warn_restart, 1) != 0)
+ {
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ Tcl_DStringFree(&tcl_cmd);
+ Tcl_DStringFree(&list_tmp);
+ pltcl_restart_in_progress = 1;
+ if (--pltcl_call_level == 0)
+ {
+ pltcl_restart_in_progress = 0;
+ }
+ siglongjmp(Warn_restart, 1);
+ }
+
+ /************************************************************
+ * Add all call arguments to the command
+ ************************************************************/
+ for (i = 0; i < prodesc->nargs; i++)
+ {
+ if (prodesc->arg_is_rel[i])
+ {
+ /**************************************************
+ * For tuple values, add a list for 'array set ...'
+ **************************************************/
+ Tcl_DStringInit(&list_tmp);
+ pltcl_build_tuple_argument(
+ ((TupleTableSlot *) (proargs->data[i]))->val,
+ ((TupleTableSlot *) (proargs->data[i]))->ttc_tupleDescriptor,
+ &list_tmp);
+ Tcl_DStringAppendElement(&tcl_cmd, Tcl_DStringValue(&list_tmp));
+ Tcl_DStringFree(&list_tmp);
+ Tcl_DStringInit(&list_tmp);
+ }
+ else
+ {
+ /**************************************************
+ * Single values are added as string element
+ * of their external representation
+ **************************************************/
+ char *tmp;
+
+ tmp = (*fmgr_faddr(&(prodesc->arg_out_func[i])))
+ (proargs->data[i],
+ prodesc->arg_out_elem[i],
+ prodesc->arg_out_len[i]);
+ Tcl_DStringAppendElement(&tcl_cmd, tmp);
+ pfree(tmp);
+ }
+ }
Tcl_DStringFree(&list_tmp);
- pltcl_restart_in_progress = 1;
- if (--pltcl_call_level == 0) {
- pltcl_restart_in_progress = 0;
- }
- siglongjmp(Warn_restart, 1);
- }
-
- /************************************************************
- * Add all call arguments to the command
- ************************************************************/
- for (i = 0; i < prodesc->nargs; i++) {
- if (prodesc->arg_is_rel[i]) {
- /**************************************************
- * For tuple values, add a list for 'array set ...'
- **************************************************/
- Tcl_DStringInit(&list_tmp);
- pltcl_build_tuple_argument(
- ((TupleTableSlot *)(proargs->data[i]))->val,
- ((TupleTableSlot *)(proargs->data[i]))->ttc_tupleDescriptor,
- &list_tmp);
- Tcl_DStringAppendElement(&tcl_cmd, Tcl_DStringValue(&list_tmp));
- Tcl_DStringFree(&list_tmp);
- Tcl_DStringInit(&list_tmp);
- } else {
- /**************************************************
- * Single values are added as string element
- * of their external representation
- **************************************************/
- char *tmp;
-
- tmp = (*fmgr_faddr(&(prodesc->arg_out_func[i])))
- (proargs->data[i],
- prodesc->arg_out_elem[i],
- prodesc->arg_out_len[i]);
- Tcl_DStringAppendElement(&tcl_cmd, tmp);
- pfree(tmp);
- }
- }
- Tcl_DStringFree(&list_tmp);
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
-
- /************************************************************
- * Call the Tcl function
- ************************************************************/
- tcl_rc = Tcl_GlobalEval(pltcl_safe_interp, Tcl_DStringValue(&tcl_cmd));
- Tcl_DStringFree(&tcl_cmd);
-
- /************************************************************
- * Check the return code from Tcl and handle
- * our special restart mechanism to get rid
- * of all nested call levels on transaction
- * abort.
- ************************************************************/
- if (tcl_rc != TCL_OK || pltcl_restart_in_progress) {
- if (!pltcl_restart_in_progress) {
- pltcl_restart_in_progress = 1;
- if (--pltcl_call_level == 0) {
- pltcl_restart_in_progress = 0;
- }
- elog(ERROR, "pltcl: %s", pltcl_safe_interp->result);
- }
- if (--pltcl_call_level == 0) {
- pltcl_restart_in_progress = 0;
- }
- siglongjmp(Warn_restart, 1);
- }
-
- /************************************************************
- * Convert the result value from the safe interpreter
- * into it's PostgreSQL data format and return it.
- * Again, the call to fmgr() could fire an elog and we
- * have to count for the current interpreter level we are
- * on. The save_restart from above is still good.
- ************************************************************/
- if (sigsetjmp(Warn_restart, 1) != 0) {
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- pltcl_restart_in_progress = 1;
- if (--pltcl_call_level == 0) {
- pltcl_restart_in_progress = 0;
- }
- siglongjmp(Warn_restart, 1);
- }
-
- retval = (Datum)(*fmgr_faddr(&prodesc->result_in_func))
- (pltcl_safe_interp->result,
- prodesc->result_in_elem,
- prodesc->result_in_len);
-
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- return retval;
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+
+ /************************************************************
+ * Call the Tcl function
+ ************************************************************/
+ tcl_rc = Tcl_GlobalEval(pltcl_safe_interp, Tcl_DStringValue(&tcl_cmd));
+ Tcl_DStringFree(&tcl_cmd);
+
+ /************************************************************
+ * Check the return code from Tcl and handle
+ * our special restart mechanism to get rid
+ * of all nested call levels on transaction
+ * abort.
+ ************************************************************/
+ if (tcl_rc != TCL_OK || pltcl_restart_in_progress)
+ {
+ if (!pltcl_restart_in_progress)
+ {
+ pltcl_restart_in_progress = 1;
+ if (--pltcl_call_level == 0)
+ {
+ pltcl_restart_in_progress = 0;
+ }
+ elog(ERROR, "pltcl: %s", pltcl_safe_interp->result);
+ }
+ if (--pltcl_call_level == 0)
+ {
+ pltcl_restart_in_progress = 0;
+ }
+ siglongjmp(Warn_restart, 1);
+ }
+
+ /************************************************************
+ * Convert the result value from the safe interpreter
+ * into it's PostgreSQL data format and return it.
+ * Again, the call to fmgr() could fire an elog and we
+ * have to count for the current interpreter level we are
+ * on. The save_restart from above is still good.
+ ************************************************************/
+ if (sigsetjmp(Warn_restart, 1) != 0)
+ {
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ pltcl_restart_in_progress = 1;
+ if (--pltcl_call_level == 0)
+ {
+ pltcl_restart_in_progress = 0;
+ }
+ siglongjmp(Warn_restart, 1);
+ }
+
+ retval = (Datum) (*fmgr_faddr(&prodesc->result_in_func))
+ (pltcl_safe_interp->result,
+ prodesc->result_in_elem,
+ prodesc->result_in_len);
+
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ return retval;
}
static HeapTuple
pltcl_trigger_handler(FmgrInfo *proinfo)
{
- TriggerData *trigdata;
- char internal_proname[512];
- char *stroid;
- Tcl_HashEntry *hashent;
- int hashnew;
- pltcl_proc_desc *prodesc;
- TupleDesc tupdesc;
- HeapTuple rettup;
- Tcl_DString tcl_cmd;
- Tcl_DString tcl_trigtup;
- Tcl_DString tcl_newtup;
- int tcl_rc;
- int i;
-
- int *modattrs;
- Datum *modvalues;
- char *modnulls;
-
- int ret_numvals;
- char **ret_values;
-
- sigjmp_buf save_restart;
-
- /************************************************************
- * Save the current trigger data local
- ************************************************************/
- trigdata = CurrentTriggerData;
- CurrentTriggerData = NULL;
-
- /************************************************************
- * Build our internal proc name from the functions Oid
- ************************************************************/
- stroid = oidout(proinfo->fn_oid);
- strcpy(internal_proname, "__PLTcl_proc_");
- strcat(internal_proname, stroid);
- pfree(stroid);
-
- /************************************************************
- * Lookup the internal proc name in the hashtable
- ************************************************************/
- hashent = Tcl_FindHashEntry(pltcl_proc_hash, internal_proname);
- if (hashent == NULL) {
+ TriggerData *trigdata;
+ char internal_proname[512];
+ char *stroid;
+ Tcl_HashEntry *hashent;
+ int hashnew;
+ pltcl_proc_desc *prodesc;
+ TupleDesc tupdesc;
+ HeapTuple rettup;
+ Tcl_DString tcl_cmd;
+ Tcl_DString tcl_trigtup;
+ Tcl_DString tcl_newtup;
+ int tcl_rc;
+ int i;
+
+ int *modattrs;
+ Datum *modvalues;
+ char *modnulls;
+
+ int ret_numvals;
+ char **ret_values;
+
+ sigjmp_buf save_restart;
+
/************************************************************
- * If we haven't found it in the hashtable,
- * we load the procedure into the safe interpreter.
- ************************************************************/
- Tcl_DString proc_internal_def;
- Tcl_DString proc_internal_body;
- HeapTuple procTup;
- Form_pg_proc procStruct;
- char *proc_source;
-
- /************************************************************
- * Allocate a new procedure description block
- ************************************************************/
- prodesc = (pltcl_proc_desc *)malloc(sizeof(pltcl_proc_desc));
- memset(prodesc, 0, sizeof(pltcl_proc_desc));
- prodesc->proname = malloc(strlen(internal_proname) + 1);
- strcpy(prodesc->proname, internal_proname);
-
- /************************************************************
- * Lookup the pg_proc tuple by Oid
- ************************************************************/
- procTup = SearchSysCacheTuple(PROOID,
- ObjectIdGetDatum(proinfo->fn_oid),
- 0, 0, 0);
- if (!HeapTupleIsValid(procTup)) {
- free(prodesc->proname);
- free(prodesc);
- elog(ERROR, "pltcl: cache lookup from pg_proc failed");
- }
- procStruct = (Form_pg_proc) GETSTRUCT(procTup);
-
- /************************************************************
- * Create the tcl command to define the internal
- * procedure
- ************************************************************/
- Tcl_DStringInit(&proc_internal_def);
- Tcl_DStringInit(&proc_internal_body);
- Tcl_DStringAppendElement(&proc_internal_def, "proc");
- Tcl_DStringAppendElement(&proc_internal_def, internal_proname);
- Tcl_DStringAppendElement(&proc_internal_def,
- "TG_name TG_relid TG_relatts TG_when TG_level TG_op __PLTcl_Tup_NEW __PLTcl_Tup_OLD args");
-
- /************************************************************
- * prefix procedure body with
- * upvar #0 GD
- * and with appropriate setting of NEW, OLD,
- * and the arguments as numerical variables.
- ************************************************************/
- Tcl_DStringAppend(&proc_internal_body, "upvar #0 ", -1);
- Tcl_DStringAppend(&proc_internal_body, internal_proname, -1);
- Tcl_DStringAppend(&proc_internal_body, " GD\n", -1);
-
- Tcl_DStringAppend(&proc_internal_body,
- "array set NEW $__PLTcl_Tup_NEW\n", -1);
- Tcl_DStringAppend(&proc_internal_body,
- "array set OLD $__PLTcl_Tup_OLD\n", -1);
-
- Tcl_DStringAppend(&proc_internal_body,
- "set i 0\n"
- "set v 0\n"
- "foreach v $args {\n"
- " incr i\n"
- " set $i $v\n"
- "}\n"
- "unset i v\n\n", -1);
-
- proc_source = textout(&(procStruct->prosrc));
- Tcl_DStringAppend(&proc_internal_body, proc_source, -1);
- pfree(proc_source);
- Tcl_DStringAppendElement(&proc_internal_def,
- Tcl_DStringValue(&proc_internal_body));
- Tcl_DStringFree(&proc_internal_body);
+ * Save the current trigger data local
+ ************************************************************/
+ trigdata = CurrentTriggerData;
+ CurrentTriggerData = NULL;
/************************************************************
- * Create the procedure in the safe interpreter
+ * Build our internal proc name from the functions Oid
************************************************************/
- tcl_rc = Tcl_GlobalEval(pltcl_safe_interp,
- Tcl_DStringValue(&proc_internal_def));
- Tcl_DStringFree(&proc_internal_def);
- if (tcl_rc != TCL_OK) {
- free(prodesc->proname);
- free(prodesc);
- elog(ERROR, "pltcl: cannot create internal procedure %s - %s",
- internal_proname, pltcl_safe_interp->result);
+ stroid = oidout(proinfo->fn_oid);
+ strcpy(internal_proname, "__PLTcl_proc_");
+ strcat(internal_proname, stroid);
+ pfree(stroid);
+
+ /************************************************************
+ * Lookup the internal proc name in the hashtable
+ ************************************************************/
+ hashent = Tcl_FindHashEntry(pltcl_proc_hash, internal_proname);
+ if (hashent == NULL)
+ {
+ /************************************************************
+ * If we haven't found it in the hashtable,
+ * we load the procedure into the safe interpreter.
+ ************************************************************/
+ Tcl_DString proc_internal_def;
+ Tcl_DString proc_internal_body;
+ HeapTuple procTup;
+ Form_pg_proc procStruct;
+ char *proc_source;
+
+ /************************************************************
+ * Allocate a new procedure description block
+ ************************************************************/
+ prodesc = (pltcl_proc_desc *) malloc(sizeof(pltcl_proc_desc));
+ memset(prodesc, 0, sizeof(pltcl_proc_desc));
+ prodesc->proname = malloc(strlen(internal_proname) + 1);
+ strcpy(prodesc->proname, internal_proname);
+
+ /************************************************************
+ * Lookup the pg_proc tuple by Oid
+ ************************************************************/
+ procTup = SearchSysCacheTuple(PROOID,
+ ObjectIdGetDatum(proinfo->fn_oid),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(procTup))
+ {
+ free(prodesc->proname);
+ free(prodesc);
+ elog(ERROR, "pltcl: cache lookup from pg_proc failed");
+ }
+ procStruct = (Form_pg_proc) GETSTRUCT(procTup);
+
+ /************************************************************
+ * Create the tcl command to define the internal
+ * procedure
+ ************************************************************/
+ Tcl_DStringInit(&proc_internal_def);
+ Tcl_DStringInit(&proc_internal_body);
+ Tcl_DStringAppendElement(&proc_internal_def, "proc");
+ Tcl_DStringAppendElement(&proc_internal_def, internal_proname);
+ Tcl_DStringAppendElement(&proc_internal_def,
+ "TG_name TG_relid TG_relatts TG_when TG_level TG_op __PLTcl_Tup_NEW __PLTcl_Tup_OLD args");
+
+ /************************************************************
+ * prefix procedure body with
+ * upvar #0 GD
+ * and with appropriate setting of NEW, OLD,
+ * and the arguments as numerical variables.
+ ************************************************************/
+ Tcl_DStringAppend(&proc_internal_body, "upvar #0 ", -1);
+ Tcl_DStringAppend(&proc_internal_body, internal_proname, -1);
+ Tcl_DStringAppend(&proc_internal_body, " GD\n", -1);
+
+ Tcl_DStringAppend(&proc_internal_body,
+ "array set NEW $__PLTcl_Tup_NEW\n", -1);
+ Tcl_DStringAppend(&proc_internal_body,
+ "array set OLD $__PLTcl_Tup_OLD\n", -1);
+
+ Tcl_DStringAppend(&proc_internal_body,
+ "set i 0\n"
+ "set v 0\n"
+ "foreach v $args {\n"
+ " incr i\n"
+ " set $i $v\n"
+ "}\n"
+ "unset i v\n\n", -1);
+
+ proc_source = textout(&(procStruct->prosrc));
+ Tcl_DStringAppend(&proc_internal_body, proc_source, -1);
+ pfree(proc_source);
+ Tcl_DStringAppendElement(&proc_internal_def,
+ Tcl_DStringValue(&proc_internal_body));
+ Tcl_DStringFree(&proc_internal_body);
+
+ /************************************************************
+ * Create the procedure in the safe interpreter
+ ************************************************************/
+ tcl_rc = Tcl_GlobalEval(pltcl_safe_interp,
+ Tcl_DStringValue(&proc_internal_def));
+ Tcl_DStringFree(&proc_internal_def);
+ if (tcl_rc != TCL_OK)
+ {
+ free(prodesc->proname);
+ free(prodesc);
+ elog(ERROR, "pltcl: cannot create internal procedure %s - %s",
+ internal_proname, pltcl_safe_interp->result);
+ }
+
+ /************************************************************
+ * Add the proc description block to the hashtable
+ ************************************************************/
+ hashent = Tcl_CreateHashEntry(pltcl_proc_hash,
+ prodesc->proname, &hashnew);
+ Tcl_SetHashValue(hashent, (ClientData) prodesc);
}
+ else
+ {
+ /************************************************************
+ * Found the proc description block in the hashtable
+ ************************************************************/
+ prodesc = (pltcl_proc_desc *) Tcl_GetHashValue(hashent);
+ }
+
+ tupdesc = trigdata->tg_relation->rd_att;
/************************************************************
- * Add the proc description block to the hashtable
+ * Create the tcl command to call the internal
+ * proc in the safe interpreter
************************************************************/
- hashent = Tcl_CreateHashEntry(pltcl_proc_hash,
- prodesc->proname, &hashnew);
- Tcl_SetHashValue(hashent, (ClientData)prodesc);
- } else {
+ Tcl_DStringInit(&tcl_cmd);
+ Tcl_DStringInit(&tcl_trigtup);
+ Tcl_DStringInit(&tcl_newtup);
+
/************************************************************
- * Found the proc description block in the hashtable
+ * We call external functions below - care for elog(ERROR)
************************************************************/
- prodesc = (pltcl_proc_desc *)Tcl_GetHashValue(hashent);
- }
+ memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
+ if (sigsetjmp(Warn_restart, 1) != 0)
+ {
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ Tcl_DStringFree(&tcl_cmd);
+ Tcl_DStringFree(&tcl_trigtup);
+ Tcl_DStringFree(&tcl_newtup);
+ pltcl_restart_in_progress = 1;
+ if (--pltcl_call_level == 0)
+ {
+ pltcl_restart_in_progress = 0;
+ }
+ siglongjmp(Warn_restart, 1);
+ }
- tupdesc = trigdata->tg_relation->rd_att;
+ /* The procedure name */
+ Tcl_DStringAppendElement(&tcl_cmd, internal_proname);
- /************************************************************
- * Create the tcl command to call the internal
- * proc in the safe interpreter
- ************************************************************/
- Tcl_DStringInit(&tcl_cmd);
- Tcl_DStringInit(&tcl_trigtup);
- Tcl_DStringInit(&tcl_newtup);
+ /* The trigger name for argument TG_name */
+ Tcl_DStringAppendElement(&tcl_cmd, trigdata->tg_trigger->tgname);
- /************************************************************
- * We call external functions below - care for elog(ERROR)
- ************************************************************/
- memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
- if (sigsetjmp(Warn_restart, 1) != 0) {
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- Tcl_DStringFree(&tcl_cmd);
- Tcl_DStringFree(&tcl_trigtup);
- Tcl_DStringFree(&tcl_newtup);
- pltcl_restart_in_progress = 1;
- if (--pltcl_call_level == 0) {
- pltcl_restart_in_progress = 0;
- }
- siglongjmp(Warn_restart, 1);
- }
-
- /* The procedure name */
- Tcl_DStringAppendElement(&tcl_cmd, internal_proname);
-
- /* The trigger name for argument TG_name */
- Tcl_DStringAppendElement(&tcl_cmd, trigdata->tg_trigger->tgname);
-
- /* The oid of the trigger relation for argument TG_relid */
- stroid = oidout(trigdata->tg_relation->rd_id);
- Tcl_DStringAppendElement(&tcl_cmd, stroid);
- pfree(stroid);
-
- /* A list of attribute names for argument TG_relatts */
- Tcl_DStringAppendElement(&tcl_trigtup, "");
- for (i = 0; i < tupdesc->natts; i++) {
- Tcl_DStringAppendElement(&tcl_trigtup, tupdesc->attrs[i]->attname.data);
- }
- Tcl_DStringAppendElement(&tcl_cmd, Tcl_DStringValue(&tcl_trigtup));
- Tcl_DStringFree(&tcl_trigtup);
- Tcl_DStringInit(&tcl_trigtup);
-
- /* The when part of the event for TG_when */
- if (TRIGGER_FIRED_BEFORE(trigdata->tg_event)) {
- Tcl_DStringAppendElement(&tcl_cmd, "BEFORE");
- }
- else if (TRIGGER_FIRED_AFTER(trigdata->tg_event)) {
- Tcl_DStringAppendElement(&tcl_cmd, "AFTER");
- }
- else {
- Tcl_DStringAppendElement(&tcl_cmd, "UNKNOWN");
- }
-
- /* The level part of the event for TG_level */
- if (TRIGGER_FIRED_FOR_ROW(trigdata->tg_event)) {
- Tcl_DStringAppendElement(&tcl_cmd, "ROW");
- }
- else if (TRIGGER_FIRED_FOR_STATEMENT(trigdata->tg_event)) {
- Tcl_DStringAppendElement(&tcl_cmd, "STATEMENT");
- }
- else {
- Tcl_DStringAppendElement(&tcl_cmd, "UNKNOWN");
- }
-
- /* Build the data list for the trigtuple */
- pltcl_build_tuple_argument(trigdata->tg_trigtuple,
- tupdesc, &tcl_trigtup);
-
- /* Now the command part of the event for TG_op and data for NEW and OLD */
- if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event)) {
- Tcl_DStringAppendElement(&tcl_cmd, "INSERT");
+ /* The oid of the trigger relation for argument TG_relid */
+ stroid = oidout(trigdata->tg_relation->rd_id);
+ Tcl_DStringAppendElement(&tcl_cmd, stroid);
+ pfree(stroid);
+ /* A list of attribute names for argument TG_relatts */
+ Tcl_DStringAppendElement(&tcl_trigtup, "");
+ for (i = 0; i < tupdesc->natts; i++)
+ {
+ Tcl_DStringAppendElement(&tcl_trigtup, tupdesc->attrs[i]->attname.data);
+ }
Tcl_DStringAppendElement(&tcl_cmd, Tcl_DStringValue(&tcl_trigtup));
- Tcl_DStringAppendElement(&tcl_cmd, "");
-
- rettup = trigdata->tg_trigtuple;
- }
- else if (TRIGGER_FIRED_BY_DELETE(trigdata->tg_event)) {
- Tcl_DStringAppendElement(&tcl_cmd, "DELETE");
-
- Tcl_DStringAppendElement(&tcl_cmd, "");
- Tcl_DStringAppendElement(&tcl_cmd, Tcl_DStringValue(&tcl_trigtup));
+ Tcl_DStringFree(&tcl_trigtup);
+ Tcl_DStringInit(&tcl_trigtup);
+
+ /* The when part of the event for TG_when */
+ if (TRIGGER_FIRED_BEFORE(trigdata->tg_event))
+ {
+ Tcl_DStringAppendElement(&tcl_cmd, "BEFORE");
+ }
+ else if (TRIGGER_FIRED_AFTER(trigdata->tg_event))
+ {
+ Tcl_DStringAppendElement(&tcl_cmd, "AFTER");
+ }
+ else
+ {
+ Tcl_DStringAppendElement(&tcl_cmd, "UNKNOWN");
+ }
- rettup = trigdata->tg_trigtuple;
- }
- else if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event)) {
- Tcl_DStringAppendElement(&tcl_cmd, "UPDATE");
+ /* The level part of the event for TG_level */
+ if (TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
+ {
+ Tcl_DStringAppendElement(&tcl_cmd, "ROW");
+ }
+ else if (TRIGGER_FIRED_FOR_STATEMENT(trigdata->tg_event))
+ {
+ Tcl_DStringAppendElement(&tcl_cmd, "STATEMENT");
+ }
+ else
+ {
+ Tcl_DStringAppendElement(&tcl_cmd, "UNKNOWN");
+ }
- pltcl_build_tuple_argument(trigdata->tg_newtuple,
- tupdesc, &tcl_newtup);
+ /* Build the data list for the trigtuple */
+ pltcl_build_tuple_argument(trigdata->tg_trigtuple,
+ tupdesc, &tcl_trigtup);
- Tcl_DStringAppendElement(&tcl_cmd, Tcl_DStringValue(&tcl_newtup));
- Tcl_DStringAppendElement(&tcl_cmd, Tcl_DStringValue(&tcl_trigtup));
+ /*
+ * Now the command part of the event for TG_op and data for NEW and
+ * OLD
+ */
+ if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
+ {
+ Tcl_DStringAppendElement(&tcl_cmd, "INSERT");
- rettup = trigdata->tg_newtuple;
- }
- else {
- Tcl_DStringAppendElement(&tcl_cmd, "UNKNOWN");
+ Tcl_DStringAppendElement(&tcl_cmd, Tcl_DStringValue(&tcl_trigtup));
+ Tcl_DStringAppendElement(&tcl_cmd, "");
- Tcl_DStringAppendElement(&tcl_cmd, Tcl_DStringValue(&tcl_trigtup));
- Tcl_DStringAppendElement(&tcl_cmd, Tcl_DStringValue(&tcl_trigtup));
+ rettup = trigdata->tg_trigtuple;
+ }
+ else if (TRIGGER_FIRED_BY_DELETE(trigdata->tg_event))
+ {
+ Tcl_DStringAppendElement(&tcl_cmd, "DELETE");
- rettup = trigdata->tg_trigtuple;
- }
-
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- Tcl_DStringFree(&tcl_trigtup);
- Tcl_DStringFree(&tcl_newtup);
-
- /************************************************************
- * Finally append the arguments from CREATE TRIGGER
- ************************************************************/
- for (i = 0; i < trigdata->tg_trigger->tgnargs; i++) {
- Tcl_DStringAppendElement(&tcl_cmd, trigdata->tg_trigger->tgargs[i]);
- }
-
- /************************************************************
- * Call the Tcl function
- ************************************************************/
- tcl_rc = Tcl_GlobalEval(pltcl_safe_interp, Tcl_DStringValue(&tcl_cmd));
- Tcl_DStringFree(&tcl_cmd);
-
- /************************************************************
- * Check the return code from Tcl and handle
- * our special restart mechanism to get rid
- * of all nested call levels on transaction
- * abort.
- ************************************************************/
- if (tcl_rc == TCL_ERROR || pltcl_restart_in_progress) {
- if (!pltcl_restart_in_progress) {
- pltcl_restart_in_progress = 1;
- if (--pltcl_call_level == 0) {
- pltcl_restart_in_progress = 0;
- }
- elog(ERROR, "pltcl: %s", pltcl_safe_interp->result);
- }
- if (--pltcl_call_level == 0) {
- pltcl_restart_in_progress = 0;
- }
- siglongjmp(Warn_restart, 1);
- }
-
- switch (tcl_rc) {
- case TCL_OK:
- break;
-
- default:
- elog(ERROR, "pltcl: unsupported TCL return code %d", tcl_rc);
- }
-
- /************************************************************
- * The return value from the procedure might be one of
- * the magic strings OK or SKIP or a list from array get
- ************************************************************/
- if (strcmp(pltcl_safe_interp->result, "OK") == 0) {
- return rettup;
- }
- if (strcmp(pltcl_safe_interp->result, "SKIP") == 0) {
- return (HeapTuple)NULL;;
- }
-
- /************************************************************
- * Convert the result value from the safe interpreter
- * and setup structures for SPI_modifytuple();
- ************************************************************/
- if (Tcl_SplitList(pltcl_safe_interp, pltcl_safe_interp->result,
- &ret_numvals, &ret_values) != TCL_OK) {
- elog(NOTICE, "pltcl: cannot split return value from trigger");
- elog(ERROR, "pltcl: %s", pltcl_safe_interp->result);
- }
-
- if (ret_numvals % 2 != 0) {
- ckfree(ret_values);
- elog(ERROR, "pltcl: invalid return list from trigger - must have even # of elements");
- }
-
- modattrs = (int *)palloc(tupdesc->natts * sizeof(int));
- modvalues = (Datum *)palloc(tupdesc->natts * sizeof(Datum));
- for (i = 0; i < tupdesc->natts; i++) {
- modattrs[i] = i + 1;
- modvalues[i] = (Datum)NULL;
- }
-
- modnulls = palloc(tupdesc->natts + 1);
- memset(modnulls, 'n', tupdesc->natts);
- modnulls[tupdesc->natts] = '\0';
-
- /************************************************************
- * Care for possible elog(ERROR)'s below
- ************************************************************/
- if (sigsetjmp(Warn_restart, 1) != 0) {
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- ckfree(ret_values);
- pltcl_restart_in_progress = 1;
- if (--pltcl_call_level == 0) {
- pltcl_restart_in_progress = 0;
+ Tcl_DStringAppendElement(&tcl_cmd, "");
+ Tcl_DStringAppendElement(&tcl_cmd, Tcl_DStringValue(&tcl_trigtup));
+
+ rettup = trigdata->tg_trigtuple;
}
- siglongjmp(Warn_restart, 1);
- }
+ else if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
+ {
+ Tcl_DStringAppendElement(&tcl_cmd, "UPDATE");
- i = 0;
- while(i < ret_numvals) {
- int attnum;
- HeapTuple typeTup;
- Oid typinput;
- Oid typelem;
- FmgrInfo finfo;
+ pltcl_build_tuple_argument(trigdata->tg_newtuple,
+ tupdesc, &tcl_newtup);
+
+ Tcl_DStringAppendElement(&tcl_cmd, Tcl_DStringValue(&tcl_newtup));
+ Tcl_DStringAppendElement(&tcl_cmd, Tcl_DStringValue(&tcl_trigtup));
+
+ rettup = trigdata->tg_newtuple;
+ }
+ else
+ {
+ Tcl_DStringAppendElement(&tcl_cmd, "UNKNOWN");
+
+ Tcl_DStringAppendElement(&tcl_cmd, Tcl_DStringValue(&tcl_trigtup));
+ Tcl_DStringAppendElement(&tcl_cmd, Tcl_DStringValue(&tcl_trigtup));
+
+ rettup = trigdata->tg_trigtuple;
+ }
+
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ Tcl_DStringFree(&tcl_trigtup);
+ Tcl_DStringFree(&tcl_newtup);
/************************************************************
- * Ignore pseudo elements with a dot name
+ * Finally append the arguments from CREATE TRIGGER
************************************************************/
- if (*(ret_values[i]) == '.') {
- i += 2;
- continue;
+ for (i = 0; i < trigdata->tg_trigger->tgnargs; i++)
+ {
+ Tcl_DStringAppendElement(&tcl_cmd, trigdata->tg_trigger->tgargs[i]);
}
/************************************************************
- * Get the attribute number
+ * Call the Tcl function
+ ************************************************************/
+ tcl_rc = Tcl_GlobalEval(pltcl_safe_interp, Tcl_DStringValue(&tcl_cmd));
+ Tcl_DStringFree(&tcl_cmd);
+
+ /************************************************************
+ * Check the return code from Tcl and handle
+ * our special restart mechanism to get rid
+ * of all nested call levels on transaction
+ * abort.
************************************************************/
- attnum = SPI_fnumber(tupdesc, ret_values[i++]);
- if (attnum == SPI_ERROR_NOATTRIBUTE) {
- elog(ERROR, "pltcl: invalid attribute '%s'", ret_values[--i]);
+ if (tcl_rc == TCL_ERROR || pltcl_restart_in_progress)
+ {
+ if (!pltcl_restart_in_progress)
+ {
+ pltcl_restart_in_progress = 1;
+ if (--pltcl_call_level == 0)
+ {
+ pltcl_restart_in_progress = 0;
+ }
+ elog(ERROR, "pltcl: %s", pltcl_safe_interp->result);
+ }
+ if (--pltcl_call_level == 0)
+ {
+ pltcl_restart_in_progress = 0;
+ }
+ siglongjmp(Warn_restart, 1);
+ }
+
+ switch (tcl_rc)
+ {
+ case TCL_OK:
+ break;
+
+ default:
+ elog(ERROR, "pltcl: unsupported TCL return code %d", tcl_rc);
}
/************************************************************
- * Lookup the attribute type in the syscache
- * for the input function
+ * The return value from the procedure might be one of
+ * the magic strings OK or SKIP or a list from array get
************************************************************/
- typeTup = SearchSysCacheTuple(TYPOID,
- ObjectIdGetDatum(tupdesc->attrs[attnum - 1]->atttypid),
- 0, 0, 0);
- if (!HeapTupleIsValid(typeTup)) {
- elog(ERROR, "pltcl: Cache lookup for attribute '%s' type %ld failed",
- ret_values[--i],
- ObjectIdGetDatum(tupdesc->attrs[attnum - 1]->atttypid));
+ if (strcmp(pltcl_safe_interp->result, "OK") == 0)
+ {
+ return rettup;
+ }
+ if (strcmp(pltcl_safe_interp->result, "SKIP") == 0)
+ {
+ return (HeapTuple) NULL;;
}
- typinput = (Oid) (((TypeTupleForm)GETSTRUCT(typeTup))->typinput);
- typelem = (Oid) (((TypeTupleForm)GETSTRUCT(typeTup))->typelem);
/************************************************************
- * Set the attribute to NOT NULL and convert the contents
+ * Convert the result value from the safe interpreter
+ * and setup structures for SPI_modifytuple();
************************************************************/
- modnulls[attnum - 1] = ' ';
- fmgr_info(typinput, &finfo);
- modvalues[attnum - 1] = (Datum)(*fmgr_faddr(&finfo))
- (ret_values[i++],
- typelem,
- (!VARLENA_FIXED_SIZE(tupdesc->attrs[attnum - 1]))
- ? tupdesc->attrs[attnum - 1]->attlen
- : tupdesc->attrs[attnum - 1]->atttypmod
- );
- }
+ if (Tcl_SplitList(pltcl_safe_interp, pltcl_safe_interp->result,
+ &ret_numvals, &ret_values) != TCL_OK)
+ {
+ elog(NOTICE, "pltcl: cannot split return value from trigger");
+ elog(ERROR, "pltcl: %s", pltcl_safe_interp->result);
+ }
+ if (ret_numvals % 2 != 0)
+ {
+ ckfree(ret_values);
+ elog(ERROR, "pltcl: invalid return list from trigger - must have even # of elements");
+ }
- rettup = SPI_modifytuple(trigdata->tg_relation, rettup, tupdesc->natts,
- modattrs, modvalues, modnulls);
+ modattrs = (int *) palloc(tupdesc->natts * sizeof(int));
+ modvalues = (Datum *) palloc(tupdesc->natts * sizeof(Datum));
+ for (i = 0; i < tupdesc->natts; i++)
+ {
+ modattrs[i] = i + 1;
+ modvalues[i] = (Datum) NULL;
+ }
- pfree(modattrs);
- pfree(modvalues);
- pfree(modnulls);
+ modnulls = palloc(tupdesc->natts + 1);
+ memset(modnulls, 'n', tupdesc->natts);
+ modnulls[tupdesc->natts] = '\0';
- if (rettup == NULL) {
- elog(ERROR, "pltcl: SPI_modifytuple() failed - RC = %d\n", SPI_result);
- }
+ /************************************************************
+ * Care for possible elog(ERROR)'s below
+ ************************************************************/
+ if (sigsetjmp(Warn_restart, 1) != 0)
+ {
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ ckfree(ret_values);
+ pltcl_restart_in_progress = 1;
+ if (--pltcl_call_level == 0)
+ {
+ pltcl_restart_in_progress = 0;
+ }
+ siglongjmp(Warn_restart, 1);
+ }
- ckfree(ret_values);
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ i = 0;
+ while (i < ret_numvals)
+ {
+ int attnum;
+ HeapTuple typeTup;
+ Oid typinput;
+ Oid typelem;
+ FmgrInfo finfo;
+
+ /************************************************************
+ * Ignore pseudo elements with a dot name
+ ************************************************************/
+ if (*(ret_values[i]) == '.')
+ {
+ i += 2;
+ continue;
+ }
- return rettup;
+ /************************************************************
+ * Get the attribute number
+ ************************************************************/
+ attnum = SPI_fnumber(tupdesc, ret_values[i++]);
+ if (attnum == SPI_ERROR_NOATTRIBUTE)
+ {
+ elog(ERROR, "pltcl: invalid attribute '%s'", ret_values[--i]);
+ }
+
+ /************************************************************
+ * Lookup the attribute type in the syscache
+ * for the input function
+ ************************************************************/
+ typeTup = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(tupdesc->attrs[attnum - 1]->atttypid),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(typeTup))
+ {
+ elog(ERROR, "pltcl: Cache lookup for attribute '%s' type %ld failed",
+ ret_values[--i],
+ ObjectIdGetDatum(tupdesc->attrs[attnum - 1]->atttypid));
+ }
+ typinput = (Oid) (((TypeTupleForm) GETSTRUCT(typeTup))->typinput);
+ typelem = (Oid) (((TypeTupleForm) GETSTRUCT(typeTup))->typelem);
+
+ /************************************************************
+ * Set the attribute to NOT NULL and convert the contents
+ ************************************************************/
+ modnulls[attnum - 1] = ' ';
+ fmgr_info(typinput, &finfo);
+ modvalues[attnum - 1] = (Datum) (*fmgr_faddr(&finfo))
+ (ret_values[i++],
+ typelem,
+ (!VARLENA_FIXED_SIZE(tupdesc->attrs[attnum - 1]))
+ ? tupdesc->attrs[attnum - 1]->attlen
+ : tupdesc->attrs[attnum - 1]->atttypmod
+ );
+ }
+
+
+ rettup = SPI_modifytuple(trigdata->tg_relation, rettup, tupdesc->natts,
+ modattrs, modvalues, modnulls);
+
+ pfree(modattrs);
+ pfree(modvalues);
+ pfree(modnulls);
+
+ if (rettup == NULL)
+ {
+ elog(ERROR, "pltcl: SPI_modifytuple() failed - RC = %d\n", SPI_result);
+ }
+
+ ckfree(ret_values);
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+
+ return rettup;
}
/**********************************************************************
* pltcl_elog() - elog() support for PLTcl
**********************************************************************/
-static int pltcl_elog(ClientData cdata, Tcl_Interp *interp,
- int argc, char *argv[])
+static int
+pltcl_elog(ClientData cdata, Tcl_Interp * interp,
+ int argc, char *argv[])
{
- int level;
- sigjmp_buf save_restart;
-
- /************************************************************
- * Suppress messages during the restart process
- ************************************************************/
- if (pltcl_restart_in_progress)
- return TCL_ERROR;
-
- /************************************************************
- * Catch the restart longjmp and begin a controlled
- * return though all interpreter levels if it happens
- ************************************************************/
- memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
- if (sigsetjmp(Warn_restart, 1) != 0) {
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- pltcl_restart_in_progress = 1;
- return TCL_ERROR;
- }
-
- if (argc != 3) {
- Tcl_SetResult(interp, "syntax error - 'elog level msg'",
- TCL_VOLATILE);
- return TCL_ERROR;
- }
-
- if (strcmp(argv[1], "NOTICE") == 0) {
- level = NOTICE;
- } else
- if (strcmp(argv[1], "WARN") == 0) {
- level = ERROR;
- } else
- if (strcmp(argv[1], "ERROR") == 0) {
- level = ERROR;
- } else
- if (strcmp(argv[1], "FATAL") == 0) {
- level = FATAL;
- } else
- if (strcmp(argv[1], "DEBUG") == 0) {
- level = DEBUG;
- } else
- if (strcmp(argv[1], "NOIND") == 0) {
- level = NOIND;
- } else {
- Tcl_AppendResult(interp, "Unknown elog level '", argv[1],
- "'", NULL);
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- return TCL_ERROR;
- }
-
- /************************************************************
- * Call elog(), restore the original restart address
- * and return to the caller (if not catched)
- ************************************************************/
- elog(level, argv[2]);
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- return TCL_OK;
+ int level;
+ sigjmp_buf save_restart;
+
+ /************************************************************
+ * Suppress messages during the restart process
+ ************************************************************/
+ if (pltcl_restart_in_progress)
+ return TCL_ERROR;
+
+ /************************************************************
+ * Catch the restart longjmp and begin a controlled
+ * return though all interpreter levels if it happens
+ ************************************************************/
+ memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
+ if (sigsetjmp(Warn_restart, 1) != 0)
+ {
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ pltcl_restart_in_progress = 1;
+ return TCL_ERROR;
+ }
+
+ if (argc != 3)
+ {
+ Tcl_SetResult(interp, "syntax error - 'elog level msg'",
+ TCL_VOLATILE);
+ return TCL_ERROR;
+ }
+
+ if (strcmp(argv[1], "NOTICE") == 0)
+ {
+ level = NOTICE;
+ }
+ else if (strcmp(argv[1], "WARN") == 0)
+ {
+ level = ERROR;
+ }
+ else if (strcmp(argv[1], "ERROR") == 0)
+ {
+ level = ERROR;
+ }
+ else if (strcmp(argv[1], "FATAL") == 0)
+ {
+ level = FATAL;
+ }
+ else if (strcmp(argv[1], "DEBUG") == 0)
+ {
+ level = DEBUG;
+ }
+ else if (strcmp(argv[1], "NOIND") == 0)
+ {
+ level = NOIND;
+ }
+ else
+ {
+ Tcl_AppendResult(interp, "Unknown elog level '", argv[1],
+ "'", NULL);
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ return TCL_ERROR;
+ }
+
+ /************************************************************
+ * Call elog(), restore the original restart address
+ * and return to the caller (if not catched)
+ ************************************************************/
+ elog(level, argv[2]);
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ return TCL_OK;
}
* pltcl_quote() - quote literal strings that are to
* be used in SPI_exec query strings
**********************************************************************/
-static int pltcl_quote(ClientData cdata, Tcl_Interp *interp,
- int argc, char *argv[])
+static int
+pltcl_quote(ClientData cdata, Tcl_Interp * interp,
+ int argc, char *argv[])
{
- char *tmp;
- char *cp1;
- char *cp2;
-
- /************************************************************
- * Check call syntax
- ************************************************************/
- if (argc != 2) {
- Tcl_SetResult(interp, "syntax error - 'quote string'", TCL_VOLATILE);
- return TCL_ERROR;
- }
-
- /************************************************************
- * Allocate space for the maximum the string can
- * grow to and initialize pointers
- ************************************************************/
- tmp = palloc(strlen(argv[1]) * 2 + 1);
- cp1 = argv[1];
- cp2 = tmp;
-
- /************************************************************
- * Walk through string and double every quote and backslash
- ************************************************************/
- while (*cp1) {
- if (*cp1 == '\'') {
- *cp2++ = '\'';
- } else {
- if (*cp1 == '\\') {
- *cp2++ = '\\';
- }
- }
- *cp2++ = *cp1++;
- }
-
- /************************************************************
- * Terminate the string and set it as result
- ************************************************************/
- *cp2 = '\0';
- Tcl_SetResult(interp, tmp, TCL_VOLATILE);
- pfree(tmp);
- return TCL_OK;
+ char *tmp;
+ char *cp1;
+ char *cp2;
+
+ /************************************************************
+ * Check call syntax
+ ************************************************************/
+ if (argc != 2)
+ {
+ Tcl_SetResult(interp, "syntax error - 'quote string'", TCL_VOLATILE);
+ return TCL_ERROR;
+ }
+
+ /************************************************************
+ * Allocate space for the maximum the string can
+ * grow to and initialize pointers
+ ************************************************************/
+ tmp = palloc(strlen(argv[1]) * 2 + 1);
+ cp1 = argv[1];
+ cp2 = tmp;
+
+ /************************************************************
+ * Walk through string and double every quote and backslash
+ ************************************************************/
+ while (*cp1)
+ {
+ if (*cp1 == '\'')
+ {
+ *cp2++ = '\'';
+ }
+ else
+ {
+ if (*cp1 == '\\')
+ {
+ *cp2++ = '\\';
+ }
+ }
+ *cp2++ = *cp1++;
+ }
+
+ /************************************************************
+ * Terminate the string and set it as result
+ ************************************************************/
+ *cp2 = '\0';
+ Tcl_SetResult(interp, tmp, TCL_VOLATILE);
+ pfree(tmp);
+ return TCL_OK;
}
* pltcl_SPI_exec() - The builtin SPI_exec command
* for the safe interpreter
**********************************************************************/
-static int pltcl_SPI_exec(ClientData cdata, Tcl_Interp *interp,
- int argc, char *argv[])
+static int
+pltcl_SPI_exec(ClientData cdata, Tcl_Interp * interp,
+ int argc, char *argv[])
{
- int spi_rc;
- char buf[64];
- int count = 0;
- char *arrayname = NULL;
- int query_idx;
- int i;
- int loop_rc;
- int ntuples;
- HeapTuple *tuples;
- TupleDesc tupdesc;
- sigjmp_buf save_restart;
-
- char *usage = "syntax error - 'SPI_exec "
- "?-count n? "
- "?-array name? query ?loop body?";
-
- /************************************************************
- * Don't do anything if we are already in restart mode
- ************************************************************/
- if (pltcl_restart_in_progress)
- return TCL_ERROR;
-
- /************************************************************
- * Check the call syntax and get the count option
- ************************************************************/
- if (argc < 2) {
- Tcl_SetResult(interp, usage, TCL_VOLATILE);
- return TCL_ERROR;
- }
-
- i = 1;
- while (i < argc) {
- if (strcmp(argv[i], "-array") == 0) {
- if (++i >= argc) {
- Tcl_SetResult(interp, usage, TCL_VOLATILE);
+ int spi_rc;
+ char buf[64];
+ int count = 0;
+ char *arrayname = NULL;
+ int query_idx;
+ int i;
+ int loop_rc;
+ int ntuples;
+ HeapTuple *tuples;
+ TupleDesc tupdesc;
+ sigjmp_buf save_restart;
+
+ char *usage = "syntax error - 'SPI_exec "
+ "?-count n? "
+ "?-array name? query ?loop body?";
+
+ /************************************************************
+ * Don't do anything if we are already in restart mode
+ ************************************************************/
+ if (pltcl_restart_in_progress)
+ return TCL_ERROR;
+
+ /************************************************************
+ * Check the call syntax and get the count option
+ ************************************************************/
+ if (argc < 2)
+ {
+ Tcl_SetResult(interp, usage, TCL_VOLATILE);
+ return TCL_ERROR;
+ }
+
+ i = 1;
+ while (i < argc)
+ {
+ if (strcmp(argv[i], "-array") == 0)
+ {
+ if (++i >= argc)
+ {
+ Tcl_SetResult(interp, usage, TCL_VOLATILE);
+ return TCL_ERROR;
+ }
+ arrayname = argv[i++];
+ continue;
+ }
+
+ if (strcmp(argv[i], "-count") == 0)
+ {
+ if (++i >= argc)
+ {
+ Tcl_SetResult(interp, usage, TCL_VOLATILE);
+ return TCL_ERROR;
+ }
+ if (Tcl_GetInt(interp, argv[i++], &count) != TCL_OK)
+ {
+ return TCL_ERROR;
+ }
+ continue;
+ }
+
+ break;
+ }
+
+ query_idx = i;
+ if (query_idx >= argc)
+ {
+ Tcl_SetResult(interp, usage, TCL_VOLATILE);
+ return TCL_ERROR;
+ }
+
+ /************************************************************
+ * Prepare to start a controlled return through all
+ * interpreter levels on transaction abort
+ ************************************************************/
+ memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
+ if (sigsetjmp(Warn_restart, 1) != 0)
+ {
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ pltcl_restart_in_progress = 1;
+ Tcl_SetResult(interp, "Transaction abort", TCL_VOLATILE);
+ return TCL_ERROR;
+ }
+
+ /************************************************************
+ * Execute the query and handle return codes
+ ************************************************************/
+ spi_rc = SPI_exec(argv[query_idx], count);
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+
+ switch (spi_rc)
+ {
+ case SPI_OK_UTILITY:
+ Tcl_SetResult(interp, "0", TCL_VOLATILE);
+ return TCL_OK;
+
+ case SPI_OK_SELINTO:
+ case SPI_OK_INSERT:
+ case SPI_OK_DELETE:
+ case SPI_OK_UPDATE:
+ sprintf(buf, "%d", SPI_processed);
+ Tcl_SetResult(interp, buf, TCL_VOLATILE);
+ return TCL_OK;
+
+ case SPI_OK_SELECT:
+ break;
+
+ case SPI_ERROR_ARGUMENT:
+ Tcl_SetResult(interp,
+ "pltcl: SPI_exec() failed - SPI_ERROR_ARGUMENT",
+ TCL_VOLATILE);
+ return TCL_ERROR;
+
+ case SPI_ERROR_UNCONNECTED:
+ Tcl_SetResult(interp,
+ "pltcl: SPI_exec() failed - SPI_ERROR_UNCONNECTED",
+ TCL_VOLATILE);
+ return TCL_ERROR;
+
+ case SPI_ERROR_COPY:
+ Tcl_SetResult(interp,
+ "pltcl: SPI_exec() failed - SPI_ERROR_COPY",
+ TCL_VOLATILE);
+ return TCL_ERROR;
+
+ case SPI_ERROR_CURSOR:
+ Tcl_SetResult(interp,
+ "pltcl: SPI_exec() failed - SPI_ERROR_CURSOR",
+ TCL_VOLATILE);
+ return TCL_ERROR;
+
+ case SPI_ERROR_TRANSACTION:
+ Tcl_SetResult(interp,
+ "pltcl: SPI_exec() failed - SPI_ERROR_TRANSACTION",
+ TCL_VOLATILE);
+ return TCL_ERROR;
+
+ case SPI_ERROR_OPUNKNOWN:
+ Tcl_SetResult(interp,
+ "pltcl: SPI_exec() failed - SPI_ERROR_OPUNKNOWN",
+ TCL_VOLATILE);
+ return TCL_ERROR;
+
+ default:
+ sprintf(buf, "%d", spi_rc);
+ Tcl_AppendResult(interp, "pltcl: SPI_exec() failed - ",
+ "unknown RC ", buf, NULL);
+ return TCL_ERROR;
+ }
+
+ /************************************************************
+ * Only SELECT queries fall through to here - remember the
+ * tuples we got
+ ************************************************************/
+
+ ntuples = SPI_processed;
+ if (ntuples > 0)
+ {
+ tuples = SPI_tuptable->vals;
+ tupdesc = SPI_tuptable->tupdesc;
+ }
+
+ /************************************************************
+ * Again prepare for elog(ERROR)
+ ************************************************************/
+ if (sigsetjmp(Warn_restart, 1) != 0)
+ {
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ pltcl_restart_in_progress = 1;
+ Tcl_SetResult(interp, "Transaction abort", TCL_VOLATILE);
return TCL_ERROR;
- }
- arrayname = argv[i++];
- continue;
}
- if (strcmp(argv[i], "-count") == 0) {
- if (++i >= argc) {
- Tcl_SetResult(interp, usage, TCL_VOLATILE);
+ /************************************************************
+ * If there is no loop body given, just set the variables
+ * from the first tuple (if any) and return the number of
+ * tuples selected
+ ************************************************************/
+ if (argc == query_idx + 1)
+ {
+ if (ntuples > 0)
+ {
+ pltcl_set_tuple_values(interp, arrayname, 0, tuples[0], tupdesc);
+ }
+ sprintf(buf, "%d", ntuples);
+ Tcl_SetResult(interp, buf, TCL_VOLATILE);
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ return TCL_OK;
+ }
+
+ /************************************************************
+ * There is a loop body - process all tuples and evaluate
+ * the body on each
+ ************************************************************/
+ query_idx++;
+ for (i = 0; i < ntuples; i++)
+ {
+ pltcl_set_tuple_values(interp, arrayname, i, tuples[i], tupdesc);
+
+ loop_rc = Tcl_Eval(interp, argv[query_idx]);
+
+ if (loop_rc == TCL_OK)
+ continue;
+ if (loop_rc == TCL_CONTINUE)
+ continue;
+ if (loop_rc == TCL_RETURN)
+ {
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ return TCL_RETURN;
+ }
+ if (loop_rc == TCL_BREAK)
+ break;
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
return TCL_ERROR;
- }
- if (Tcl_GetInt(interp, argv[i++], &count) != TCL_OK) {
- return TCL_ERROR;
- }
- continue;
- }
-
- break;
- }
-
- query_idx = i;
- if (query_idx >= argc) {
- Tcl_SetResult(interp, usage, TCL_VOLATILE);
- return TCL_ERROR;
- }
-
- /************************************************************
- * Prepare to start a controlled return through all
- * interpreter levels on transaction abort
- ************************************************************/
- memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
- if (sigsetjmp(Warn_restart, 1) != 0) {
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- pltcl_restart_in_progress = 1;
- Tcl_SetResult(interp, "Transaction abort", TCL_VOLATILE);
- return TCL_ERROR;
- }
-
- /************************************************************
- * Execute the query and handle return codes
- ************************************************************/
- spi_rc = SPI_exec(argv[query_idx], count);
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
-
- switch (spi_rc) {
- case SPI_OK_UTILITY:
- Tcl_SetResult(interp, "0", TCL_VOLATILE);
- return TCL_OK;
-
- case SPI_OK_SELINTO:
- case SPI_OK_INSERT:
- case SPI_OK_DELETE:
- case SPI_OK_UPDATE:
- sprintf(buf, "%d", SPI_processed);
- Tcl_SetResult(interp, buf, TCL_VOLATILE);
- return TCL_OK;
-
- case SPI_OK_SELECT:
- break;
-
- case SPI_ERROR_ARGUMENT:
- Tcl_SetResult(interp,
- "pltcl: SPI_exec() failed - SPI_ERROR_ARGUMENT",
- TCL_VOLATILE);
- return TCL_ERROR;
-
- case SPI_ERROR_UNCONNECTED:
- Tcl_SetResult(interp,
- "pltcl: SPI_exec() failed - SPI_ERROR_UNCONNECTED",
- TCL_VOLATILE);
- return TCL_ERROR;
-
- case SPI_ERROR_COPY:
- Tcl_SetResult(interp,
- "pltcl: SPI_exec() failed - SPI_ERROR_COPY",
- TCL_VOLATILE);
- return TCL_ERROR;
-
- case SPI_ERROR_CURSOR:
- Tcl_SetResult(interp,
- "pltcl: SPI_exec() failed - SPI_ERROR_CURSOR",
- TCL_VOLATILE);
- return TCL_ERROR;
-
- case SPI_ERROR_TRANSACTION:
- Tcl_SetResult(interp,
- "pltcl: SPI_exec() failed - SPI_ERROR_TRANSACTION",
- TCL_VOLATILE);
- return TCL_ERROR;
-
- case SPI_ERROR_OPUNKNOWN:
- Tcl_SetResult(interp,
- "pltcl: SPI_exec() failed - SPI_ERROR_OPUNKNOWN",
- TCL_VOLATILE);
- return TCL_ERROR;
-
- default:
- sprintf(buf, "%d", spi_rc);
- Tcl_AppendResult(interp, "pltcl: SPI_exec() failed - ",
- "unknown RC ", buf, NULL);
- return TCL_ERROR;
- }
-
- /************************************************************
- * Only SELECT queries fall through to here - remember the
- * tuples we got
- ************************************************************/
-
- ntuples = SPI_processed;
- if (ntuples > 0) {
- tuples = SPI_tuptable->vals;
- tupdesc = SPI_tuptable->tupdesc;
- }
-
- /************************************************************
- * Again prepare for elog(ERROR)
- ************************************************************/
- if (sigsetjmp(Warn_restart, 1) != 0) {
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- pltcl_restart_in_progress = 1;
- Tcl_SetResult(interp, "Transaction abort", TCL_VOLATILE);
- return TCL_ERROR;
- }
-
- /************************************************************
- * If there is no loop body given, just set the variables
- * from the first tuple (if any) and return the number of
- * tuples selected
- ************************************************************/
- if (argc == query_idx + 1) {
- if (ntuples > 0) {
- pltcl_set_tuple_values(interp, arrayname, 0, tuples[0], tupdesc);
- }
- sprintf(buf, "%d", ntuples);
+ }
+
+ /************************************************************
+ * Finally return the number of tuples
+ ************************************************************/
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ sprintf(buf, "%d", ntuples);
Tcl_SetResult(interp, buf, TCL_VOLATILE);
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
return TCL_OK;
- }
-
- /************************************************************
- * There is a loop body - process all tuples and evaluate
- * the body on each
- ************************************************************/
- query_idx++;
- for (i = 0; i < ntuples; i++) {
- pltcl_set_tuple_values(interp, arrayname, i, tuples[i], tupdesc);
-
- loop_rc = Tcl_Eval(interp, argv[query_idx]);
-
- if (loop_rc == TCL_OK) continue;
- if (loop_rc == TCL_CONTINUE) continue;
- if (loop_rc == TCL_RETURN) {
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- return TCL_RETURN;
- }
- if (loop_rc == TCL_BREAK) break;
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- return TCL_ERROR;
- }
-
- /************************************************************
- * Finally return the number of tuples
- ************************************************************/
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- sprintf(buf, "%d", ntuples);
- Tcl_SetResult(interp, buf, TCL_VOLATILE);
- return TCL_OK;
}
* access. There is no chance to prepare
* and not save the plan currently.
**********************************************************************/
-static int pltcl_SPI_prepare(ClientData cdata, Tcl_Interp *interp,
- int argc, char *argv[])
+static int
+pltcl_SPI_prepare(ClientData cdata, Tcl_Interp * interp,
+ int argc, char *argv[])
{
- int nargs;
- char **args;
- pltcl_query_desc *qdesc;
- void *plan;
- int i;
- HeapTuple typeTup;
- Tcl_HashEntry *hashent;
- int hashnew;
- sigjmp_buf save_restart;
-
- /************************************************************
- * Don't do anything if we are already in restart mode
- ************************************************************/
- if (pltcl_restart_in_progress)
- return TCL_ERROR;
-
- /************************************************************
- * Check the call syntax
- ************************************************************/
- if (argc != 3) {
- Tcl_SetResult(interp, "syntax error - 'SPI_prepare query argtypes'",
- TCL_VOLATILE);
- return TCL_ERROR;
- }
-
- /************************************************************
- * Split the argument type list
- ************************************************************/
- if (Tcl_SplitList(interp, argv[2], &nargs, &args) != TCL_OK) {
- return TCL_ERROR;
- }
-
- /************************************************************
- * Allocate the new querydesc structure
- ************************************************************/
- qdesc = (pltcl_query_desc *)malloc(sizeof(pltcl_query_desc));
- sprintf(qdesc->qname, "%lx", (long)qdesc);
- qdesc->nargs = nargs;
- qdesc->argtypes = (Oid *)malloc(nargs * sizeof(Oid));
- qdesc->arginfuncs = (FmgrInfo *)malloc(nargs * sizeof(FmgrInfo));
- qdesc->argtypelems = (Oid *)malloc(nargs * sizeof(Oid));
- qdesc->argvalues = (Datum *)malloc(nargs * sizeof(Datum));
- qdesc->arglen = (int *)malloc(nargs * sizeof(int));
-
- /************************************************************
- * Prepare to start a controlled return through all
- * interpreter levels on transaction abort
- ************************************************************/
- memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
- if (sigsetjmp(Warn_restart, 1) != 0) {
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- pltcl_restart_in_progress = 1;
- free(qdesc->argtypes);
- free(qdesc->arginfuncs);
- free(qdesc->argtypelems);
- free(qdesc->argvalues);
- free(qdesc->arglen);
- free(qdesc);
- ckfree(args);
- return TCL_ERROR;
- }
-
- /************************************************************
- * Lookup the argument types by name in the system cache
- * and remember the required information for input conversion
- ************************************************************/
- for (i = 0; i < nargs; i++) {
- typeTup = SearchSysCacheTuple(TYPNAME,
- PointerGetDatum(args[i]),
- 0, 0, 0);
- if (!HeapTupleIsValid(typeTup)) {
- elog(ERROR, "pltcl: Cache lookup of type %s failed", args[i]);
- }
- qdesc->argtypes[i] = typeTup->t_oid;
- fmgr_info(((TypeTupleForm) GETSTRUCT(typeTup))->typinput,
- &(qdesc->arginfuncs[i]));
- qdesc->argtypelems[i] = ((TypeTupleForm) GETSTRUCT(typeTup))->typelem;
- qdesc->argvalues[i] = (Datum)NULL;
- qdesc->arglen[i] = (int)(((TypeTupleForm) GETSTRUCT(typeTup))->typlen);
- }
-
- /************************************************************
- * Prepare the plan and check for errors
- ************************************************************/
- plan = SPI_prepare(argv[1], nargs, qdesc->argtypes);
-
- if (plan == NULL) {
- char buf[128];
- char *reason;
+ int nargs;
+ char **args;
+ pltcl_query_desc *qdesc;
+ void *plan;
+ int i;
+ HeapTuple typeTup;
+ Tcl_HashEntry *hashent;
+ int hashnew;
+ sigjmp_buf save_restart;
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ /************************************************************
+ * Don't do anything if we are already in restart mode
+ ************************************************************/
+ if (pltcl_restart_in_progress)
+ return TCL_ERROR;
- switch(SPI_result) {
- case SPI_ERROR_ARGUMENT:
- reason = "SPI_ERROR_ARGUMENT";
- break;
+ /************************************************************
+ * Check the call syntax
+ ************************************************************/
+ if (argc != 3)
+ {
+ Tcl_SetResult(interp, "syntax error - 'SPI_prepare query argtypes'",
+ TCL_VOLATILE);
+ return TCL_ERROR;
+ }
- case SPI_ERROR_UNCONNECTED:
- reason = "SPI_ERROR_UNCONNECTED";
- break;
+ /************************************************************
+ * Split the argument type list
+ ************************************************************/
+ if (Tcl_SplitList(interp, argv[2], &nargs, &args) != TCL_OK)
+ {
+ return TCL_ERROR;
+ }
- case SPI_ERROR_COPY:
- reason = "SPI_ERROR_COPY";
- break;
+ /************************************************************
+ * Allocate the new querydesc structure
+ ************************************************************/
+ qdesc = (pltcl_query_desc *) malloc(sizeof(pltcl_query_desc));
+ sprintf(qdesc->qname, "%lx", (long) qdesc);
+ qdesc->nargs = nargs;
+ qdesc->argtypes = (Oid *) malloc(nargs * sizeof(Oid));
+ qdesc->arginfuncs = (FmgrInfo *) malloc(nargs * sizeof(FmgrInfo));
+ qdesc->argtypelems = (Oid *) malloc(nargs * sizeof(Oid));
+ qdesc->argvalues = (Datum *) malloc(nargs * sizeof(Datum));
+ qdesc->arglen = (int *) malloc(nargs * sizeof(int));
- case SPI_ERROR_CURSOR:
- reason = "SPI_ERROR_CURSOR";
- break;
+ /************************************************************
+ * Prepare to start a controlled return through all
+ * interpreter levels on transaction abort
+ ************************************************************/
+ memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
+ if (sigsetjmp(Warn_restart, 1) != 0)
+ {
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ pltcl_restart_in_progress = 1;
+ free(qdesc->argtypes);
+ free(qdesc->arginfuncs);
+ free(qdesc->argtypelems);
+ free(qdesc->argvalues);
+ free(qdesc->arglen);
+ free(qdesc);
+ ckfree(args);
+ return TCL_ERROR;
+ }
- case SPI_ERROR_TRANSACTION:
- reason = "SPI_ERROR_TRANSACTION";
- break;
+ /************************************************************
+ * Lookup the argument types by name in the system cache
+ * and remember the required information for input conversion
+ ************************************************************/
+ for (i = 0; i < nargs; i++)
+ {
+ typeTup = SearchSysCacheTuple(TYPNAME,
+ PointerGetDatum(args[i]),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(typeTup))
+ {
+ elog(ERROR, "pltcl: Cache lookup of type %s failed", args[i]);
+ }
+ qdesc->argtypes[i] = typeTup->t_oid;
+ fmgr_info(((TypeTupleForm) GETSTRUCT(typeTup))->typinput,
+ &(qdesc->arginfuncs[i]));
+ qdesc->argtypelems[i] = ((TypeTupleForm) GETSTRUCT(typeTup))->typelem;
+ qdesc->argvalues[i] = (Datum) NULL;
+ qdesc->arglen[i] = (int) (((TypeTupleForm) GETSTRUCT(typeTup))->typlen);
+ }
- case SPI_ERROR_OPUNKNOWN:
- reason = "SPI_ERROR_OPUNKNOWN";
- break;
+ /************************************************************
+ * Prepare the plan and check for errors
+ ************************************************************/
+ plan = SPI_prepare(argv[1], nargs, qdesc->argtypes);
- default:
- sprintf(buf, "unknown RC %d", SPI_result);
- reason = buf;
- break;
-
- }
+ if (plan == NULL)
+ {
+ char buf[128];
+ char *reason;
- elog(ERROR, "pltcl: SPI_prepare() failed - %s", reason);
- }
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- /************************************************************
- * Save the plan
- ************************************************************/
- qdesc->plan = SPI_saveplan(plan);
- if (qdesc->plan == NULL) {
- char buf[128];
- char *reason;
+ switch (SPI_result)
+ {
+ case SPI_ERROR_ARGUMENT:
+ reason = "SPI_ERROR_ARGUMENT";
+ break;
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ case SPI_ERROR_UNCONNECTED:
+ reason = "SPI_ERROR_UNCONNECTED";
+ break;
- switch(SPI_result) {
- case SPI_ERROR_ARGUMENT:
- reason = "SPI_ERROR_ARGUMENT";
- break;
+ case SPI_ERROR_COPY:
+ reason = "SPI_ERROR_COPY";
+ break;
- case SPI_ERROR_UNCONNECTED:
- reason = "SPI_ERROR_UNCONNECTED";
- break;
+ case SPI_ERROR_CURSOR:
+ reason = "SPI_ERROR_CURSOR";
+ break;
- default:
- sprintf(buf, "unknown RC %d", SPI_result);
- reason = buf;
- break;
-
+ case SPI_ERROR_TRANSACTION:
+ reason = "SPI_ERROR_TRANSACTION";
+ break;
+
+ case SPI_ERROR_OPUNKNOWN:
+ reason = "SPI_ERROR_OPUNKNOWN";
+ break;
+
+ default:
+ sprintf(buf, "unknown RC %d", SPI_result);
+ reason = buf;
+ break;
+
+ }
+
+ elog(ERROR, "pltcl: SPI_prepare() failed - %s", reason);
}
- elog(ERROR, "pltcl: SPI_saveplan() failed - %s", reason);
- }
+ /************************************************************
+ * Save the plan
+ ************************************************************/
+ qdesc->plan = SPI_saveplan(plan);
+ if (qdesc->plan == NULL)
+ {
+ char buf[128];
+ char *reason;
+
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+
+ switch (SPI_result)
+ {
+ case SPI_ERROR_ARGUMENT:
+ reason = "SPI_ERROR_ARGUMENT";
+ break;
+
+ case SPI_ERROR_UNCONNECTED:
+ reason = "SPI_ERROR_UNCONNECTED";
+ break;
+
+ default:
+ sprintf(buf, "unknown RC %d", SPI_result);
+ reason = buf;
+ break;
+
+ }
- /************************************************************
- * Insert a hashtable entry for the plan and return
- * the key to the caller
- ************************************************************/
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- hashent = Tcl_CreateHashEntry(pltcl_query_hash, qdesc->qname, &hashnew);
- Tcl_SetHashValue(hashent, (ClientData)qdesc);
+ elog(ERROR, "pltcl: SPI_saveplan() failed - %s", reason);
+ }
+
+ /************************************************************
+ * Insert a hashtable entry for the plan and return
+ * the key to the caller
+ ************************************************************/
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ hashent = Tcl_CreateHashEntry(pltcl_query_hash, qdesc->qname, &hashnew);
+ Tcl_SetHashValue(hashent, (ClientData) qdesc);
- Tcl_SetResult(interp, qdesc->qname, TCL_VOLATILE);
- return TCL_OK;
+ Tcl_SetResult(interp, qdesc->qname, TCL_VOLATILE);
+ return TCL_OK;
}
/**********************************************************************
* pltcl_SPI_execp() - Execute a prepared plan
**********************************************************************/
-static int pltcl_SPI_execp(ClientData cdata, Tcl_Interp *interp,
- int argc, char *argv[])
+static int
+pltcl_SPI_execp(ClientData cdata, Tcl_Interp * interp,
+ int argc, char *argv[])
{
- int spi_rc;
- char buf[64];
- int i, j;
- int loop_body;
- Tcl_HashEntry *hashent;
- pltcl_query_desc *qdesc;
- char *nulls = NULL;
- char *arrayname = NULL;
- int count = 0;
- int callnargs;
- static char **callargs = NULL;
- int loop_rc;
- int ntuples;
- HeapTuple *tuples = NULL;
- TupleDesc tupdesc = NULL;
- sigjmp_buf save_restart;
-
- char *usage = "syntax error - 'SPI_execp "
- "?-nulls string? ?-count n? "
- "?-array name? query ?args? ?loop body?";
-
- /************************************************************
- * Tidy up from an earlier abort
- ************************************************************/
- if (callargs != NULL) {
- ckfree(callargs);
- callargs = NULL;
- }
-
- /************************************************************
- * Don't do anything if we are already in restart mode
- ************************************************************/
- if (pltcl_restart_in_progress)
- return TCL_ERROR;
-
- /************************************************************
- * Get the options and check syntax
- ************************************************************/
- i = 1;
- while (i < argc) {
- if (strcmp(argv[i], "-array") == 0) {
- if (++i >= argc) {
- Tcl_SetResult(interp, usage, TCL_VOLATILE);
- return TCL_ERROR;
- }
- arrayname = argv[i++];
- continue;
+ int spi_rc;
+ char buf[64];
+ int i,
+ j;
+ int loop_body;
+ Tcl_HashEntry *hashent;
+ pltcl_query_desc *qdesc;
+ char *nulls = NULL;
+ char *arrayname = NULL;
+ int count = 0;
+ int callnargs;
+ static char **callargs = NULL;
+ int loop_rc;
+ int ntuples;
+ HeapTuple *tuples = NULL;
+ TupleDesc tupdesc = NULL;
+ sigjmp_buf save_restart;
+
+ char *usage = "syntax error - 'SPI_execp "
+ "?-nulls string? ?-count n? "
+ "?-array name? query ?args? ?loop body?";
+
+ /************************************************************
+ * Tidy up from an earlier abort
+ ************************************************************/
+ if (callargs != NULL)
+ {
+ ckfree(callargs);
+ callargs = NULL;
}
- if (strcmp(argv[i], "-nulls") == 0) {
- if (++i >= argc) {
- Tcl_SetResult(interp, usage, TCL_VOLATILE);
+
+ /************************************************************
+ * Don't do anything if we are already in restart mode
+ ************************************************************/
+ if (pltcl_restart_in_progress)
return TCL_ERROR;
- }
- nulls = argv[i++];
- continue;
+
+ /************************************************************
+ * Get the options and check syntax
+ ************************************************************/
+ i = 1;
+ while (i < argc)
+ {
+ if (strcmp(argv[i], "-array") == 0)
+ {
+ if (++i >= argc)
+ {
+ Tcl_SetResult(interp, usage, TCL_VOLATILE);
+ return TCL_ERROR;
+ }
+ arrayname = argv[i++];
+ continue;
+ }
+ if (strcmp(argv[i], "-nulls") == 0)
+ {
+ if (++i >= argc)
+ {
+ Tcl_SetResult(interp, usage, TCL_VOLATILE);
+ return TCL_ERROR;
+ }
+ nulls = argv[i++];
+ continue;
+ }
+ if (strcmp(argv[i], "-count") == 0)
+ {
+ if (++i >= argc)
+ {
+ Tcl_SetResult(interp, usage, TCL_VOLATILE);
+ return TCL_ERROR;
+ }
+ if (Tcl_GetInt(interp, argv[i++], &count) != TCL_OK)
+ {
+ return TCL_ERROR;
+ }
+ continue;
+ }
+
+ break;
}
- if (strcmp(argv[i], "-count") == 0) {
- if (++i >= argc) {
- Tcl_SetResult(interp, usage, TCL_VOLATILE);
+
+ /************************************************************
+ * Check minimum call arguments
+ ************************************************************/
+ if (i >= argc)
+ {
+ Tcl_SetResult(interp, usage, TCL_VOLATILE);
return TCL_ERROR;
- }
- if (Tcl_GetInt(interp, argv[i++], &count) != TCL_OK) {
- return TCL_ERROR;
- }
- continue;
- }
-
- break;
- }
-
- /************************************************************
- * Check minimum call arguments
- ************************************************************/
- if (i >= argc) {
- Tcl_SetResult(interp, usage, TCL_VOLATILE);
- return TCL_ERROR;
- }
-
- /************************************************************
- * Get the prepared plan descriptor by it's key
- ************************************************************/
- hashent = Tcl_FindHashEntry(pltcl_query_hash, argv[i++]);
- if (hashent == NULL) {
- Tcl_AppendResult(interp, "invalid queryid '", argv[--i], "'", NULL);
- return TCL_ERROR;
- }
- qdesc = (pltcl_query_desc *)Tcl_GetHashValue(hashent);
-
- /************************************************************
- * If a nulls string is given, check for correct length
- ************************************************************/
- if (nulls != NULL) {
- if (strlen(nulls) != qdesc->nargs) {
- Tcl_SetResult(interp,
- "length of nulls string doesn't match # of arguments",
- TCL_VOLATILE);
- return TCL_ERROR;
- }
- }
-
- /************************************************************
- * If there was a argtype list on preparation, we need
- * an argument value list now
- ************************************************************/
- if (qdesc->nargs > 0) {
- if (i >= argc) {
- Tcl_SetResult(interp, "missing argument list", TCL_VOLATILE);
- return TCL_ERROR;
- }
-
- /************************************************************
- * Split the argument values
- ************************************************************/
- if (Tcl_SplitList(interp, argv[i++], &callnargs, &callargs) != TCL_OK) {
- return TCL_ERROR;
- }
-
- /************************************************************
- * Check that the # of arguments matches
- ************************************************************/
- if (callnargs != qdesc->nargs) {
- Tcl_SetResult(interp,
- "argument list length doesn't match # of arguments for query",
- TCL_VOLATILE);
- if (callargs != NULL) {
- ckfree(callargs);
- callargs = NULL;
- }
- return TCL_ERROR;
}
/************************************************************
- * Prepare to start a controlled return through all
- * interpreter levels on transaction abort during the
- * parse of the arguments
+ * Get the prepared plan descriptor by it's key
************************************************************/
- memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
- if (sigsetjmp(Warn_restart, 1) != 0) {
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- for (j = 0; j < callnargs; j++) {
- if (qdesc->arglen[j] < 0 &&
- qdesc->argvalues[j] != (Datum)NULL) {
- pfree((char *)(qdesc->argvalues[j]));
- qdesc->argvalues[j] = (Datum)NULL;
- }
- }
- ckfree(callargs);
- callargs = NULL;
- pltcl_restart_in_progress = 1;
- Tcl_SetResult(interp, "Transaction abort", TCL_VOLATILE);
- return TCL_ERROR;
+ hashent = Tcl_FindHashEntry(pltcl_query_hash, argv[i++]);
+ if (hashent == NULL)
+ {
+ Tcl_AppendResult(interp, "invalid queryid '", argv[--i], "'", NULL);
+ return TCL_ERROR;
}
+ qdesc = (pltcl_query_desc *) Tcl_GetHashValue(hashent);
/************************************************************
- * Setup the value array for the SPI_execp() using
- * the type specific input functions
+ * If a nulls string is given, check for correct length
************************************************************/
- for (j = 0; j < callnargs; j++) {
- qdesc->argvalues[j] = (Datum)(*fmgr_faddr(&qdesc->arginfuncs[j]))
- (callargs[j],
- qdesc->argtypelems[j],
- qdesc->arglen[j]);
+ if (nulls != NULL)
+ {
+ if (strlen(nulls) != qdesc->nargs)
+ {
+ Tcl_SetResult(interp,
+ "length of nulls string doesn't match # of arguments",
+ TCL_VOLATILE);
+ return TCL_ERROR;
+ }
}
/************************************************************
- * Free the splitted argument value list
+ * If there was a argtype list on preparation, we need
+ * an argument value list now
************************************************************/
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- ckfree(callargs);
- callargs = NULL;
- } else {
- callnargs = 0;
- }
-
- /************************************************************
- * Remember the index of the last processed call
- * argument - a loop body for SELECT might follow
- ************************************************************/
- loop_body = i;
-
- /************************************************************
- * Prepare to start a controlled return through all
- * interpreter levels on transaction abort
- ************************************************************/
- memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
- if (sigsetjmp(Warn_restart, 1) != 0) {
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- for (j = 0; j < callnargs; j++) {
- if (qdesc->arglen[j] < 0 && qdesc->argvalues[j] != (Datum)NULL) {
- pfree((char *)(qdesc->argvalues[j]));
- qdesc->argvalues[j] = (Datum)NULL;
- }
- }
- pltcl_restart_in_progress = 1;
- Tcl_SetResult(interp, "Transaction abort", TCL_VOLATILE);
- return TCL_ERROR;
- }
-
- /************************************************************
- * Execute the plan
- ************************************************************/
- spi_rc = SPI_execp(qdesc->plan, qdesc->argvalues, nulls, count);
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
-
- /************************************************************
- * For varlena data types, free the argument values
- ************************************************************/
- for (j = 0; j < callnargs; j++) {
- if (qdesc->arglen[j] < 0 && qdesc->argvalues[j] != (Datum)NULL) {
- pfree((char *)(qdesc->argvalues[j]));
- qdesc->argvalues[j] = (Datum)NULL;
- }
- }
-
- /************************************************************
- * Check the return code from SPI_execp()
- ************************************************************/
- switch (spi_rc) {
- case SPI_OK_UTILITY:
- Tcl_SetResult(interp, "0", TCL_VOLATILE);
- return TCL_OK;
-
- case SPI_OK_SELINTO:
- case SPI_OK_INSERT:
- case SPI_OK_DELETE:
- case SPI_OK_UPDATE:
- sprintf(buf, "%d", SPI_processed);
- Tcl_SetResult(interp, buf, TCL_VOLATILE);
- return TCL_OK;
-
- case SPI_OK_SELECT:
- break;
-
- case SPI_ERROR_ARGUMENT:
- Tcl_SetResult(interp,
- "pltcl: SPI_exec() failed - SPI_ERROR_ARGUMENT",
- TCL_VOLATILE);
- return TCL_ERROR;
-
- case SPI_ERROR_UNCONNECTED:
- Tcl_SetResult(interp,
- "pltcl: SPI_exec() failed - SPI_ERROR_UNCONNECTED",
- TCL_VOLATILE);
- return TCL_ERROR;
-
- case SPI_ERROR_COPY:
- Tcl_SetResult(interp,
- "pltcl: SPI_exec() failed - SPI_ERROR_COPY",
- TCL_VOLATILE);
- return TCL_ERROR;
-
- case SPI_ERROR_CURSOR:
- Tcl_SetResult(interp,
- "pltcl: SPI_exec() failed - SPI_ERROR_CURSOR",
- TCL_VOLATILE);
- return TCL_ERROR;
-
- case SPI_ERROR_TRANSACTION:
- Tcl_SetResult(interp,
- "pltcl: SPI_exec() failed - SPI_ERROR_TRANSACTION",
- TCL_VOLATILE);
- return TCL_ERROR;
-
- case SPI_ERROR_OPUNKNOWN:
- Tcl_SetResult(interp,
- "pltcl: SPI_exec() failed - SPI_ERROR_OPUNKNOWN",
- TCL_VOLATILE);
- return TCL_ERROR;
-
- default:
- sprintf(buf, "%d", spi_rc);
- Tcl_AppendResult(interp, "pltcl: SPI_exec() failed - ",
- "unknown RC ", buf, NULL);
- return TCL_ERROR;
- }
-
- /************************************************************
- * Only SELECT queries fall through to here - remember the
- * tuples we got
- ************************************************************/
-
- ntuples = SPI_processed;
- if (ntuples > 0) {
- tuples = SPI_tuptable->vals;
- tupdesc = SPI_tuptable->tupdesc;
- }
-
- /************************************************************
- * Prepare to start a controlled return through all
- * interpreter levels on transaction abort during
- * the ouput conversions of the results
- ************************************************************/
- memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
- if (sigsetjmp(Warn_restart, 1) != 0) {
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- pltcl_restart_in_progress = 1;
- Tcl_SetResult(interp, "Transaction abort", TCL_VOLATILE);
- return TCL_ERROR;
- }
-
- /************************************************************
- * If there is no loop body given, just set the variables
- * from the first tuple (if any) and return the number of
- * tuples selected
- ************************************************************/
- if (loop_body >= argc) {
- if (ntuples > 0) {
- pltcl_set_tuple_values(interp, arrayname, 0, tuples[0], tupdesc);
- }
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- sprintf(buf, "%d", ntuples);
- Tcl_SetResult(interp, buf, TCL_VOLATILE);
- return TCL_OK;
- }
-
- /************************************************************
- * There is a loop body - process all tuples and evaluate
- * the body on each
- ************************************************************/
- for (i = 0; i < ntuples; i++) {
- pltcl_set_tuple_values(interp, arrayname, i, tuples[i], tupdesc);
-
- loop_rc = Tcl_Eval(interp, argv[loop_body]);
-
- if (loop_rc == TCL_OK) continue;
- if (loop_rc == TCL_CONTINUE) continue;
- if (loop_rc == TCL_RETURN) {
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- return TCL_RETURN;
- }
- if (loop_rc == TCL_BREAK) break;
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- return TCL_ERROR;
- }
-
- /************************************************************
- * Finally return the number of tuples
- ************************************************************/
- memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
- sprintf(buf, "%d", ntuples);
- Tcl_SetResult(interp, buf, TCL_VOLATILE);
- return TCL_OK;
-}
+ if (qdesc->nargs > 0)
+ {
+ if (i >= argc)
+ {
+ Tcl_SetResult(interp, "missing argument list", TCL_VOLATILE);
+ return TCL_ERROR;
+ }
+ /************************************************************
+ * Split the argument values
+ ************************************************************/
+ if (Tcl_SplitList(interp, argv[i++], &callnargs, &callargs) != TCL_OK)
+ {
+ return TCL_ERROR;
+ }
-/**********************************************************************
- * pltcl_set_tuple_values() - Set variables for all attributes
- * of a given tuple
- **********************************************************************/
-static void pltcl_set_tuple_values(Tcl_Interp *interp, char *arrayname,
- int tupno, HeapTuple tuple, TupleDesc tupdesc)
-{
- int i;
- char *outputstr;
- char buf[64];
- Datum attr;
- bool isnull;
+ /************************************************************
+ * Check that the # of arguments matches
+ ************************************************************/
+ if (callnargs != qdesc->nargs)
+ {
+ Tcl_SetResult(interp,
+ "argument list length doesn't match # of arguments for query",
+ TCL_VOLATILE);
+ if (callargs != NULL)
+ {
+ ckfree(callargs);
+ callargs = NULL;
+ }
+ return TCL_ERROR;
+ }
- char *attname;
- HeapTuple typeTup;
- Oid typoutput;
- Oid typelem;
+ /************************************************************
+ * Prepare to start a controlled return through all
+ * interpreter levels on transaction abort during the
+ * parse of the arguments
+ ************************************************************/
+ memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
+ if (sigsetjmp(Warn_restart, 1) != 0)
+ {
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ for (j = 0; j < callnargs; j++)
+ {
+ if (qdesc->arglen[j] < 0 &&
+ qdesc->argvalues[j] != (Datum) NULL)
+ {
+ pfree((char *) (qdesc->argvalues[j]));
+ qdesc->argvalues[j] = (Datum) NULL;
+ }
+ }
+ ckfree(callargs);
+ callargs = NULL;
+ pltcl_restart_in_progress = 1;
+ Tcl_SetResult(interp, "Transaction abort", TCL_VOLATILE);
+ return TCL_ERROR;
+ }
- char **arrptr;
- char **nameptr;
- char *nullname = NULL;
+ /************************************************************
+ * Setup the value array for the SPI_execp() using
+ * the type specific input functions
+ ************************************************************/
+ for (j = 0; j < callnargs; j++)
+ {
+ qdesc->argvalues[j] = (Datum) (*fmgr_faddr(&qdesc->arginfuncs[j]))
+ (callargs[j],
+ qdesc->argtypelems[j],
+ qdesc->arglen[j]);
+ }
- /************************************************************
- * Prepare pointers for Tcl_SetVar2() below and in array
- * mode set the .tupno element
- ************************************************************/
- if (arrayname == NULL) {
- arrptr = &attname;
- nameptr = &nullname;
- } else {
- arrptr = &arrayname;
- nameptr = &attname;
- sprintf(buf, "%d", tupno);
- Tcl_SetVar2(interp, arrayname, ".tupno", buf, 0);
- }
+ /************************************************************
+ * Free the splitted argument value list
+ ************************************************************/
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ ckfree(callargs);
+ callargs = NULL;
+ }
+ else
+ {
+ callnargs = 0;
+ }
- for (i = 0; i < tupdesc->natts; i++) {
/************************************************************
- * Get the attribute name
+ * Remember the index of the last processed call
+ * argument - a loop body for SELECT might follow
************************************************************/
- attname = tupdesc->attrs[i]->attname.data;
+ loop_body = i;
/************************************************************
- * Get the attributes value
+ * Prepare to start a controlled return through all
+ * interpreter levels on transaction abort
************************************************************/
- attr = heap_getattr(tuple, i + 1, tupdesc, &isnull);
-
+ memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
+ if (sigsetjmp(Warn_restart, 1) != 0)
+ {
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ for (j = 0; j < callnargs; j++)
+ {
+ if (qdesc->arglen[j] < 0 && qdesc->argvalues[j] != (Datum) NULL)
+ {
+ pfree((char *) (qdesc->argvalues[j]));
+ qdesc->argvalues[j] = (Datum) NULL;
+ }
+ }
+ pltcl_restart_in_progress = 1;
+ Tcl_SetResult(interp, "Transaction abort", TCL_VOLATILE);
+ return TCL_ERROR;
+ }
+
+ /************************************************************
+ * Execute the plan
+ ************************************************************/
+ spi_rc = SPI_execp(qdesc->plan, qdesc->argvalues, nulls, count);
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+
/************************************************************
- * Lookup the attribute type in the syscache
- * for the output function
+ * For varlena data types, free the argument values
************************************************************/
- typeTup = SearchSysCacheTuple(TYPOID,
- ObjectIdGetDatum(tupdesc->attrs[i]->atttypid),
- 0, 0, 0);
- if (!HeapTupleIsValid(typeTup)) {
- elog(ERROR, "pltcl: Cache lookup for attribute '%s' type %ld failed",
- attname, ObjectIdGetDatum(tupdesc->attrs[i]->atttypid));
+ for (j = 0; j < callnargs; j++)
+ {
+ if (qdesc->arglen[j] < 0 && qdesc->argvalues[j] != (Datum) NULL)
+ {
+ pfree((char *) (qdesc->argvalues[j]));
+ qdesc->argvalues[j] = (Datum) NULL;
+ }
}
- typoutput = (Oid) (((TypeTupleForm)GETSTRUCT(typeTup))->typoutput);
- typelem = (Oid) (((TypeTupleForm)GETSTRUCT(typeTup))->typelem);
+ /************************************************************
+ * Check the return code from SPI_execp()
+ ************************************************************/
+ switch (spi_rc)
+ {
+ case SPI_OK_UTILITY:
+ Tcl_SetResult(interp, "0", TCL_VOLATILE);
+ return TCL_OK;
+
+ case SPI_OK_SELINTO:
+ case SPI_OK_INSERT:
+ case SPI_OK_DELETE:
+ case SPI_OK_UPDATE:
+ sprintf(buf, "%d", SPI_processed);
+ Tcl_SetResult(interp, buf, TCL_VOLATILE);
+ return TCL_OK;
+
+ case SPI_OK_SELECT:
+ break;
+
+ case SPI_ERROR_ARGUMENT:
+ Tcl_SetResult(interp,
+ "pltcl: SPI_exec() failed - SPI_ERROR_ARGUMENT",
+ TCL_VOLATILE);
+ return TCL_ERROR;
+
+ case SPI_ERROR_UNCONNECTED:
+ Tcl_SetResult(interp,
+ "pltcl: SPI_exec() failed - SPI_ERROR_UNCONNECTED",
+ TCL_VOLATILE);
+ return TCL_ERROR;
+
+ case SPI_ERROR_COPY:
+ Tcl_SetResult(interp,
+ "pltcl: SPI_exec() failed - SPI_ERROR_COPY",
+ TCL_VOLATILE);
+ return TCL_ERROR;
+
+ case SPI_ERROR_CURSOR:
+ Tcl_SetResult(interp,
+ "pltcl: SPI_exec() failed - SPI_ERROR_CURSOR",
+ TCL_VOLATILE);
+ return TCL_ERROR;
+
+ case SPI_ERROR_TRANSACTION:
+ Tcl_SetResult(interp,
+ "pltcl: SPI_exec() failed - SPI_ERROR_TRANSACTION",
+ TCL_VOLATILE);
+ return TCL_ERROR;
+
+ case SPI_ERROR_OPUNKNOWN:
+ Tcl_SetResult(interp,
+ "pltcl: SPI_exec() failed - SPI_ERROR_OPUNKNOWN",
+ TCL_VOLATILE);
+ return TCL_ERROR;
+
+ default:
+ sprintf(buf, "%d", spi_rc);
+ Tcl_AppendResult(interp, "pltcl: SPI_exec() failed - ",
+ "unknown RC ", buf, NULL);
+ return TCL_ERROR;
+ }
/************************************************************
- * If there is a value, set the variable
- * If not, unset it
- *
- * Hmmm - Null attributes will cause functions to
- * crash if they don't expect them - need something
- * smarter here.
+ * Only SELECT queries fall through to here - remember the
+ * tuples we got
************************************************************/
- if (!isnull && OidIsValid(typoutput)) {
- FmgrInfo finfo;
- fmgr_info(typoutput, &finfo);
+ ntuples = SPI_processed;
+ if (ntuples > 0)
+ {
+ tuples = SPI_tuptable->vals;
+ tupdesc = SPI_tuptable->tupdesc;
+ }
+
+ /************************************************************
+ * Prepare to start a controlled return through all
+ * interpreter levels on transaction abort during
+ * the ouput conversions of the results
+ ************************************************************/
+ memcpy(&save_restart, &Warn_restart, sizeof(save_restart));
+ if (sigsetjmp(Warn_restart, 1) != 0)
+ {
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ pltcl_restart_in_progress = 1;
+ Tcl_SetResult(interp, "Transaction abort", TCL_VOLATILE);
+ return TCL_ERROR;
+ }
- outputstr = (*fmgr_faddr(&finfo))
- (attr, typelem,
- tupdesc->attrs[i]->attlen);
+ /************************************************************
+ * If there is no loop body given, just set the variables
+ * from the first tuple (if any) and return the number of
+ * tuples selected
+ ************************************************************/
+ if (loop_body >= argc)
+ {
+ if (ntuples > 0)
+ {
+ pltcl_set_tuple_values(interp, arrayname, 0, tuples[0], tupdesc);
+ }
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ sprintf(buf, "%d", ntuples);
+ Tcl_SetResult(interp, buf, TCL_VOLATILE);
+ return TCL_OK;
+ }
- Tcl_SetVar2(interp, *arrptr, *nameptr, outputstr, 0);
- pfree(outputstr);
- } else {
- Tcl_UnsetVar2(interp, *arrptr, *nameptr, 0);
+ /************************************************************
+ * There is a loop body - process all tuples and evaluate
+ * the body on each
+ ************************************************************/
+ for (i = 0; i < ntuples; i++)
+ {
+ pltcl_set_tuple_values(interp, arrayname, i, tuples[i], tupdesc);
+
+ loop_rc = Tcl_Eval(interp, argv[loop_body]);
+
+ if (loop_rc == TCL_OK)
+ continue;
+ if (loop_rc == TCL_CONTINUE)
+ continue;
+ if (loop_rc == TCL_RETURN)
+ {
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ return TCL_RETURN;
+ }
+ if (loop_rc == TCL_BREAK)
+ break;
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ return TCL_ERROR;
}
- }
+
+ /************************************************************
+ * Finally return the number of tuples
+ ************************************************************/
+ memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
+ sprintf(buf, "%d", ntuples);
+ Tcl_SetResult(interp, buf, TCL_VOLATILE);
+ return TCL_OK;
}
/**********************************************************************
- * pltcl_build_tuple_argument() - Build a string usable for 'array set'
- * from all attributes of a given tuple
+ * pltcl_set_tuple_values() - Set variables for all attributes
+ * of a given tuple
**********************************************************************/
-static void pltcl_build_tuple_argument(HeapTuple tuple, TupleDesc tupdesc,
- Tcl_DString *retval)
+static void
+pltcl_set_tuple_values(Tcl_Interp * interp, char *arrayname,
+ int tupno, HeapTuple tuple, TupleDesc tupdesc)
{
- int i;
- char *outputstr;
- Datum attr;
- bool isnull;
+ int i;
+ char *outputstr;
+ char buf[64];
+ Datum attr;
+ bool isnull;
- char *attname;
- HeapTuple typeTup;
- Oid typoutput;
- Oid typelem;
+ char *attname;
+ HeapTuple typeTup;
+ Oid typoutput;
+ Oid typelem;
- for (i = 0; i < tupdesc->natts; i++) {
- /************************************************************
- * Get the attribute name
- ************************************************************/
- attname = tupdesc->attrs[i]->attname.data;
+ char **arrptr;
+ char **nameptr;
+ char *nullname = NULL;
/************************************************************
- * Get the attributes value
- ************************************************************/
- attr = heap_getattr(tuple, i + 1, tupdesc, &isnull);
-
- /************************************************************
- * Lookup the attribute type in the syscache
- * for the output function
+ * Prepare pointers for Tcl_SetVar2() below and in array
+ * mode set the .tupno element
************************************************************/
- typeTup = SearchSysCacheTuple(TYPOID,
- ObjectIdGetDatum(tupdesc->attrs[i]->atttypid),
- 0, 0, 0);
- if (!HeapTupleIsValid(typeTup)) {
- elog(ERROR, "pltcl: Cache lookup for attribute '%s' type %ld failed",
- attname, ObjectIdGetDatum(tupdesc->attrs[i]->atttypid));
+ if (arrayname == NULL)
+ {
+ arrptr = &attname;
+ nameptr = &nullname;
+ }
+ else
+ {
+ arrptr = &arrayname;
+ nameptr = &attname;
+ sprintf(buf, "%d", tupno);
+ Tcl_SetVar2(interp, arrayname, ".tupno", buf, 0);
}
- typoutput = (Oid) (((TypeTupleForm)GETSTRUCT(typeTup))->typoutput);
- typelem = (Oid) (((TypeTupleForm)GETSTRUCT(typeTup))->typelem);
+ for (i = 0; i < tupdesc->natts; i++)
+ {
+ /************************************************************
+ * Get the attribute name
+ ************************************************************/
+ attname = tupdesc->attrs[i]->attname.data;
+
+ /************************************************************
+ * Get the attributes value
+ ************************************************************/
+ attr = heap_getattr(tuple, i + 1, tupdesc, &isnull);
+
+ /************************************************************
+ * Lookup the attribute type in the syscache
+ * for the output function
+ ************************************************************/
+ typeTup = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(tupdesc->attrs[i]->atttypid),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(typeTup))
+ {
+ elog(ERROR, "pltcl: Cache lookup for attribute '%s' type %ld failed",
+ attname, ObjectIdGetDatum(tupdesc->attrs[i]->atttypid));
+ }
- /************************************************************
- * If there is a value, append the attribute name and the
- * value to the list
- *
- * Hmmm - Null attributes will cause functions to
- * crash if they don't expect them - need something
- * smarter here.
- ************************************************************/
- if (!isnull && OidIsValid(typoutput)) {
- FmgrInfo finfo;
+ typoutput = (Oid) (((TypeTupleForm) GETSTRUCT(typeTup))->typoutput);
+ typelem = (Oid) (((TypeTupleForm) GETSTRUCT(typeTup))->typelem);
+
+ /************************************************************
+ * If there is a value, set the variable
+ * If not, unset it
+ *
+ * Hmmm - Null attributes will cause functions to
+ * crash if they don't expect them - need something
+ * smarter here.
+ ************************************************************/
+ if (!isnull && OidIsValid(typoutput))
+ {
+ FmgrInfo finfo;
+
+ fmgr_info(typoutput, &finfo);
+
+ outputstr = (*fmgr_faddr(&finfo))
+ (attr, typelem,
+ tupdesc->attrs[i]->attlen);
+
+ Tcl_SetVar2(interp, *arrptr, *nameptr, outputstr, 0);
+ pfree(outputstr);
+ }
+ else
+ {
+ Tcl_UnsetVar2(interp, *arrptr, *nameptr, 0);
+ }
+ }
+}
- fmgr_info(typoutput, &finfo);
- outputstr = (*fmgr_faddr(&finfo))
- (attr, typelem,
- tupdesc->attrs[i]->attlen);
+/**********************************************************************
+ * pltcl_build_tuple_argument() - Build a string usable for 'array set'
+ * from all attributes of a given tuple
+ **********************************************************************/
+static void
+pltcl_build_tuple_argument(HeapTuple tuple, TupleDesc tupdesc,
+ Tcl_DString * retval)
+{
+ int i;
+ char *outputstr;
+ Datum attr;
+ bool isnull;
+
+ char *attname;
+ HeapTuple typeTup;
+ Oid typoutput;
+ Oid typelem;
+
+ for (i = 0; i < tupdesc->natts; i++)
+ {
+ /************************************************************
+ * Get the attribute name
+ ************************************************************/
+ attname = tupdesc->attrs[i]->attname.data;
+
+ /************************************************************
+ * Get the attributes value
+ ************************************************************/
+ attr = heap_getattr(tuple, i + 1, tupdesc, &isnull);
+
+ /************************************************************
+ * Lookup the attribute type in the syscache
+ * for the output function
+ ************************************************************/
+ typeTup = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(tupdesc->attrs[i]->atttypid),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(typeTup))
+ {
+ elog(ERROR, "pltcl: Cache lookup for attribute '%s' type %ld failed",
+ attname, ObjectIdGetDatum(tupdesc->attrs[i]->atttypid));
+ }
- Tcl_DStringAppendElement(retval, attname);
- Tcl_DStringAppendElement(retval, outputstr);
- pfree(outputstr);
+ typoutput = (Oid) (((TypeTupleForm) GETSTRUCT(typeTup))->typoutput);
+ typelem = (Oid) (((TypeTupleForm) GETSTRUCT(typeTup))->typelem);
+
+ /************************************************************
+ * If there is a value, append the attribute name and the
+ * value to the list
+ *
+ * Hmmm - Null attributes will cause functions to
+ * crash if they don't expect them - need something
+ * smarter here.
+ ************************************************************/
+ if (!isnull && OidIsValid(typoutput))
+ {
+ FmgrInfo finfo;
+
+ fmgr_info(typoutput, &finfo);
+
+ outputstr = (*fmgr_faddr(&finfo))
+ (attr, typelem,
+ tupdesc->attrs[i]->attlen);
+
+ Tcl_DStringAppendElement(retval, attname);
+ Tcl_DStringAppendElement(retval, outputstr);
+ pfree(outputstr);
+ }
}
- }
}
-
-
*pgoptions,
*pgtty;
char *dbName;
- /* int nFields;
- * int i,
- * j;
+
+ /*
+ * int nFields; int i, j;
*/
PGconn *conn;
/* close the connection to the database and cleanup */
PQfinish(conn);
- return 0; /* Though PQfinish(conn1) has called exit(1) */
+ return 0; /* Though PQfinish(conn1) has called
+ * exit(1) */
}
*/
#include
#include
-#include "postgres.h" /* -> "c.h" -> int16, in access/attnum.h */
+#include "postgres.h" /* -> "c.h" -> int16, in access/attnum.h */
#include "libpq-fe.h"
#include "utils/geo_decls.h" /* for the POLYGON type */
*pgoptions,
*pgtty;
char *dbName;
- /* int nFields;
- * int i,
- * j;
+
+ /*
+ * int nFields; int i, j;
*/
int i;
int i_fnum,
/* close the connection to the database and cleanup */
PQfinish(conn);
- return 0; /* Though PQfinish(conn1) has called exit(1) */
+ return 0; /* Though PQfinish(conn1) has called
+ * exit(1) */
}
}
static void
-check_conn(PGconn *conn, const char* dbName)
+check_conn(PGconn *conn, const char *dbName)
{
/* check to see that the backend connection was successfully made */
if (PQstatus(conn) == CONNECTION_BAD)
}
int
-main(int argc, char** argv)
+main(int argc, char **argv)
{
char *pghost,
*pgport,
*pgoptions,
*pgtty;
char *dbName1,
- *dbName2;
+ *dbName2;
char *tblName;
int nFields;
int i,
j;
PGconn *conn1,
- *conn2;
- /* PGresult *res1,
- * *res2;
+ *conn2;
+
+ /*
+ * PGresult *res1, *res2;
*/
PGresult *res1;
{
fprintf(stderr, "DECLARE CURSOR command failed\n");
PQclear(res1);
- exit_nicely(conn1,(PGconn*)NULL);
+ exit_nicely(conn1, (PGconn *) NULL);
}
PQclear(res1);
{
fprintf(stderr, "FETCH ALL command didn't return tuples properly\n");
PQclear(res1);
- exit_nicely(conn1,(PGconn*)NULL);
+ exit_nicely(conn1, (PGconn *) NULL);
}
/* first, print out the attribute names */
PQfinish(conn1);
/* fclose(debug); */
- return 0; /* Though PQfinish(conn1) has called exit(1) */
+ return 0; /* Though PQfinish(conn1) has called
+ * exit(1) */
}
/*
- * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.22 1998/02/11 19:14:04 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.23 1998/02/26 04:46:30 momjian Exp $
*/
#include /* faked on sunos */
/*
** Distance from a point to a path
*/
-double *
+double *
regress_dist_ptpath(pt, path)
Point *pt;
PATH *path;
/* this essentially does a cartesian product of the lsegs in the
two paths, and finds the min distance between any two lsegs */
-double *
+double *
regress_path_dist(p1, p2)
PATH *p1;
PATH *p2;
return (min);
}
-PATH *
+PATH *
poly2path(poly)
POLYGON *poly;
{
}
/* return the point where two paths intersect. Assumes that they do. */
-Point *
+Point *
interpt_pp(p1, p2)
PATH *p1;
PATH *p2;
#define NARGS 3
-WIDGET *
+WIDGET *
widget_in(str)
char *str;
{
return (result);
}
-char *
+char *
widget_out(widget)
WIDGET *widget;
{
return (width * height);
}
-char *
+char *
reverse_c16(string)
char *string;
{
return (tuple);
}
-HeapTuple ttdummy(void);
-int32 set_ttdummy(int32 on);
+HeapTuple ttdummy(void);
+int32 set_ttdummy(int32 on);
-extern int4 nextval(struct varlena * seqin);
+extern int4 nextval(struct varlena * seqin);
#define TTDUMMY_INFINITY 999999
-static void *splan = NULL;
-static bool ttoff = false;
+static void *splan = NULL;
+static bool ttoff = false;
HeapTuple
ttdummy()
Trigger *trigger; /* to get trigger name */
char **args; /* arguments */
int attnum[2]; /* fnumbers of start/stop columns */
- Datum oldon, oldoff;
- Datum newon, newoff;
+ Datum oldon,
+ oldoff;
+ Datum newon,
+ newoff;
Datum *cvals; /* column values */
char *cnulls; /* column nulls */
char *relname; /* triggered relation name */
if (TRIGGER_FIRED_AFTER(CurrentTriggerData->tg_event))
elog(ERROR, "ttdummy: must be fired before event");
if (TRIGGER_FIRED_BY_INSERT(CurrentTriggerData->tg_event))
- elog (ERROR, "ttdummy: can't process INSERT event");
+ elog(ERROR, "ttdummy: can't process INSERT event");
if (TRIGGER_FIRED_BY_UPDATE(CurrentTriggerData->tg_event))
newtuple = CurrentTriggerData->tg_newtuple;
-
+
trigtuple = CurrentTriggerData->tg_trigtuple;
-
+
rel = CurrentTriggerData->tg_relation;
relname = SPI_getrelname(rel);
-
+
/* check if TT is OFF for this relation */
- if (ttoff) /* OFF - nothing to do */
+ if (ttoff) /* OFF - nothing to do */
{
- pfree (relname);
+ pfree(relname);
return ((newtuple != NULL) ? newtuple : trigtuple);
}
-
+
trigger = CurrentTriggerData->tg_trigger;
if (trigger->tgnargs != 2)
- elog(ERROR, "ttdummy (%s): invalid (!= 2) number of arguments %d",
- relname, trigger->tgnargs);
-
+ elog(ERROR, "ttdummy (%s): invalid (!= 2) number of arguments %d",
+ relname, trigger->tgnargs);
+
args = trigger->tgargs;
tupdesc = rel->rd_att;
natts = tupdesc->natts;
-
+
CurrentTriggerData = NULL;
-
- for (i = 0; i < 2; i++ )
+
+ for (i = 0; i < 2; i++)
{
- attnum[i] = SPI_fnumber (tupdesc, args[i]);
- if ( attnum[i] < 0 )
+ attnum[i] = SPI_fnumber(tupdesc, args[i]);
+ if (attnum[i] < 0)
elog(ERROR, "ttdummy (%s): there is no attribute %s", relname, args[i]);
- if (SPI_gettypeid (tupdesc, attnum[i]) != INT4OID)
- elog(ERROR, "ttdummy (%s): attributes %s and %s must be of abstime type",
- relname, args[0], args[1]);
+ if (SPI_gettypeid(tupdesc, attnum[i]) != INT4OID)
+ elog(ERROR, "ttdummy (%s): attributes %s and %s must be of abstime type",
+ relname, args[0], args[1]);
}
-
- oldon = SPI_getbinval (trigtuple, tupdesc, attnum[0], &isnull);
+
+ oldon = SPI_getbinval(trigtuple, tupdesc, attnum[0], &isnull);
if (isnull)
elog(ERROR, "ttdummy (%s): %s must be NOT NULL", relname, args[0]);
-
- oldoff = SPI_getbinval (trigtuple, tupdesc, attnum[1], &isnull);
+
+ oldoff = SPI_getbinval(trigtuple, tupdesc, attnum[1], &isnull);
if (isnull)
elog(ERROR, "ttdummy (%s): %s must be NOT NULL", relname, args[1]);
-
- if (newtuple != NULL) /* UPDATE */
+
+ if (newtuple != NULL) /* UPDATE */
{
- newon = SPI_getbinval (newtuple, tupdesc, attnum[0], &isnull);
+ newon = SPI_getbinval(newtuple, tupdesc, attnum[0], &isnull);
if (isnull)
elog(ERROR, "ttdummy (%s): %s must be NOT NULL", relname, args[0]);
- newoff = SPI_getbinval (newtuple, tupdesc, attnum[1], &isnull);
+ newoff = SPI_getbinval(newtuple, tupdesc, attnum[1], &isnull);
if (isnull)
elog(ERROR, "ttdummy (%s): %s must be NOT NULL", relname, args[1]);
-
- if ( oldon != newon || oldoff != newoff )
- elog (ERROR, "ttdummy (%s): you can't change %s and/or %s columns (use set_ttdummy)",
- relname, args[0], args[1]);
-
- if ( newoff != TTDUMMY_INFINITY )
+
+ if (oldon != newon || oldoff != newoff)
+ elog(ERROR, "ttdummy (%s): you can't change %s and/or %s columns (use set_ttdummy)",
+ relname, args[0], args[1]);
+
+ if (newoff != TTDUMMY_INFINITY)
{
- pfree (relname); /* allocated in upper executor context */
+ pfree(relname); /* allocated in upper executor context */
return (NULL);
}
}
else if (oldoff != TTDUMMY_INFINITY) /* DELETE */
{
- pfree (relname);
+ pfree(relname);
return (NULL);
}
-
+
{
- struct varlena *seqname = textin ("ttdummy_seq");
-
- newoff = nextval (seqname);
- pfree (seqname);
+ struct varlena *seqname = textin("ttdummy_seq");
+
+ newoff = nextval(seqname);
+ pfree(seqname);
}
-
+
/* Connect to SPI manager */
if ((ret = SPI_connect()) < 0)
elog(ERROR, "ttdummy (%s): SPI_connect returned %d", relname, ret);
-
+
/* Fetch tuple values and nulls */
- cvals = (Datum *) palloc (natts * sizeof (Datum));
- cnulls = (char *) palloc (natts * sizeof (char));
+ cvals = (Datum *) palloc(natts * sizeof(Datum));
+ cnulls = (char *) palloc(natts * sizeof(char));
for (i = 0; i < natts; i++)
{
- cvals[i] = SPI_getbinval ((newtuple != NULL) ? newtuple : trigtuple,
- tupdesc, i + 1, &isnull);
+ cvals[i] = SPI_getbinval((newtuple != NULL) ? newtuple : trigtuple,
+ tupdesc, i + 1, &isnull);
cnulls[i] = (isnull) ? 'n' : ' ';
}
-
+
/* change date column(s) */
- if (newtuple) /* UPDATE */
+ if (newtuple) /* UPDATE */
{
- cvals[attnum[0] - 1] = newoff; /* start_date eq current date */
+ cvals[attnum[0] - 1] = newoff; /* start_date eq current date */
cnulls[attnum[0] - 1] = ' ';
- cvals[attnum[1] - 1] = TTDUMMY_INFINITY; /* stop_date eq INFINITY */
+ cvals[attnum[1] - 1] = TTDUMMY_INFINITY; /* stop_date eq INFINITY */
cnulls[attnum[1] - 1] = ' ';
}
- else /* DELETE */
+ else
+/* DELETE */
{
- cvals[attnum[1] - 1] = newoff; /* stop_date eq current date */
+ cvals[attnum[1] - 1] = newoff; /* stop_date eq current date */
cnulls[attnum[1] - 1] = ' ';
}
-
+
/* if there is no plan ... */
if (splan == NULL)
{
void *pplan;
Oid *ctypes;
char sql[8192];
-
+
/* allocate ctypes for preparation */
ctypes = (Oid *) palloc(natts * sizeof(Oid));
-
+
/*
- * Construct query:
- * INSERT INTO _relation_ VALUES ($1, ...)
+ * Construct query: INSERT INTO _relation_ VALUES ($1, ...)
*/
sprintf(sql, "INSERT INTO %s VALUES (", relname);
for (i = 1; i <= natts; i++)
{
sprintf(sql + strlen(sql), "$%d%s",
- i, (i < natts) ? ", " : ")");
+ i, (i < natts) ? ", " : ")");
ctypes[i - 1] = SPI_gettypeid(tupdesc, i);
}
-
+
/* Prepare plan for query */
pplan = SPI_prepare(sql, natts, ctypes);
if (pplan == NULL)
elog(ERROR, "ttdummy (%s): SPI_prepare returned %d", relname, SPI_result);
-
+
pplan = SPI_saveplan(pplan);
if (pplan == NULL)
elog(ERROR, "ttdummy (%s): SPI_saveplan returned %d", relname, SPI_result);
-
+
splan = pplan;
}
-
+
ret = SPI_execp(splan, cvals, cnulls, 0);
-
+
if (ret < 0)
elog(ERROR, "ttdummy (%s): SPI_execp returned %d", relname, ret);
-
+
/* Tuple to return to upper Executor ... */
- if (newtuple) /* UPDATE */
+ if (newtuple) /* UPDATE */
{
HeapTuple tmptuple;
-
- tmptuple = SPI_copytuple (trigtuple);
- rettuple = SPI_modifytuple (rel, tmptuple, 1, &(attnum[1]), &newoff, NULL);
- SPI_pfree (tmptuple);
+
+ tmptuple = SPI_copytuple(trigtuple);
+ rettuple = SPI_modifytuple(rel, tmptuple, 1, &(attnum[1]), &newoff, NULL);
+ SPI_pfree(tmptuple);
}
- else /* DELETE */
+ else
+/* DELETE */
rettuple = trigtuple;
-
- SPI_finish(); /* don't forget say Bye to SPI mgr */
-
- pfree (relname);
+
+ SPI_finish(); /* don't forget say Bye to SPI mgr */
+
+ pfree(relname);
return (rettuple);
}
int32
set_ttdummy(int32 on)
{
-
- if (ttoff) /* OFF currently */
+
+ if (ttoff) /* OFF currently */
{
if (on == 0)
return (0);
-
+
/* turn ON */
ttoff = false;
return (0);
}
-
+
/* ON currently */
if (on != 0)
return (1);
-
+
/* turn OFF */
ttoff = true;
-
+
return (1);
}
* pointer. POSTGRES thinks all output functions are:
* char *out_func(char *);
*/
-char *
+char *
complex_out(Complex * complex)
{
char *result;
return (arg + 1);
}
-char16 *
+char16 *
concat16(char16 *arg1, char16 *arg2)
{
char16 *new_c16 = (char16 *) palloc(sizeof(char16));
return (char16 *) (strncat((char *) new_c16, (char *) arg2, 16));
}
-text *
+text *
copytext(text *t)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/utils/Attic/strdup.c,v 1.4 1997/09/08 02:41:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/utils/Attic/strdup.c,v 1.5 1998/02/26 04:46:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include
#include "strdup.h"
-char *
+char *
strdup(char const * string)
{
char *nstr;
projects / postgresql.git / commitdiff