+ token = lsptok(NULL, &tokenLength);
+ s[i] = (char) atoi(token);
+ }
+ } else if (length <= 0) {
+ s = NULL;
+ } else if (length >= 1) {
+ s = (char*)palloc(length);
+ Assert( s!=NULL );
+ for (i=0; i
+ token = lsptok(NULL, &tokenLength);
+ s[i] = (char) atoi(token);
+ }
+ res = PointerGetDatum(s);
+ }
+
+ token = lsptok(NULL, &tokenLength); /* skip the ']' */
+ if (token[0] != ']') {
+ elog(WARN, "readValue: ']' expected, length =%d", length);
+ }
+
+ return(res);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * readfuncs.h--
+ * header file for read.c and readfuncs.c. These functions are internal
+ * to the stringToNode interface and should not be used by anyone else.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: readfuncs.h,v 1.1.1.1 1996/07/09 06:21:33 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef READFUNCS_H
+#define READFUNCS_H
+
+/*
+ * prototypes for functions in read.c (the lisp token parser)
+ */
+extern char *lsptok(char *string, int *length);
+extern void *nodeRead(bool read_car_only);
+
+/*
+ * prototypes for functions in readfuncs.c
+ */
+extern Node *parsePlanString();
+
+#endif /* READFUNCS_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * relation.h--
+ * Definitions for internal planner nodes.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: relation.h,v 1.1.1.1 1996/07/09 06:21:33 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef RELATION_H
+#define RELATION_H
+
+#include "c.h"
+#include "nodes/pg_list.h"
+#include "nodes/primnodes.h"
+#include "nodes/parsenodes.h"
+#include "nodes/nodes.h"
+
+/*
+ * Relid
+ * List of relation identifiers (indexes into the rangetable).
+ */
+
+typedef List *Relid;
+
+/*
+ * Rel
+ * Per-base-relation information
+ *
+ * Parts of this data structure are specific to various scan and join
+ * mechanisms. It didn't seem worth creating new node types for them.
+ *
+ * relids - List of relation indentifiers
+ * indexed - true if the relation has secondary indices
+ * pages - number of pages in the relation
+ * tuples - number of tuples in the relation
+ * size - number of tuples in the relation after restrictions clauses
+ * have been applied
+ * width - number of bytes per tuple in the relation after the
+ * appropriate projections have been done
+ * targetlist - List of TargetList nodes
+ * pathlist - List of Path nodes, one for each possible method of
+ * generating the relation
+ * unorderedpath - a Path node generating this relation whose resulting
+ * tuples are unordered (this isn't necessarily a
+ * sequential scan path, e.g., scanning with a hash index
+ * leaves the tuples unordered)
+ * cheapestpath - least expensive Path (regardless of final order)
+ * pruneable - flag to let the planner know whether it can prune the plan
+ * space of this Rel or not. -- JMH, 11/11/92
+ *
+ * * If the relation is a (secondary) index it will have the following
+ * three fields:
+ *
+ * classlist - List of PG_AMOPCLASS OIDs for the index
+ * indexkeys - List of base-relation attribute numbers that are index keys
+ * ordering - List of PG_OPERATOR OIDs which order the indexscan result
+ * relam - the OID of the pg_am of the index
+ *
+ * * The presence of the remaining fields depends on the restrictions
+ * and joins which the relation participates in:
+ *
+ * clauseinfo - List of ClauseInfo nodes, containing info about each
+ * qualification clause in which this relation participates
+ * joininfo - List of JoinInfo nodes, containing info about each join
+ * clause in which this relation participates
+ * innerjoin - List of Path nodes that represent indices that may be used
+ * as inner paths of nestloop joins
+ *
+ * NB. the last element of the arrays classlist, indexkeys and ordering
+ * is always 0. 2/95 - ay
+ */
+
+typedef struct Rel {
+ NodeTag type;
+
+ /* all relations: */
+ Relid relids;
+
+ /* catalog statistics information */
+ bool indexed;
+ int pages;
+ int tuples;
+ int size;
+ int width;
+
+ /* materialization information */
+ List *targetlist;
+ List *pathlist;
+ struct Path *unorderedpath;
+ struct Path *cheapestpath;
+ bool pruneable;
+
+ /* used solely by indices: */
+ Oid *classlist; /* classes of AM operators */
+ int *indexkeys; /* keys over which we're indexing */
+ Oid relam; /* OID of the access method (in pg_am) */
+
+ Oid indproc;
+ List *indpred;
+
+ /* used by various scans and joins: */
+ Oid *ordering; /* OID of operators in sort order */
+ List *clauseinfo; /* restriction clauses */
+ List *joininfo; /* join clauses */
+ List *innerjoin;
+ List *superrels;
+} Rel;
+
+extern Var *get_expr(TargetEntry *foo);
+
+typedef struct MergeOrder {
+ NodeTag type;
+ Oid join_operator;
+ Oid left_operator;
+ Oid right_operator;
+ Oid left_type;
+ Oid right_type;
+} MergeOrder;
+
+typedef enum OrderType {
+ MERGE_ORDER, SORTOP_ORDER
+} OrderType;
+
+typedef struct PathOrder {
+ OrderType ordtype;
+ union {
+ Oid *sortop;
+ MergeOrder *merge;
+ } ord;
+} PathOrder;
+
+typedef struct Path {
+ NodeTag type;
+
+ Rel *parent;
+ Cost path_cost;
+
+ NodeTag pathtype;
+
+ PathOrder p_ordering;
+
+ List *keys;
+ Cost outerjoincost;
+ Relid joinid;
+ List *locclauseinfo;
+} Path;
+
+typedef struct IndexPath {
+ Path path;
+ List *indexid;
+ List *indexqual;
+} IndexPath;
+
+typedef struct JoinPath {
+ Path path;
+ List *pathclauseinfo;
+ Path *outerjoinpath;
+ Path *innerjoinpath;
+} JoinPath;
+
+typedef struct MergePath {
+ JoinPath jpath;
+ List *path_mergeclauses;
+ List *outersortkeys;
+ List *innersortkeys;
+} MergePath;
+
+typedef struct HashPath {
+ JoinPath jpath;
+ List *path_hashclauses;
+ List *outerhashkeys;
+ List *innerhashkeys;
+} HashPath;
+
+/******
+ * Keys
+ ******/
+
+typedef struct OrderKey {
+ NodeTag type;
+ int attribute_number;
+ Index array_index;
+} OrderKey;
+
+typedef struct JoinKey {
+ NodeTag type;
+ Var *outer;
+ Var *inner;
+} JoinKey;
+
+/*******
+ * clause info
+ *******/
+
+typedef struct CInfo {
+ NodeTag type;
+ Expr *clause; /* should be an OP clause */
+ Cost selectivity;
+ bool notclause;
+ List *indexids;
+
+ /* mergesort only */
+ MergeOrder *mergesortorder;
+
+ /* hashjoin only */
+ Oid hashjoinoperator;
+ Relid cinfojoinid;
+} CInfo;
+
+typedef struct JoinMethod {
+ NodeTag type;
+ List *jmkeys;
+ List *clauses;
+} JoinMethod;
+
+typedef struct HInfo {
+ JoinMethod jmethod;
+ Oid hashop;
+} HInfo;
+
+typedef struct MInfo {
+ JoinMethod jmethod;
+ MergeOrder *m_ordering;
+} MInfo;
+
+typedef struct JInfo {
+ NodeTag type;
+ List *otherrels;
+ List *jinfoclauseinfo;
+ bool mergesortable;
+ bool hashjoinable;
+ bool inactive;
+} JInfo;
+
+typedef struct Iter {
+ NodeTag type;
+ Node *iterexpr;
+ Oid itertype; /* type of the iter expr (use for type
+ checking) */
+} Iter;
+
+/*
+** Stream:
+** A stream represents a root-to-leaf path in a plan tree (i.e. a tree of
+** JoinPaths and Paths). The stream includes pointers to all Path nodes,
+** as well as to any clauses that reside above Path nodes. This structure
+** is used to make Path nodes and clauses look similar, so that Predicate
+** Migration can run.
+**
+** pathptr -- pointer to the current path node
+** cinfo -- if NULL, this stream node referes to the path node.
+** Otherwise this is a pointer to the current clause.
+** clausetype -- whether cinfo is in locclauseinfo or pathclauseinfo in the
+** path node
+** upstream -- linked list pointer upwards
+** downstream -- ditto, downwards
+** groupup -- whether or not this node is in a group with the node upstream
+** groupcost -- total cost of the group that node is in
+** groupsel -- total selectivity of the group that node is in
+*/
+typedef struct Stream *StreamPtr;
+
+typedef struct Stream {
+ NodeTag type;
+ Path *pathptr;
+ CInfo *cinfo;
+ int *clausetype;
+ struct Stream *upstream;
+ struct Stream *downstream;
+ bool groupup;
+ Cost groupcost;
+ Cost groupsel;
+} Stream;
+
+#endif /* RELATION_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for the optimizer module
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/optimizer/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:34 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+optdir=$(CURDIR)/optimizer
+VPATH:=$(VPATH):$(optdir):\
+ $(optdir)/path:$(optdir)/prep:$(optdir)/util:$(optdir)/plan
+
+SUBSRCS=
+include $(optdir)/path/Makefile.inc
+include $(optdir)/prep/Makefile.inc
+include $(optdir)/util/Makefile.inc
+include $(optdir)/plan/Makefile.inc
+SRCS_OPTIMIZER:= $(SUBSRCS)
+
+HEADERS+= clauseinfo.h clauses.h cost.h internal.h joininfo.h keys.h \
+ ordering.h pathnode.h paths.h plancat.h planmain.h \
+ planner.h prep.h tlist.h var.h xfunc.h
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * clauseinfo.h--
+ * prototypes for clauseinfo.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: clauseinfo.h,v 1.1.1.1 1996/07/09 06:21:34 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CLAUSEINFO_H
+#define CLAUSEINFO_H
+
+extern bool valid_or_clause(CInfo *clauseinfo);
+extern List *get_actual_clauses(List *clauseinfo_list);
+extern void get_relattvals(List *clauseinfo_list, List **attnos,
+ List **values, List **flags);
+extern void get_joinvars(Oid relid, List *clauseinfo_list,
+ List **attnos, List **values, List **flags);
+extern List *get_opnos(List *clauseinfo_list);
+
+#endif /* CLAUSEINFO_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * clauses.h--
+ * prototypes for clauses.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: clauses.h,v 1.1.1.1 1996/07/09 06:21:34 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CLAUSES_H
+#define CLAUSES_H
+
+#include "nodes/pg_list.h"
+#include "nodes/primnodes.h"
+
+extern Expr *make_clause(int type, Node *oper, List *args);
+extern bool is_opclause(Node *clause);
+extern Expr *make_opclause(Oper *op, Var *leftop, Var *rightop);
+extern Var *get_leftop(Expr *clause);
+extern Var *get_rightop(Expr *clause);
+
+extern bool agg_clause(Node *clause);
+
+extern bool is_funcclause(Node *clause);
+extern Expr *make_funcclause(Func *func, List *funcargs);
+
+extern bool or_clause(Node *clause);
+extern Expr *make_orclause(List *orclauses);
+
+extern bool not_clause(Node *clause);
+extern Expr *make_notclause(Expr *notclause);
+extern Expr *get_notclausearg(Expr *notclause);
+
+extern bool and_clause(Node *clause);
+extern Expr *make_andclause(List *andclauses);
+
+extern List *pull_constant_clauses(List *quals, List **constantQual);
+extern void clause_relids_vars(Node *clause, List **relids, List **vars);
+extern int NumRelids(Node *clause);
+extern bool contains_not(Node *clause);
+extern bool join_clause_p(Node *clause);
+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,
+ AttrNumber *attno, Datum *constval, int *flag);
+extern void get_rels_atts(Node *clause, int *relid1,
+ AttrNumber *attno1, int *relid2, AttrNumber *attno2);
+extern void CommuteClause(Node *clause);
+
+#endif /* CLAUSES_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * cost.h--
+ * prototypes for costsize.c and clausesel.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: cost.h,v 1.1.1.1 1996/07/09 06:21:34 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef COST_H
+#define COST_H
+
+/*
+ * prototypes for costsize.c--
+ * routines to compute costs and sizes
+ */
+extern bool _enable_seqscan_;
+extern bool _enable_indexscan_;
+extern bool _enable_sort_;
+extern bool _enable_hash_;
+extern bool _enable_nestloop_;
+extern bool _enable_mergesort_;
+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,
+ 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_result(int tuples, int width);
+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,
+ List *outersortkeys, List *innersortkeys,
+ int outersize, int innersize, int outerwidth, int innerwidth);
+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 int compute_rel_width(Rel *rel);
+extern int compute_targetlist_width(List *targetlist);
+extern int compute_joinrel_size(JoinPath *joinpath);
+extern int page_size(int tuples, int width);
+
+/*
+ * prototypes for fuctions in clausesel.h--
+ * routines to compute clause selectivities
+ */
+extern void set_clause_selectivities(List *clauseinfo_list, Cost new_selectivity);
+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,
+ Node *clause, List *or_selectivities);
+
+#endif /* COST_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * internal.h--
+ * Definitions required throughout the query optimizer.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: internal.h,v 1.1.1.1 1996/07/09 06:21:34 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef INTERNAL_H
+#define INTERNAL_H
+
+/*
+ * ---------- SHARED MACROS
+ *
+ * Macros common to modules for creating, accessing, and modifying
+ * query tree and query plan components.
+ * Shared with the executor.
+ *
+ */
+
+#include "nodes/nodes.h"
+#include "nodes/primnodes.h"
+#include "nodes/plannodes.h"
+#include "parser/parsetree.h"
+#include "nodes/relation.h"
+#include "catalog/pg_index.h" /* for INDEX_MAX_KEYS */
+#include "utils/syscache.h" /* for SearchSysCacheGetAttribute, etc. */
+
+/*
+ * System-dependent tuning constants
+ *
+ */
+#define _CPU_PAGE_WEIGHT_ 0.065 /* CPU-to-page cost weighting factor */
+#define _PAGE_SIZE_ 8192 /* BLCKSZ (from ../h/bufmgr.h) */
+#define _MAX_KEYS_ INDEX_MAX_KEYS /* maximum number of keys in an index */
+#define _TID_SIZE_ 6 /* sizeof(itemid) (from ../h/itemid.h) */
+
+/*
+ * Size estimates
+ *
+ */
+
+/* The cost of sequentially scanning a materialized temporary relation
+ */
+#define _TEMP_SCAN_COST_ 10
+
+/* The number of pages and tuples in a materialized relation
+ */
+#define _TEMP_RELATION_PAGES_ 1
+#define _TEMP_RELATION_TUPLES_ 10
+
+/* The length of a variable-length field in bytes
+ */
+#define _DEFAULT_ATTRIBUTE_WIDTH_ (2 * _TID_SIZE_)
+
+/*
+ * Flags and identifiers
+ *
+ */
+
+/* Identifier for (sort) temp relations */
+/* used to be -1 */
+#define _TEMP_RELATION_ID_ InvalidOid
+
+/* Identifier for invalid relation OIDs and attribute numbers for use by
+ * selectivity functions
+ */
+#define _SELEC_VALUE_UNKNOWN_ -1
+
+/* Flag indicating that a clause constant is really a parameter (or other
+ * non-constant?), a non-parameter, or a constant on the right side
+ * of the clause.
+ */
+#define _SELEC_NOT_CONSTANT_ 0
+#define _SELEC_IS_CONSTANT_ 1
+#define _SELEC_CONSTANT_LEFT_ 0
+#define _SELEC_CONSTANT_RIGHT_ 2
+
+#define TOLERANCE 0.000001
+
+#define FLOAT_EQUAL(X,Y) ((X) - (Y) < TOLERANCE)
+#define FLOAT_IS_ZERO(X) (FLOAT_EQUAL(X,0.0))
+
+extern int BushyPlanFlag;
+/* #define deactivate_joininfo(joininfo) joininfo->inactive=true*/
+/*#define joininfo_inactive(joininfo) joininfo->inactive */
+
+#endif /* INTERNAL_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * joininfo.h--
+ * prototypes for joininfo.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: joininfo.h,v 1.1.1.1 1996/07/09 06:21:34 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef JOININFO_H
+#define JOININFO_H
+
+extern JInfo *joininfo_member(List *join_relids, List *joininfo_list);
+extern JInfo *find_joininfo_node(Rel *this_rel, List *join_relids);
+extern Var *other_join_clause_var(Var *var, Expr *clause);
+
+#endif /* JOININFO_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * keys.h--
+ * prototypes for keys.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: keys.h,v 1.1.1.1 1996/07/09 06:21:34 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef KEYS_H
+#define KEYS_H
+
+extern bool match_indexkey_operand(int indexkey, Var *operand, Rel *rel);
+extern bool equal_indexkey_var(int index_key, Var *var);
+extern Var *extract_subkey(JoinKey *jk, int which_subkey);
+extern bool samekeys(List *keys1, List *keys2);
+extern List *collect_index_pathkeys(int *index_keys, List *tlist);
+
+#endif /* KEYS_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * ordering.h--
+ * prototypes for ordering.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: ordering.h,v 1.1.1.1 1996/07/09 06:21:34 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ORDERING_H
+#define ORDERING_H
+
+extern bool equal_path_path_ordering(PathOrder *path_ordering1,
+ PathOrder *path_ordering2);
+extern bool equal_path_merge_ordering(Oid *path_ordering,
+ MergeOrder *merge_ordering);
+extern bool equal_merge_merge_ordering(MergeOrder *merge_ordering1,
+ MergeOrder *merge_ordering2);
+extern bool equal_sortops_order(Oid *ordering1, Oid *ordering2);
+
+#endif /* ORDERING_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for optimizer/path
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:35 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS= allpaths.c clausesel.c costsize.c hashutils.c indxpath.c \
+ joinpath.c joinrels.c joinutils.c mergeutils.c orindxpath.c \
+ prune.c
+
+# not ready yet: predmig.c xfunc.c
+
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * allpaths.c--
+ * Routines to find possible search paths for processing a query
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.1.1.1 1996/07/09 06:21:35 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/relation.h"
+#include "nodes/primnodes.h"
+
+#include "optimizer/internal.h"
+
+#include "optimizer/paths.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/clauses.h"
+#include "optimizer/xfunc.h"
+#include "optimizer/cost.h"
+
+#include "commands/creatinh.h"
+
+static void find_rel_paths(Query *root, List *rels);
+static List *find_join_paths(Query *root, List *outer_rels, int levels_left);
+
+/*
+ * find-paths--
+ * Finds all possible access paths for executing a query, returning the
+ * top level list of relation entries.
+ *
+ * 'rels' is the list of single relation entries appearing in the query
+ */
+List *
+find_paths(Query *root, List *rels)
+{
+ int levels_left;
+
+ /*
+ * Set the number of join (not nesting) levels yet to be processed.
+ */
+ levels_left = length(rels);
+
+ if (levels_left <= 0)
+ return NIL;
+
+ /*
+ * Find the base relation paths.
+ */
+ find_rel_paths(root, rels);
+
+ if (levels_left <= 1) {
+ /*
+ * Unsorted single relation, no more processing is required.
+ */
+ return (rels);
+ }else {
+ /*
+ * this means that joins or sorts are required.
+ * set selectivities of clauses that have not been set
+ * by an index.
+ */
+ set_rest_relselec(root, rels);
+
+ return(find_join_paths(root, rels, levels_left-1));
+ }
+}
+
+/*
+ * find-rel-paths--
+ * Finds all paths available for scanning each relation entry in
+ * 'rels'. Sequential scan and any available indices are considered
+ * if possible(indices are not considered for lower nesting levels).
+ * All unique paths are attached to the relation's 'pathlist' field.
+ *
+ * MODIFIES: rels
+ */
+static void
+find_rel_paths(Query *root, List *rels)
+{
+ List *temp;
+ Rel *rel;
+ List *lastpath;
+
+ foreach(temp, rels) {
+ List *sequential_scan_list;
+ List *rel_index_scan_list;
+ List *or_index_scan_list;
+
+ rel = (Rel *)lfirst(temp);
+ sequential_scan_list = lcons(create_seqscan_path(rel),
+ NIL);
+
+ rel_index_scan_list =
+ find_index_paths(root,
+ rel,
+ find_relation_indices(root,rel),
+ rel->clauseinfo,
+ rel->joininfo);
+
+ or_index_scan_list =
+ create_or_index_paths(root, rel, rel->clauseinfo);
+
+ rel->pathlist = add_pathlist(rel,
+ sequential_scan_list,
+ append(rel_index_scan_list,
+ or_index_scan_list));
+
+ /* The unordered path is always the last in the list.
+ * If it is not the cheapest path, prune it.
+ */
+ lastpath = rel->pathlist;
+ while(lnext(lastpath)!=NIL)
+ lastpath=lnext(lastpath);
+ prune_rel_path(rel, (Path*)lfirst(lastpath));
+ /*
+ * if there is a qualification of sequential scan the selec.
+ * value is not set -- so set it explicitly -- Sunita
+ */
+ set_rest_selec(root, rel->clauseinfo);
+ rel->size = compute_rel_size(rel);
+ rel->width = compute_rel_width(rel);
+ }
+ return;
+}
+
+/*
+ * find-join-paths--
+ * Find all possible joinpaths for a query by successively finding ways
+ * to join single relations into join relations.
+ *
+ * if BushyPlanFlag is set, bushy tree plans will be generated:
+ * Find all possible joinpaths(bushy trees) for a query by systematically
+ * finding ways to join relations(both original and derived) together.
+ *
+ * 'outer-rels' is the current list of relations for which join paths
+ * are to be found, i.e., he current list of relations that
+ * have already been derived.
+ * 'levels-left' is the current join level being processed, where '1' is
+ * the "last" level
+ *
+ * Returns the final level of join relations, i.e., the relation that is
+ * the result of joining all the original relations togehter.
+ */
+static List *
+find_join_paths(Query *root, List *outer_rels, int levels_left)
+{
+ List *x;
+ List *new_rels;
+ Rel *rel;
+
+ /*
+ * Determine all possible pairs of relations to be joined at this level.
+ * Determine paths for joining these relation pairs and modify 'new-rels'
+ * accordingly, then eliminate redundant join relations.
+ */
+ new_rels = find_join_rels(root, outer_rels);
+
+ find_all_join_paths(root, new_rels);
+
+ new_rels = prune_joinrels(new_rels);
+
+#if 0
+ /*
+ ** for each expensive predicate in each path in each distinct rel,
+ ** consider doing pullup -- JMH
+ */
+ if (XfuncMode != XFUNC_NOPULL && XfuncMode != XFUNC_OFF)
+ foreach(x, new_rels)
+ xfunc_trypullup((Rel*)lfirst(x));
+#endif
+
+ prune_rel_paths(new_rels);
+
+ if(BushyPlanFlag) {
+ /*
+ * In case of bushy trees
+ * if there is still a join between a join relation and another
+ * relation, add a new joininfo that involves the join relation
+ * to the joininfo list of the other relation
+ */
+ add_new_joininfos(root, new_rels,outer_rels);
+ }
+
+ foreach(x, new_rels) {
+ rel = (Rel*)lfirst(x);
+ rel->size = compute_rel_size(rel);
+ rel->width = compute_rel_width(rel);
+
+/*#define OPTIMIZER_DEBUG*/
+#ifdef OPTIMIZER_DEBUG
+ printf("levels left: %d\n", levels_left);
+ debug_print_rel(root, rel);
+#endif
+ }
+
+ if(BushyPlanFlag) {
+ /*
+ * prune rels that have been completely incorporated into
+ * new join rels
+ */
+ outer_rels = prune_oldrels(outer_rels);
+ /*
+ * merge join rels if then contain the same list of base rels
+ */
+ outer_rels = merge_joinrels(new_rels,outer_rels);
+ root->join_relation_list_ = outer_rels;
+ }
+ else {
+ root->join_relation_list_ = new_rels;
+ }
+
+ if(levels_left == 1) {
+ if(BushyPlanFlag)
+ return(final_join_rels(outer_rels));
+ else
+ return(new_rels);
+ } else {
+ if(BushyPlanFlag)
+ return(find_join_paths(root, outer_rels, levels_left - 1));
+ else
+ return(find_join_paths(root, new_rels, levels_left - 1));
+ }
+}
+
+/*****************************************************************************
+ *
+ *****************************************************************************/
+
+static void
+print_joinclauses(Query *root, List *clauses)
+{
+ List *l;
+ extern void print_expr(Node *expr, List *rtable); /* in print.c */
+
+ foreach(l, clauses) {
+ CInfo *c = lfirst(l);
+
+ print_expr((Node*)c->clause, root->rtable);
+ if (lnext(l)) printf(" ");
+ }
+}
+
+void
+print_path(Query *root, Path *path, int indent)
+{
+ char *ptype = NULL;
+ JoinPath *jp;
+ bool join;
+ int i;
+
+ for(i=0; i < indent; i++)
+ printf("\t");
+
+ switch(nodeTag(path)) {
+ case T_Path:
+ ptype = "SeqScan"; join=false; break;
+ case T_IndexPath:
+ ptype = "IdxScan"; join=false; break;
+ case T_JoinPath:
+ ptype = "Nestloop"; join=true; break;
+ case T_MergePath:
+ ptype = "MergeJoin"; join=true; break;
+ case T_HashPath:
+ ptype = "HashJoin"; join=true; break;
+ default:
+ break;
+ }
+ if (join) {
+ int size = path->parent->size;
+ jp = (JoinPath*)path;
+ printf("%s size=%d cost=%f\n", ptype, size, path->path_cost);
+ switch(nodeTag(path)) {
+ case T_MergePath:
+ case T_HashPath:
+ for(i=0; i < indent+1; i++)
+ printf("\t");
+ printf(" clauses=(");
+ print_joinclauses(root,
+ ((JoinPath*)path)->pathclauseinfo);
+ printf(")\n");
+
+ if (nodeTag(path)==T_MergePath) {
+ MergePath *mp = (MergePath*)path;
+ if (mp->outersortkeys || mp->innersortkeys) {
+ for(i=0; i < indent+1; i++)
+ printf("\t");
+ printf(" sortouter=%d sortinner=%d\n",
+ ((mp->outersortkeys)?1:0),
+ ((mp->innersortkeys)?1:0));
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ print_path(root, jp->outerjoinpath, indent+1);
+ print_path(root, jp->innerjoinpath, indent+1);
+ } else {
+ int size = path->parent->size;
+ int relid = lfirsti(path->parent->relids);
+ printf("%s(%d) size=%d cost=%f",
+ ptype, relid, size, path->path_cost);
+
+ if (nodeTag(path)==T_IndexPath) {
+ List *k, *l;
+
+ printf(" keys=");
+ foreach (k, path->keys) {
+ printf("(");
+ foreach (l, lfirst(k)) {
+ Var *var = lfirst(l);
+ printf("%d.%d", var->varnoold, var->varoattno);
+ if (lnext(l)) printf(", ");
+ }
+ printf(")");
+ if (lnext(k)) printf(", ");
+ }
+ }
+ printf("\n");
+ }
+}
+
+#ifdef OPTIMIZER_DEBUG
+static void
+debug_print_rel(Query *root, Rel *rel)
+{
+ List *l;
+
+ printf("(");
+ foreach(l, rel->relids) {
+ printf("%d ", lfirsti(l));
+ }
+ printf("): size=%d width=%d\n", rel->size, rel->width);
+
+ printf("\tpath list:\n");
+ foreach (l, rel->pathlist) {
+ print_path(root, lfirst(l), 1);
+ }
+ printf("\tcheapest path:\n");
+ print_path(root, rel->cheapestpath, 1);
+}
+#endif /* OPTIMIZER_DEBUG */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * clausesel.c--
+ * Routines to compute and set clause selectivities
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/clausesel.c,v 1.1.1.1 1996/07/09 06:21:35 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/relation.h"
+#include "nodes/primnodes.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/clauses.h"
+#include "optimizer/clauseinfo.h"
+#include "optimizer/cost.h"
+#include "optimizer/plancat.h"
+
+#include "parser/parsetree.h" /* for getrelid() */
+
+#include "catalog/pg_proc.h"
+#include "catalog/pg_operator.h"
+
+#include "utils/elog.h"
+#include "utils/lsyscache.h"
+
+static Cost compute_selec(Query *root, List *clauses, List *or_selectivities);
+
+/****************************************************************************
+ * ROUTINES TO SET CLAUSE SELECTIVITIES
+ ****************************************************************************/
+
+/*
+ * set_clause_selectivities -
+ * Sets the selectivity field for each of clause in 'clauseinfo-list'
+ * to 'new-selectivity'. If the selectivity has already been set, reset
+ * it only if the new one is better.
+ *
+ * Returns nothing of interest.
+ *
+ */
+void
+set_clause_selectivities(List *clauseinfo_list, Cost new_selectivity)
+{
+ List *temp;
+ CInfo *clausenode;
+ Cost cost_clause;
+
+ foreach (temp,clauseinfo_list) {
+ clausenode = (CInfo*)lfirst(temp);
+ cost_clause = clausenode->selectivity;
+ if ( FLOAT_IS_ZERO(cost_clause) || new_selectivity < cost_clause) {
+ clausenode->selectivity = new_selectivity;
+ }
+ }
+}
+
+/*
+ * product_selec -
+ * Multiplies the selectivities of each clause in 'clauseinfo-list'.
+ *
+ * Returns a flonum corresponding to the selectivity of 'clauseinfo-list'.
+ */
+Cost
+product_selec(List *clauseinfo_list)
+{
+ Cost result = 1.0;
+ if (clauseinfo_list!=NIL) {
+ List *xclausenode = NIL;
+ Cost temp;
+
+ foreach(xclausenode,clauseinfo_list) {
+ temp = ((CInfo *)lfirst(xclausenode))->selectivity;
+ result = result * temp;
+ }
+ }
+ return(result);
+}
+
+/*
+ * set_rest_relselec -
+ * Scans through clauses on each relation and assigns a selectivity to
+ * those clauses that haven't been assigned a selectivity by an index.
+ *
+ * Returns nothing of interest.
+ * MODIFIES: selectivities of the various rel's clauseinfo
+ * slots.
+ */
+void
+set_rest_relselec(Query *root, List *rel_list)
+{
+ Rel *rel;
+ List *x;
+
+ foreach (x,rel_list) {
+ rel = (Rel*)lfirst(x);
+ set_rest_selec(root, rel->clauseinfo);
+ }
+}
+
+/*
+ * set_rest_selec -
+ * Sets the selectivity fields for those clauses within a single
+ * relation's 'clauseinfo-list' that haven't already been set.
+ *
+ * Returns nothing of interest.
+ *
+ */
+void
+set_rest_selec(Query *root, List *clauseinfo_list)
+{
+ List *temp = NIL;
+ CInfo *clausenode = (CInfo*)NULL;
+ Cost cost_clause;
+
+ foreach (temp,clauseinfo_list) {
+ clausenode = (CInfo*)lfirst(temp);
+ cost_clause = clausenode->selectivity;
+
+ /*
+ * Check to see if the selectivity of this clause or any 'or'
+ * subclauses (if any) haven't been set yet.
+ */
+ if (valid_or_clause(clausenode) || FLOAT_IS_ZERO(cost_clause)) {
+ clausenode->selectivity =
+ compute_clause_selec(root,
+ (Node*)clausenode->clause,
+ lcons(makeFloat(cost_clause), NIL));
+ }
+ }
+}
+
+/****************************************************************************
+ * ROUTINES TO COMPUTE SELECTIVITIES
+ ****************************************************************************/
+
+/*
+ * compute_clause_selec -
+ * Given a clause, this routine will compute the selectivity of the
+ * clause by calling 'compute_selec' with the appropriate parameters
+ * and possibly use that return value to compute the real selectivity
+ * of a clause.
+ *
+ * 'or-selectivities' are selectivities that have already been assigned
+ * to subclauses of an 'or' clause.
+ *
+ * Returns a flonum corresponding to the clause selectivity.
+ *
+ */
+Cost
+compute_clause_selec(Query *root, Node *clause, List *or_selectivities)
+{
+ if (!is_opclause (clause)) {
+ /* if it's not an operator clause, then it is a boolean clause -jolly*/
+ /*
+ * Boolean variables get a selectivity of 1/2.
+ */
+ return(0.1);
+ } else if (not_clause (clause)) {
+ /*
+ * 'not' gets "1.0 - selectivity-of-inner-clause".
+ */
+ return (1.000000 - compute_selec(root,
+ lcons(get_notclausearg((Expr*)clause),
+ NIL),
+ or_selectivities));
+ } else if (or_clause(clause)) {
+ /*
+ * Both 'or' and 'and' clauses are evaluated as described in
+ * (compute_selec).
+ */
+ return (compute_selec(root,
+ ((Expr*)clause)->args, or_selectivities));
+ } else {
+ return(compute_selec(root,
+ lcons(clause,NIL),or_selectivities));
+ }
+}
+
+/*
+ * compute_selec -
+ * Computes the selectivity of a clause.
+ *
+ * If there is more than one clause in the argument 'clauses', then the
+ * desired selectivity is that of an 'or' clause. Selectivities for an
+ * 'or' clause such as (OR a b) are computed by finding the selectivity
+ * of a (s1) and b (s2) and computing s1+s2 - s1*s2.
+ *
+ * In addition, if the clause is an 'or' clause, individual selectivities
+ * may have already been assigned by indices to subclauses. These values
+ * are contained in the list 'or-selectivities'.
+ *
+ * Returns the clause selectivity as a flonum.
+ *
+ */
+static Cost
+compute_selec(Query *root, List *clauses, List *or_selectivities)
+{
+ Cost s1 = 0;
+ List *clause = lfirst(clauses);
+
+ if (clauses==NULL) {
+ s1 = 1.0;
+ } else if (IsA(clause,Param)) {
+ /* XXX How're we handling this before?? -ay */
+ s1 = 1.0;
+ } else if (IsA(clause,Const)) {
+ s1 = ((bool) ((Const*) clause)->constvalue) ? 1.0 : 0.0;
+ } else if (IsA(clause,Var)) {
+ Oid relid = getrelid(((Var*)clause)->varno,
+ root->rtable);
+
+ /*
+ * we have a bool Var. This is exactly equivalent to the clause:
+ * reln.attribute = 't'
+ * so we compute the selectivity as if that is what we have. The
+ * magic #define constants are a hack. I didn't want to have to
+ * do system cache look ups to find out all of that info.
+ */
+
+ s1 = restriction_selectivity(EqualSelectivityProcedure,
+ BooleanEqualOperator,
+ relid,
+ ((Var*)clause)->varoattno,
+ "t",
+ _SELEC_CONSTANT_RIGHT_);
+ } else if (or_selectivities) {
+ /* If s1 has already been assigned by an index, use that value. */
+ List *this_sel = lfirst(or_selectivities);
+
+ s1 = floatVal(this_sel);
+ } else if (is_funcclause((Node*)clause)) {
+ /* this isn't an Oper, it's a Func!! */
+ /*
+ ** This is not an operator, so we guess at the selectivity.
+ ** THIS IS A HACK TO GET V4 OUT THE DOOR. FUNCS SHOULD BE
+ ** ABLE TO HAVE SELECTIVITIES THEMSELVES.
+ ** -- JMH 7/9/92
+ */
+ s1 = 0.1;
+ } else if (NumRelids((Node*) clause) == 1) {
+ /* ...otherwise, calculate s1 from 'clauses'.
+ * The clause is not a join clause, since there is
+ * only one relid in the clause. The clause
+ * selectivity will be based on the operator
+ * selectivity and operand values.
+ */
+ Oid opno = ((Oper*)((Expr*)clause)->oper)->opno;
+ RegProcedure oprrest = get_oprrest(opno);
+ Oid relid;
+ int relidx;
+ AttrNumber attno;
+ Datum constval;
+ int flag;
+
+ get_relattval((Node*)clause, &relidx, &attno, &constval, &flag);
+ relid = getrelid(relidx, root->rtable);
+
+ /* if the oprrest procedure is missing for whatever reason,
+ use a selectivity of 0.5*/
+ if (!oprrest)
+ s1 = (Cost) (0.5);
+ else
+ if (attno == InvalidAttrNumber) {
+ /* attno can be Invalid if the clause had a function in it,
+ i.e. WHERE myFunc(f) = 10 */
+ /* this should be FIXED somehow to use function selectivity */
+ s1 = (Cost) (0.5);
+ } else
+ s1 = (Cost) restriction_selectivity(oprrest,
+ opno,
+ relid,
+ attno,
+ (char *)constval,
+ flag);
+
+ } else {
+ /* The clause must be a join clause. The clause
+ * selectivity will be based on the relations to be
+ * scanned and the attributes they are to be joined
+ * on.
+ */
+ Oid opno = ((Oper*)((Expr*)clause)->oper)->opno;
+ RegProcedure oprjoin = get_oprjoin (opno);
+ int relid1, relid2;
+ AttrNumber attno1, attno2;
+
+ get_rels_atts((Node*)clause, &relid1, &attno1, &relid2, &attno2);
+ relid1 = getrelid(relid1, root->rtable);
+ relid2 = getrelid(relid2, root->rtable);
+
+ /* if the oprjoin procedure is missing for whatever reason,
+ use a selectivity of 0.5*/
+ if (!oprjoin)
+ s1 = (Cost) (0.5);
+ else
+ s1 = (Cost) join_selectivity(oprjoin,
+ opno,
+ relid1,
+ attno1,
+ relid2,
+ attno2);
+ }
+
+ /* A null clause list eliminates no tuples, so return a selectivity
+ * of 1.0. If there is only one clause, the selectivity is not
+ * that of an 'or' clause, but rather that of the single clause.
+ */
+
+ if (length (clauses) < 2) {
+ return(s1);
+ } else {
+ /* Compute selectivity of the 'or'ed subclauses. */
+ /* Added check for taking lnext(NIL). -- JMH 3/9/92 */
+ Cost s2;
+
+ if (or_selectivities != NIL)
+ s2 = compute_selec(root, lnext(clauses), lnext(or_selectivities));
+ else
+ s2 = compute_selec(root, lnext(clauses), NIL);
+ return(s1 + s2 - s1 * s2);
+ }
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * costsize.c--
+ * Routines to compute (and set) relation sizes and path costs
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.1.1.1 1996/07/09 06:21:35 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#ifdef WIN32
+#include
+#include
+#define MAXINT INT_MAX
+#else
+# if defined(PORTNAME_BSD44_derived) || defined(PORTNAME_bsdi)
+# include
+# define MAXINT INT_MAX
+# else
+# include
+# endif /* !PORTNAME_BSD44_derived */
+#endif /* WIN32 */
+
+#include "postgres.h"
+
+#include "nodes/relation.h"
+
+#include "optimizer/cost.h"
+#include "optimizer/internal.h"
+#include "optimizer/keys.h"
+#include "optimizer/tlist.h"
+
+#include "storage/bufmgr.h" /* for BLCKSZ */
+
+static int compute_attribute_width(TargetEntry *tlistentry);
+static double base_log(double x, double b);
+
+int _disable_cost_ = 30000000;
+
+bool _enable_seqscan_ = true;
+bool _enable_indexscan_ = true;
+bool _enable_sort_ = true;
+bool _enable_hash_ = true;
+bool _enable_nestloop_ = true;
+bool _enable_mergesort_ = true;
+bool _enable_hashjoin_ = true;
+
+/*
+ * cost_seqscan--
+ * Determines and returns the cost of scanning a relation sequentially.
+ * If the relation is a temporary to be materialized from a query
+ * embedded within a data field (determined by 'relid' containing an
+ * attribute reference), then a predetermined constant is returned (we
+ * have NO IDEA how big the result of a POSTQUEL procedure is going to
+ * be).
+ *
+ * disk = p
+ * cpu = *CPU-PAGE-WEIGHT* * t
+ *
+ * 'relid' is the relid of the relation to be scanned
+ * 'relpages' is the number of pages in the relation to be scanned
+ * (as determined from the system catalogs)
+ * 'reltuples' is the number of tuples in the relation to be scanned
+ *
+ * Returns a flonum.
+ *
+ */
+Cost
+cost_seqscan(int relid, int relpages, int reltuples)
+{
+ Cost temp = 0;
+
+ if ( !_enable_seqscan_ )
+ temp += _disable_cost_;
+
+ if (relid < 0) {
+ /*
+ * cost of sequentially scanning a materialized temporary relation
+ */
+ temp += _TEMP_SCAN_COST_;
+ } else {
+ temp += relpages;
+ temp += _CPU_PAGE_WEIGHT_ * reltuples;
+ }
+ Assert(temp >= 0);
+ return(temp);
+}
+
+
+/*
+ * cost_index--
+ * Determines and returns the cost of scanning a relation using an index.
+ *
+ * disk = expected-index-pages + expected-data-pages
+ * cpu = *CPU-PAGE-WEIGHT* *
+ * (expected-index-tuples + expected-data-tuples)
+ *
+ * 'indexid' is the index OID
+ * 'expected-indexpages' is the number of index pages examined in the scan
+ * 'selec' is the selectivity of the index
+ * 'relpages' is the number of pages in the main relation
+ * 'reltuples' is the number of tuples in the main relation
+ * 'indexpages' is the number of pages in the index relation
+ * 'indextuples' is the number of tuples in the index relation
+ *
+ * Returns a flonum.
+ *
+ */
+Cost
+cost_index(Oid indexid,
+ int expected_indexpages,
+ Cost selec,
+ int relpages,
+ int reltuples,
+ int indexpages,
+ int indextuples,
+ bool is_injoin)
+{
+ Cost temp;
+ Cost temp2;
+
+ temp = temp2 = (Cost) 0;
+
+ if (!_enable_indexscan_ && !is_injoin)
+ temp += _disable_cost_;
+
+ /* expected index relation pages */
+ temp += expected_indexpages;
+
+ /* about one base relation page */
+ temp += Min(relpages,(int)ceil((double)selec*indextuples));
+
+ /*
+ * per index tuple
+ */
+ temp2 += selec * indextuples;
+ temp2 += selec * reltuples;
+
+ temp = temp + (_CPU_PAGE_WEIGHT_ * temp2);
+ Assert(temp >= 0);
+ return(temp);
+}
+
+/*
+ * cost_sort--
+ * Determines and returns the cost of sorting a relation by considering
+ * 1. the cost of doing an external sort: XXX this is probably too low
+ * disk = (p lg p)
+ * cpu = *CPU-PAGE-WEIGHT* * (t lg t)
+ * 2. the cost of reading the sort result into memory (another seqscan)
+ * unless 'noread' is set
+ *
+ * 'keys' is a list of sort keys
+ * 'tuples' is the number of tuples in the relation
+ * 'width' is the average tuple width in bytes
+ * 'noread' is a flag indicating that the sort result can remain on disk
+ * (i.e., the sort result is the result relation)
+ *
+ * Returns a flonum.
+ *
+ */
+Cost
+cost_sort(List *keys, int tuples, int width, bool noread)
+{
+ Cost temp = 0;
+ int npages = page_size (tuples,width);
+ Cost pages = (Cost)npages;
+ Cost numTuples = tuples;
+
+ if ( !_enable_sort_ )
+ temp += _disable_cost_ ;
+ if (tuples == 0 || keys==NULL)
+ {
+ Assert(temp >= 0);
+ return(temp);
+ }
+ temp += pages * base_log((double)pages, (double)2.0);
+
+ /*
+ * could be base_log(pages, NBuffers), but we are only doing 2-way merges
+ */
+ temp += _CPU_PAGE_WEIGHT_ *
+ numTuples * base_log((double)pages,(double)2.0);
+
+ if( !noread )
+ temp = temp + cost_seqscan(_TEMP_RELATION_ID_, npages, tuples);
+ Assert(temp >= 0);
+
+ return(temp);
+}
+
+
+/*
+ * cost_result--
+ * Determines and returns the cost of writing a relation of 'tuples'
+ * tuples of 'width' bytes out to a result relation.
+ *
+ * Returns a flonum.
+ *
+ */
+Cost
+cost_result(int tuples, int width)
+{
+ Cost temp =0;
+ temp = temp + page_size(tuples,width);
+ temp = temp + _CPU_PAGE_WEIGHT_ * tuples;
+ Assert(temp >= 0);
+ return(temp);
+}
+
+/*
+ * cost_nestloop--
+ * Determines and returns the cost of joining two relations using the
+ * nested loop algorithm.
+ *
+ * 'outercost' is the (disk+cpu) cost of scanning the outer relation
+ * 'innercost' is the (disk+cpu) cost of scanning the inner relation
+ * 'outertuples' is the number of tuples in the outer relation
+ *
+ * Returns a flonum.
+ *
+ */
+Cost
+cost_nestloop(Cost outercost,
+ Cost innercost,
+ int outertuples,
+ int innertuples,
+ int outerpages,
+ bool is_indexjoin)
+{
+ Cost temp =0;
+
+ if ( !_enable_nestloop_ )
+ temp += _disable_cost_;
+ temp += outercost;
+ temp += outertuples * innercost;
+ Assert(temp >= 0);
+
+ return(temp);
+}
+
+/*
+ * cost_mergesort--
+ * 'outercost' and 'innercost' are the (disk+cpu) costs of scanning the
+ * outer and inner relations
+ * 'outersortkeys' and 'innersortkeys' are lists of the keys to be used
+ * to sort the outer and inner relations
+ * 'outertuples' and 'innertuples' are the number of tuples in the outer
+ * and inner relations
+ * 'outerwidth' and 'innerwidth' are the (typical) widths (in bytes)
+ * of the tuples of the outer and inner relations
+ *
+ * Returns a flonum.
+ *
+ */
+Cost
+cost_mergesort(Cost outercost,
+ Cost innercost,
+ List *outersortkeys,
+ List *innersortkeys,
+ int outersize,
+ int innersize,
+ int outerwidth,
+ int innerwidth)
+{
+ Cost temp = 0;
+
+ if ( !_enable_mergesort_ )
+ temp += _disable_cost_;
+
+ temp += outercost;
+ temp += innercost;
+ temp += cost_sort(outersortkeys,outersize,outerwidth,false);
+ temp += cost_sort(innersortkeys,innersize,innerwidth,false);
+ temp += _CPU_PAGE_WEIGHT_ * (outersize + innersize);
+ Assert(temp >= 0);
+
+ return(temp);
+}
+
+/*
+ * cost_hashjoin-- XXX HASH
+ * 'outercost' and 'innercost' are the (disk+cpu) costs of scanning the
+ * outer and inner relations
+ * 'outerkeys' and 'innerkeys' are lists of the keys to be used
+ * to hash the outer and inner relations
+ * 'outersize' and 'innersize' are the number of tuples in the outer
+ * and inner relations
+ * 'outerwidth' and 'innerwidth' are the (typical) widths (in bytes)
+ * of the tuples of the outer and inner relations
+ *
+ * Returns a flonum.
+ */
+Cost
+cost_hashjoin(Cost outercost,
+ Cost innercost,
+ List *outerkeys,
+ List *innerkeys,
+ int outersize,
+ int innersize,
+ int outerwidth,
+ int innerwidth)
+{
+ Cost temp = 0;
+ int outerpages = page_size (outersize,outerwidth);
+ int innerpages = page_size (innersize,innerwidth);
+ int nrun = ceil((double)outerpages/(double)NBuffers);
+
+ if (outerpages < innerpages)
+ return _disable_cost_;
+ if ( !_enable_hashjoin_ )
+ temp += _disable_cost_;
+/* temp += outercost + (nrun + 1) * innercost; */
+ /*
+ the innercost shouldn't be used it. Instead the
+ cost of hashing the innerpath should be used
+
+ ASSUME innercost is 1 for now -- a horrible hack
+ - jolly
+ */
+ temp += outercost + (nrun + 1);
+
+ temp += _CPU_PAGE_WEIGHT_ * (outersize + nrun * innersize);
+ Assert(temp >= 0);
+
+ return(temp);
+}
+
+/*
+ * compute-rel-size--
+ * Computes the size of each relation in 'rel-list' (after applying
+ * restrictions), by multiplying the selectivity of each restriction
+ * by the original size of the relation.
+ *
+ * Sets the 'size' field for each relation entry with this computed size.
+ *
+ * Returns the size.
+ */
+int compute_rel_size(Rel *rel)
+{
+ Cost temp;
+ int temp1;
+
+ temp = rel->tuples * product_selec(rel->clauseinfo);
+ Assert(temp >= 0);
+ if (temp >= (MAXINT - 1)) {
+ temp1 = MAXINT;
+ } else {
+ temp1 = ceil((double) temp);
+ }
+ Assert(temp1 >= 0);
+ Assert(temp1 <= MAXINT);
+ return(temp1);
+}
+
+/*
+ * compute-rel-width--
+ * Computes the width in bytes of a tuple from 'rel'.
+ *
+ * Returns the width of the tuple as a fixnum.
+ */
+int
+compute_rel_width(Rel *rel)
+{
+ return (compute_targetlist_width(get_actual_tlist(rel->targetlist)));
+}
+
+/*
+ * compute-targetlist-width--
+ * Computes the width in bytes of a tuple made from 'targetlist'.
+ *
+ * Returns the width of the tuple as a fixnum.
+ */
+int
+compute_targetlist_width(List *targetlist)
+{
+ List *temp_tl;
+ int tuple_width = 0;
+
+ foreach (temp_tl, targetlist) {
+ tuple_width = tuple_width +
+ compute_attribute_width(lfirst(temp_tl));
+ }
+ return(tuple_width);
+}
+
+/*
+ * compute-attribute-width--
+ * Given a target list entry, find the size in bytes of the attribute.
+ *
+ * If a field is variable-length, it is assumed to be at least the size
+ * of a TID field.
+ *
+ * Returns the width of the attribute as a fixnum.
+ */
+static int
+compute_attribute_width(TargetEntry *tlistentry)
+{
+ int width = get_typlen(tlistentry->resdom->restype);
+ if (width < 0)
+ return(_DEFAULT_ATTRIBUTE_WIDTH_);
+ else
+ return(width);
+}
+
+/*
+ * compute-joinrel-size--
+ * Computes the size of the join relation 'joinrel'.
+ *
+ * Returns a fixnum.
+ */
+int
+compute_joinrel_size(JoinPath *joinpath)
+{
+ Cost temp = 1.0;
+ int temp1 = 0;
+
+ temp *= ((Path*)joinpath->outerjoinpath)->parent->size;
+ temp *= ((Path*)joinpath->innerjoinpath)->parent->size;
+
+ temp = temp * product_selec(joinpath->pathclauseinfo);
+ if (temp >= (MAXINT -1)) {
+ temp1 = MAXINT;
+ } else {
+ /* should be ceil here, we don't want joinrel size's of one, do we? */
+ temp1 = ceil((double)temp);
+ }
+ Assert(temp1 >= 0);
+
+ return(temp1);
+}
+
+/*
+ * page-size--
+ * Returns an estimate of the number of pages covered by a given
+ * number of tuples of a given width (size in bytes).
+ */
+int page_size(int tuples, int width)
+{
+ int temp =0;
+
+ temp = ceil((double)(tuples * (width + sizeof(HeapTupleData)))
+ / BLCKSZ);
+ Assert(temp >= 0);
+ return(temp);
+}
+
+static double
+base_log(double x, double b)
+{
+ return(log(x)/log(b));
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * hashutils.c--
+ * Utilities for finding applicable merge clauses and pathkeys
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/hashutils.c,v 1.1.1.1 1996/07/09 06:21:35 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+#include "nodes/pg_list.h"
+#include "nodes/relation.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/paths.h"
+#include "optimizer/clauses.h"
+
+
+static HInfo *match_hashop_hashinfo(Oid hashop, List *hashinfo_list);
+
+/*
+ * group-clauses-by-hashop--
+ * If a join clause node in 'clauseinfo-list' is hashjoinable, store
+ * it within a hashinfo node containing other clause nodes with the same
+ * hash operator.
+ *
+ * 'clauseinfo-list' is the list of clauseinfo nodes
+ * 'inner-relid' is the relid of the inner join relation
+ *
+ * Returns the new list of hashinfo nodes.
+ *
+ */
+List *
+group_clauses_by_hashop(List *clauseinfo_list,
+ int inner_relid)
+{
+ List *hashinfo_list = NIL;
+ CInfo *clauseinfo = (CInfo*)NULL;
+ List *i = NIL;
+ Oid hashjoinop = 0;
+
+ foreach (i,clauseinfo_list) {
+ clauseinfo = (CInfo*)lfirst(i);
+ hashjoinop = clauseinfo->hashjoinoperator;
+
+ /*
+ * Create a new hashinfo node and add it to 'hashinfo-list' if one
+ * does not yet exist for this hash operator.
+ */
+ if (hashjoinop ) {
+ HInfo *xhashinfo = (HInfo*)NULL;
+ Expr *clause = clauseinfo->clause;
+ Var *leftop = get_leftop(clause);
+ Var *rightop = get_rightop(clause);
+ JoinKey *keys = (JoinKey*)NULL;
+
+ xhashinfo =
+ match_hashop_hashinfo(hashjoinop,hashinfo_list);
+
+ if (inner_relid == leftop->varno){
+ keys = makeNode(JoinKey);
+ keys->outer = rightop;
+ keys->inner = leftop;
+ } else {
+ keys = makeNode(JoinKey);
+ keys->outer = leftop;
+ keys->inner = rightop;
+ }
+
+ if (xhashinfo==NULL) {
+ xhashinfo = makeNode(HInfo);
+ xhashinfo->hashop = hashjoinop;
+
+ xhashinfo->jmethod.jmkeys = NIL;
+ xhashinfo->jmethod.clauses = NIL;
+
+ /* XXX was push */
+ hashinfo_list = lappend(hashinfo_list,xhashinfo);
+ hashinfo_list = nreverse(hashinfo_list);
+ }
+
+ xhashinfo->jmethod.clauses =
+ lcons(clause, xhashinfo->jmethod.clauses);
+
+ xhashinfo->jmethod.jmkeys =
+ lcons(keys, xhashinfo->jmethod.jmkeys);
+ }
+ }
+ return(hashinfo_list);
+}
+
+
+/*
+ * match-hashop-hashinfo--
+ * Searches the list 'hashinfo-list' for a hashinfo node whose hash op
+ * field equals 'hashop'.
+ *
+ * Returns the node if it exists.
+ *
+ */
+static HInfo *
+match_hashop_hashinfo(Oid hashop, List *hashinfo_list)
+{
+ Oid key = 0;
+ HInfo *xhashinfo = (HInfo*)NULL;
+ List *i = NIL;
+
+ foreach( i, hashinfo_list) {
+ xhashinfo = (HInfo*)lfirst(i);
+ key = xhashinfo->hashop;
+ if (hashop == key) { /* found */
+ return(xhashinfo); /* should be a hashinfo node ! */
+ }
+ }
+ return((HInfo*)NIL);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * indxpath.c--
+ * Routines to determine which indices are usable for scanning a
+ * given relation
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.1.1.1 1996/07/09 06:21:35 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "postgres.h"
+#include "access/attnum.h"
+#include "access/heapam.h"
+#include "access/nbtree.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/relation.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
+
+#include "utils/lsyscache.h"
+#include "utils/elog.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/paths.h"
+#include "optimizer/clauses.h"
+#include "optimizer/clauseinfo.h"
+#include "optimizer/plancat.h"
+#include "optimizer/keys.h"
+#include "optimizer/cost.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/xfunc.h"
+#include "optimizer/ordering.h"
+
+
+#include "catalog/catname.h"
+#include "catalog/pg_amop.h"
+#include "catalog/pg_proc.h"
+
+#include "executor/executor.h"
+#include "parser/parsetree.h" /* for getrelid() */
+
+
+static void match_index_orclauses(Rel *rel, Rel *index, int indexkey,
+ int xclass, List *clauseinfo_list);
+static bool match_index_to_operand(int indexkey, Expr *operand,
+ Rel *rel, Rel *index);
+static List *match_index_orclause(Rel *rel, Rel *index, int indexkey,
+ int xclass, List *or_clauses, List *other_matching_indices);
+static List *group_clauses_by_indexkey(Rel *rel, Rel *index,
+ int *indexkeys, Oid *classes, List *clauseinfo_list,
+ bool join);
+static CInfo *match_clause_to_indexkey(Rel *rel, Rel *index, int indexkey,
+ int xclass, CInfo *clauseInfo, bool join);
+static bool pred_test(List *predicate_list, List *clauseinfo_list,
+ List *joininfo_list);
+static bool one_pred_test(Expr *predicate, List *clauseinfo_list);
+static bool one_pred_clause_expr_test(Expr *predicate, Node *clause);
+static bool one_pred_clause_test(Expr *predicate, Node *clause);
+static bool clause_pred_clause_test(Expr *predicate, Node *clause);
+static List *indexable_joinclauses(Rel *rel, Rel *index, List *joininfo_list);
+static List *index_innerjoin(Query *root, Rel *rel,
+ List *clausegroup_list, Rel *index);
+static List *create_index_paths(Query *root, Rel *rel, Rel *index,
+ List *clausegroup_list, bool join);
+static List *add_index_paths(List *indexpaths, List *new_indexpaths);
+static bool function_index_operand(Expr *funcOpnd, Rel *rel, Rel *index);
+static bool SingleAttributeIndex(Rel *index);
+
+/* If Spyros can use a constant PRS2_BOOL_TYPEID, I can use this */
+#define BOOL_TYPEID ((Oid) 16)
+
+/*
+ * find-index-paths--
+ * Finds all possible index paths by determining which indices in the
+ * list 'indices' are usable.
+ *
+ * To be usable, an index must match against either a set of
+ * restriction clauses or join clauses.
+ *
+ * Note that the current implementation requires that there exist
+ * matching clauses for every key in the index (i.e., no partial
+ * matches are allowed).
+ *
+ * If an index can't be used with restriction clauses, but its keys
+ * match those of the result sort order (according to information stored
+ * within 'sortkeys'), then the index is also considered.
+ *
+ * 'rel' is the relation entry to which these index paths correspond
+ * 'indices' is a list of possible index paths
+ * 'clauseinfo-list' is a list of restriction clauseinfo nodes for 'rel'
+ * 'joininfo-list' is a list of joininfo nodes for 'rel'
+ * 'sortkeys' is a node describing the result sort order (from
+ * (find_sortkeys))
+ *
+ * Returns a list of index nodes.
+ *
+ */
+List *
+find_index_paths (Query *root,
+ Rel *rel,
+ List *indices,
+ List *clauseinfo_list,
+ List *joininfo_list)
+{
+ List *scanclausegroups = NIL;
+ List *scanpaths = NIL;
+ Rel *index = (Rel *)NULL;
+ List *joinclausegroups = NIL;
+ List *joinpaths = NIL;
+ List *retval = NIL;
+ extern List *add_index_paths();
+
+ if(indices == NIL)
+ return(NULL);
+
+ index = (Rel*)lfirst (indices);
+
+ retval = find_index_paths(root,
+ rel,
+ lnext (indices),
+ clauseinfo_list,
+ joininfo_list);
+
+ /* If this is a partial index, return if it fails the predicate test */
+ if (index->indpred != NIL)
+ if (!pred_test(index->indpred, clauseinfo_list, joininfo_list))
+ return retval;
+
+ /* 1. If this index has only one key, try matching it against
+ * subclauses of an 'or' clause. The fields of the clauseinfo
+ * nodes are marked with lists of the matching indices no path
+ * are actually created.
+ *
+ * XXX NOTE: Currently btrees dos not support indices with
+ * > 1 key, so the following test will always be true for
+ * now but we have decided not to support index-scans
+ * on disjunction . -- lp
+ */
+ if (SingleAttributeIndex(index))
+ {
+ match_index_orclauses (rel,
+ index,
+ index->indexkeys[0],
+ index->classlist[0],
+ clauseinfo_list);
+ }
+
+ /*
+ * 2. If the keys of this index match any of the available
+ * restriction clauses, then create pathnodes corresponding
+ * to each group of usable clauses.
+ */
+ scanclausegroups = group_clauses_by_indexkey(rel,
+ index,
+ index->indexkeys,
+ index->classlist,
+ clauseinfo_list,
+ false);
+
+ scanpaths = NIL;
+ if (scanclausegroups != NIL)
+ scanpaths = create_index_paths (root,
+ rel,
+ index,
+ scanclausegroups,
+ false);
+
+ /*
+ * 3. If this index can be used with any join clause, then
+ * create pathnodes for each group of usable clauses. An
+ * index can be used with a join clause if its ordering is
+ * useful for a mergejoin, or if the index can possibly be
+ * used for scanning the inner relation of a nestloop join.
+ */
+ joinclausegroups = indexable_joinclauses(rel,index,joininfo_list);
+ joinpaths = NIL;
+
+ if (joinclausegroups != NIL)
+ {
+ List *new_join_paths = create_index_paths(root, rel,
+ index,
+ joinclausegroups,
+ true);
+ List *innerjoin_paths = index_innerjoin(root, rel,joinclausegroups,index);
+
+ rel->innerjoin = nconc (rel->innerjoin, innerjoin_paths);
+ joinpaths = new_join_paths;
+ }
+
+ /*
+ * Some sanity checks to make sure that
+ * the indexpath is valid.
+ */
+ if (joinpaths!=NULL)
+ retval = add_index_paths(joinpaths,retval);
+ if (scanpaths!=NULL)
+ retval = add_index_paths(scanpaths,retval);
+
+ return retval;
+
+}
+
+
+/****************************************************************************
+ * ---- ROUTINES TO MATCH 'OR' CLAUSES ----
+ ****************************************************************************/
+
+
+/*
+ * match-index-orclauses--
+ * Attempt to match an index against subclauses within 'or' clauses.
+ * If the index does match, then the clause is marked with information
+ * about the index.
+ *
+ * Essentially, this adds 'index' to the list of indices in the
+ * ClauseInfo field of each of the clauses which it matches.
+ *
+ * 'rel' is the node of the relation on which the index is defined.
+ * 'index' is the index node.
+ * 'indexkey' is the (single) key of the index
+ * 'class' is the class of the operator corresponding to 'indexkey'.
+ * 'clauseinfo-list' is the list of available restriction clauses.
+ *
+ * Returns nothing.
+ *
+ */
+static void
+match_index_orclauses(Rel *rel,
+ Rel *index,
+ int indexkey,
+ int xclass,
+ List *clauseinfo_list)
+{
+ CInfo *clauseinfo = (CInfo*)NULL;
+ List *i = NIL;
+
+ foreach (i, clauseinfo_list) {
+ clauseinfo = (CInfo*)lfirst(i);
+ if (valid_or_clause(clauseinfo)) {
+
+ /* Mark the 'or' clause with a list of indices which
+ * match each of its subclauses. The list is
+ * generated by adding 'index' to the existing
+ * list where appropriate.
+ */
+ clauseinfo->indexids =
+ match_index_orclause (rel,index,indexkey,
+ xclass,
+ clauseinfo->clause->args,
+ clauseinfo->indexids);
+ }
+ }
+}
+
+/*
+ * match_index_operand--
+ * Generalize test for a match between an existing index's key
+ * and the operand on the rhs of a restriction clause. Now check
+ * for functional indices as well.
+ */
+static bool
+match_index_to_operand(int indexkey,
+ Expr *operand,
+ Rel *rel,
+ Rel *index)
+{
+ /*
+ * Normal index.
+ */
+ if (index->indproc == InvalidOid)
+ return match_indexkey_operand(indexkey, (Var*)operand, rel);
+
+ /*
+ * functional index check
+ */
+ return (function_index_operand(operand, rel, index));
+}
+
+/*
+ * match-index-orclause--
+ * Attempts to match an index against the subclauses of an 'or' clause.
+ *
+ * A match means that:
+ * (1) the operator within the subclause can be used with one
+ * of the index's operator classes, and
+ * (2) there is a usable key that matches the variable within a
+ * sargable clause.
+ *
+ * 'or-clauses' are the remaining subclauses within the 'or' clause
+ * 'other-matching-indices' is the list of information on other indices
+ * that have already been matched to subclauses within this
+ * particular 'or' clause (i.e., a list previously generated by
+ * this routine)
+ *
+ * Returns a list of the form ((a b c) (d e f) nil (g h) ...) where
+ * a,b,c are nodes of indices that match the first subclause in
+ * 'or-clauses', d,e,f match the second subclause, no indices
+ * match the third, g,h match the fourth, etc.
+ */
+static List *
+match_index_orclause(Rel *rel,
+ Rel *index,
+ int indexkey,
+ int xclass,
+ List *or_clauses,
+ List *other_matching_indices)
+{
+ Node *clause = NULL;
+ List *matched_indices = other_matching_indices;
+ List *index_list = NIL;
+ List *clist;
+ List *ind;
+
+ if (!matched_indices)
+ matched_indices = lcons(NIL, NIL);
+
+ for (clist = or_clauses, ind = matched_indices;
+ clist;
+ clist = lnext(clist), ind = lnext(ind))
+ {
+ clause = lfirst(clist);
+ if (is_opclause (clause) &&
+ op_class(((Oper*)((Expr*)clause)->oper)->opno,
+ xclass, index->relam) &&
+ match_index_to_operand(indexkey,
+ (Expr*)get_leftop((Expr*)clause),
+ rel,
+ index) &&
+ IsA(get_rightop((Expr*)clause),Const)) {
+
+ matched_indices = lcons(index, matched_indices);
+ index_list = lappend(index_list,
+ matched_indices);
+ }
+ }
+ return(index_list);
+
+}
+
+/****************************************************************************
+ * ---- ROUTINES TO CHECK RESTRICTIONS ----
+ ****************************************************************************/
+
+
+/*
+ * DoneMatchingIndexKeys() - MACRO
+ *
+ * Determine whether we should continue matching index keys in a clause.
+ * Depends on if there are more to match or if this is a functional index.
+ * In the latter case we stop after the first match since the there can
+ * be only key (i.e. the function's return value) and the attributes in
+ * keys list represent the arguments to the function. -mer 3 Oct. 1991
+ */
+#define DoneMatchingIndexKeys(indexkeys, index) \
+ (indexkeys[0] == 0 || \
+ (index->indproc != InvalidOid))
+
+/*
+ * group-clauses-by-indexkey--
+ * Determines whether there are clauses which will match each and every
+ * one of the remaining keys of an index.
+ *
+ * 'rel' is the node of the relation corresponding to the index.
+ * 'indexkeys' are the remaining index keys to be matched.
+ * 'classes' are the classes of the index operators on those keys.
+ * 'clauses' is either:
+ * (1) the list of available restriction clauses on a single
+ * relation, or
+ * (2) a list of join clauses between 'rel' and a fixed set of
+ * relations,
+ * depending on the value of 'join'.
+ * 'startlist' is a list of those clause nodes that have matched the keys
+ * that have already been checked.
+ * 'join' is a flag indicating that the clauses being checked are join
+ * clauses.
+ *
+ * Returns all possible groups of clauses that will match (given that
+ * one or more clauses can match any of the remaining keys).
+ * E.g., if you have clauses A, B, and C, ((A B) (A C)) might be
+ * returned for an index with 2 keys.
+ *
+ */
+static List *
+group_clauses_by_indexkey(Rel *rel,
+ Rel *index,
+ int *indexkeys,
+ Oid *classes,
+ List *clauseinfo_list,
+ bool join)
+{
+ List *curCinfo = NIL;
+ CInfo *matched_clause = (CInfo*)NULL;
+ List *clausegroup = NIL;
+
+
+ if (clauseinfo_list == NIL)
+ return NIL;
+
+ foreach (curCinfo,clauseinfo_list) {
+ CInfo *temp = (CInfo*)lfirst(curCinfo);
+ int *curIndxKey = indexkeys;
+ Oid *curClass = classes;
+
+ do {
+ /*
+ * If we can't find any matching clauses for the first of
+ * the remaining keys, give up.
+ */
+ matched_clause = match_clause_to_indexkey (rel,
+ index,
+ curIndxKey[0],
+ curClass[0],
+ temp,
+ join);
+ if (!matched_clause)
+ break;
+
+ clausegroup = lcons(matched_clause, clausegroup);
+ curIndxKey++;
+ curClass++;
+
+ } while ( !DoneMatchingIndexKeys(curIndxKey, index) );
+ }
+
+ if (clausegroup != NIL)
+ return(lcons(clausegroup, NIL));
+ return NIL;
+}
+
+/*
+ * IndexScanableClause () MACRO
+ *
+ * Generalize condition on which we match a clause with an index.
+ * Now we can match with functional indices.
+ */
+#define IndexScanableOperand(opnd, indkeys, rel, index) \
+ ((index->indproc == InvalidOid) ? \
+ equal_indexkey_var(indkeys,opnd) : \
+ function_index_operand((Expr*)opnd,rel,index))
+
+/*
+ * match_clause_to-indexkey--
+ * Finds the first of a relation's available restriction clauses that
+ * matches a key of an index.
+ *
+ * To match, the clause must:
+ * (1) be in the form (op var const) if the clause is a single-
+ * relation clause, and
+ * (2) contain an operator which is in the same class as the index
+ * operator for this key.
+ *
+ * If the clause being matched is a join clause, then 'join' is t.
+ *
+ * Returns a single clauseinfo node corresponding to the matching
+ * clause.
+ *
+ * NOTE: returns nil if clause is an or_clause.
+ *
+ */
+static CInfo *
+match_clause_to_indexkey(Rel *rel,
+ Rel *index,
+ int indexkey,
+ int xclass,
+ CInfo *clauseInfo,
+ bool join)
+{
+ Expr *clause = clauseInfo->clause;
+ Var *leftop, *rightop;
+ Oid join_op = InvalidOid;
+ bool isIndexable = false;
+
+ if (or_clause((Node*)clause) ||
+ not_clause((Node*)clause) || single_node((Node*)clause))
+ return ((CInfo*)NULL);
+
+ leftop = get_leftop(clause);
+ rightop = get_rightop(clause);
+ /*
+ * If this is not a join clause, check for clauses of the form:
+ * (operator var/func constant) and (operator constant var/func)
+ */
+ if (!join)
+ {
+ Oid restrict_op = InvalidOid;
+
+ /*
+ * Check for standard s-argable clause
+ */
+ if (IsA(rightop,Const))
+ {
+ restrict_op = ((Oper*)((Expr*)clause)->oper)->opno;
+ isIndexable =
+ ( op_class(restrict_op, xclass, index->relam) &&
+ IndexScanableOperand(leftop,
+ indexkey,
+ rel,
+ index) );
+ }
+
+ /*
+ * Must try to commute the clause to standard s-arg format.
+ */
+ else if (IsA(leftop,Const))
+ {
+ restrict_op =
+ get_commutator(((Oper*)((Expr*)clause)->oper)->opno);
+
+ if ( (restrict_op != InvalidOid) &&
+ op_class(restrict_op, xclass, index->relam) &&
+ IndexScanableOperand(rightop,
+ indexkey,rel,index) )
+ {
+ isIndexable = true;
+ /*
+ * In place list modification.
+ * (op const var/func) -> (op var/func const)
+ */
+ /* BUG! Old version:
+ CommuteClause(clause, restrict_op);
+ */
+ CommuteClause((Node*)clause);
+ }
+ }
+ }
+ /*
+ * Check for an indexable scan on one of the join relations.
+ * clause is of the form (operator var/func var/func)
+ */
+ else
+ {
+ if (match_index_to_operand(indexkey,(Expr*)rightop,rel,index)) {
+
+ join_op = get_commutator(((Oper*)((Expr*)clause)->oper)->opno);
+
+ } else if (match_index_to_operand(indexkey,
+ (Expr*)leftop,rel,index)) {
+ join_op = ((Oper*)((Expr*)clause)->oper)->opno;
+ }
+
+ if ( join_op && op_class(join_op,xclass,index->relam) &&
+ join_clause_p((Node*)clause))
+ {
+ isIndexable = true;
+
+ /*
+ * If we're using the operand's commutator we must
+ * commute the clause.
+ */
+ if (join_op != ((Oper*)((Expr*)clause)->oper)->opno)
+ CommuteClause((Node*)clause);
+ }
+ }
+
+ if (isIndexable)
+ return(clauseInfo);
+
+ return(NULL);
+}
+
+/****************************************************************************
+ * ---- ROUTINES TO DO PARTIAL INDEX PREDICATE TESTS ----
+ ****************************************************************************/
+
+/*
+ * pred_test--
+ * Does the "predicate inclusion test" for partial indexes.
+ *
+ * Recursively checks whether the clauses in clauseinfo_list imply
+ * that the given predicate is true.
+ *
+ * This routine (together with the routines it calls) iterates over
+ * ANDs in the predicate first, then reduces the qualification
+ * clauses down to their constituent terms, and iterates over ORs
+ * in the predicate last. This order is important to make the test
+ * succeed whenever possible (assuming the predicate has been
+ * successfully cnfify()-ed). --Nels, Jan '93
+ */
+static bool
+pred_test(List *predicate_list, List *clauseinfo_list, List *joininfo_list)
+{
+ List *pred, *items, *item;
+
+ /*
+ * Note: if Postgres tried to optimize queries by forming equivalence
+ * classes over equi-joined attributes (i.e., if it recognized that a
+ * qualification such as "where a.b=c.d and a.b=5" could make use of
+ * an index on c.d), then we could use that equivalence class info
+ * here with joininfo_list to do more complete tests for the usability
+ * of a partial index. For now, the test only uses restriction
+ * clauses (those in clauseinfo_list). --Nels, Dec '92
+ */
+
+ if (predicate_list == NULL)
+ return true; /* no predicate: the index is usable */
+ if (clauseinfo_list == NULL)
+ return false; /* no restriction clauses: the test must fail */
+
+ foreach (pred, predicate_list) {
+ /* if any clause is not implied, the whole predicate is not implied */
+ if (and_clause(lfirst(pred))) {
+ items = ((Expr*)lfirst(pred))->args;
+ foreach (item, items) {
+ if (!one_pred_test(lfirst(item), clauseinfo_list))
+ return false;
+ }
+ }
+ else if (!one_pred_test(lfirst(pred), clauseinfo_list))
+ return false;
+ }
+ return true;
+}
+
+
+/*
+ * one_pred_test--
+ * Does the "predicate inclusion test" for one conjunct of a predicate
+ * expression.
+ */
+static bool
+one_pred_test(Expr *predicate, List *clauseinfo_list)
+{
+ CInfo *clauseinfo;
+ List *item;
+
+ Assert(predicate != NULL);
+ foreach (item, clauseinfo_list) {
+ clauseinfo = (CInfo *)lfirst(item);
+ /* if any clause implies the predicate, return true */
+ if (one_pred_clause_expr_test(predicate, (Node*)clauseinfo->clause))
+ return true;
+ }
+ return false;
+}
+
+
+/*
+ * one_pred_clause_expr_test--
+ * Does the "predicate inclusion test" for a general restriction-clause
+ * expression.
+ */
+static bool
+one_pred_clause_expr_test(Expr *predicate, Node *clause)
+{
+ List *items, *item;
+
+ if (is_opclause(clause))
+ return one_pred_clause_test(predicate, clause);
+ else if (or_clause(clause)) {
+ items = ((Expr*)clause)->args;
+ foreach (item, items) {
+ /* if any OR item doesn't imply the predicate, clause doesn't */
+ if (!one_pred_clause_expr_test(predicate, lfirst(item)))
+ return false;
+ }
+ return true;
+ }else if (and_clause(clause)) {
+ items = ((Expr*)clause)->args;
+ foreach (item, items) {
+ /* if any AND item implies the predicate, the whole clause does */
+ if (one_pred_clause_expr_test(predicate, lfirst(item)))
+ return true;
+ }
+ return false;
+ }else {
+ /* unknown clause type never implies the predicate */
+ return false;
+ }
+}
+
+
+/*
+ * one_pred_clause_test--
+ * Does the "predicate inclusion test" for one conjunct of a predicate
+ * expression for a simple restriction clause.
+ */
+static bool
+one_pred_clause_test(Expr *predicate, Node *clause)
+{
+ List *items, *item;
+
+ if (is_opclause((Node*)predicate))
+ return clause_pred_clause_test(predicate, clause);
+ else if (or_clause((Node*)predicate)) {
+ items = predicate->args;
+ foreach (item, items) {
+ /* if any item is implied, the whole predicate is implied */
+ if (one_pred_clause_test(lfirst(item), clause))
+ return true;
+ }
+ return false;
+ }else if (and_clause((Node*)predicate)) {
+ items = predicate->args;
+ foreach (item, items) {
+ /*
+ * if any item is not implied, the whole predicate is not
+ * implied
+ */
+ if (!one_pred_clause_test(lfirst(item), clause))
+ return false;
+ }
+ return true;
+ }
+ else {
+ elog(DEBUG, "Unsupported predicate type, index will not be used");
+ return false;
+ }
+}
+
+
+/*
+ * Define an "operator implication table" for btree operators ("strategies").
+ * The "strategy numbers" are: (1) < (2) <= (3) = (4) >= (5) >
+ *
+ * The interpretation of:
+ *
+ * test_op = BT_implic_table[given_op-1][target_op-1]
+ *
+ * where test_op, given_op and target_op are strategy numbers (from 1 to 5)
+ * of btree operators, is as follows:
+ *
+ * If you know, for some ATTR, that "ATTR given_op CONST1" is true, and you
+ * want to determine whether "ATTR target_op CONST2" must also be true, then
+ * you can use "CONST1 test_op CONST2" as a test. If this test returns true,
+ * then the target expression must be true; if the test returns false, then
+ * the target expression may be false.
+ *
+ * An entry where test_op==0 means the implication cannot be determined, i.e.,
+ * this test should always be considered false.
+ */
+
+StrategyNumber BT_implic_table[BTMaxStrategyNumber][BTMaxStrategyNumber] = {
+ {2, 2, 0, 0, 0},
+ {1, 2, 0, 0, 0},
+ {1, 2, 3, 4, 5},
+ {0, 0, 0, 4, 5},
+ {0, 0, 0, 4, 4}
+};
+
+
+/*
+ * clause_pred_clause_test--
+ * Use operator class info to check whether clause implies predicate.
+ *
+ * Does the "predicate inclusion test" for a "simple clause" predicate
+ * for a single "simple clause" restriction. Currently, this only handles
+ * (binary boolean) operators that are in some btree operator class.
+ * Eventually, rtree operators could also be handled by defining an
+ * appropriate "RT_implic_table" array.
+ */
+static bool
+clause_pred_clause_test(Expr *predicate, Node *clause)
+{
+ Var *pred_var, *clause_var;
+ Const *pred_const, *clause_const;
+ Oid pred_op, clause_op, test_op;
+ Oid opclass_id;
+ StrategyNumber pred_strategy, clause_strategy, test_strategy;
+ Oper *test_oper;
+ Expr *test_expr;
+ bool test_result, isNull;
+ Relation relation;
+ HeapScanDesc scan;
+ HeapTuple tuple;
+ ScanKeyData entry[3];
+ Form_pg_amop form;
+
+ pred_var = (Var*)get_leftop(predicate);
+ pred_const = (Const*)get_rightop(predicate);
+ clause_var = (Var*)get_leftop((Expr*)clause);
+ clause_const = (Const*)get_rightop((Expr*)clause);
+
+ /* Check the basic form; for now, only allow the simplest case */
+ if (!is_opclause(clause) ||
+ !IsA(clause_var,Var) ||
+ !IsA(clause_const,Const) ||
+ !IsA(predicate->oper,Oper) ||
+ !IsA(pred_var,Var) ||
+ !IsA(pred_const,Const)) {
+ return false;
+ }
+
+ /*
+ * The implication can't be determined unless the predicate and the clause
+ * refer to the same attribute.
+ */
+ if (clause_var->varattno != pred_var->varattno)
+ return false;
+
+ /* Get the operators for the two clauses we're comparing */
+ pred_op = ((Oper*)((Expr*)predicate)->oper)->opno;
+ clause_op = ((Oper*)((Expr*)clause)->oper)->opno;
+
+
+ /*
+ * 1. Find a "btree" strategy number for the pred_op
+ */
+ /* XXX - hardcoded amopid value 403 to find "btree" operator classes */
+ ScanKeyEntryInitialize(&entry[0], 0,
+ Anum_pg_amop_amopid,
+ ObjectIdEqualRegProcedure,
+ ObjectIdGetDatum(403));
+
+ ScanKeyEntryInitialize(&entry[1], 0,
+ Anum_pg_amop_amopopr,
+ ObjectIdEqualRegProcedure,
+ ObjectIdGetDatum(pred_op));
+
+ relation = heap_openr(AccessMethodOperatorRelationName);
+
+ /*
+ * The following assumes that any given operator will only be in a single
+ * btree operator class. This is true at least for all the pre-defined
+ * operator classes. If it isn't true, then whichever operator class
+ * happens to be returned first for the given operator will be used to
+ * find the associated strategy numbers for the test. --Nels, Jan '93
+ */
+ scan = heap_beginscan(relation, false, NowTimeQual, 2, entry);
+ tuple = heap_getnext(scan, false, (Buffer *)NULL);
+ if (! HeapTupleIsValid(tuple)) {
+ elog(DEBUG, "clause_pred_clause_test: unknown pred_op");
+ return false;
+ }
+ form = (Form_pg_amop) GETSTRUCT(tuple);
+
+ /* Get the predicate operator's strategy number (1 to 5) */
+ pred_strategy = (StrategyNumber)form->amopstrategy;
+
+ /* Remember which operator class this strategy number came from */
+ opclass_id = form->amopclaid;
+
+ heap_endscan(scan);
+
+
+ /*
+ * 2. From the same opclass, find a strategy num for the clause_op
+ */
+ ScanKeyEntryInitialize(&entry[1], 0,
+ Anum_pg_amop_amopclaid,
+ ObjectIdEqualRegProcedure,
+ ObjectIdGetDatum(opclass_id));
+
+ ScanKeyEntryInitialize(&entry[2], 0,
+ Anum_pg_amop_amopopr,
+ ObjectIdEqualRegProcedure,
+ ObjectIdGetDatum(clause_op));
+
+ scan = heap_beginscan(relation, false, NowTimeQual, 3, entry);
+ tuple = heap_getnext(scan, false, (Buffer *)NULL);
+ if (! HeapTupleIsValid(tuple)) {
+ elog(DEBUG, "clause_pred_clause_test: unknown clause_op");
+ return false;
+ }
+ form = (Form_pg_amop) GETSTRUCT(tuple);
+
+ /* Get the restriction clause operator's strategy number (1 to 5) */
+ clause_strategy = (StrategyNumber)form->amopstrategy;
+ heap_endscan(scan);
+
+
+ /*
+ * 3. Look up the "test" strategy number in the implication table
+ */
+
+ test_strategy = BT_implic_table[clause_strategy-1][pred_strategy-1];
+ if (test_strategy == 0)
+ return false; /* the implication cannot be determined */
+
+
+ /*
+ * 4. From the same opclass, find the operator for the test strategy
+ */
+
+ ScanKeyEntryInitialize(&entry[2], 0,
+ Anum_pg_amop_amopstrategy,
+ Integer16EqualRegProcedure,
+ Int16GetDatum(test_strategy));
+
+ scan = heap_beginscan(relation, false, NowTimeQual, 3, entry);
+ tuple = heap_getnext(scan, false, (Buffer *)NULL);
+ if (! HeapTupleIsValid(tuple)) {
+ elog(DEBUG, "clause_pred_clause_test: unknown test_op");
+ return false;
+ }
+ form = (Form_pg_amop) GETSTRUCT(tuple);
+
+ /* Get the test operator */
+ test_op = form->amopopr;
+ heap_endscan(scan);
+
+
+ /*
+ * 5. Evaluate the test
+ */
+ test_oper = makeOper(test_op, /* opno */
+ InvalidOid, /* opid */
+ BOOL_TYPEID, /* opresulttype */
+ 0, /* opsize */
+ NULL); /* op_fcache */
+ (void) replace_opid(test_oper);
+
+ test_expr = make_opclause(test_oper,
+ copyObject(clause_const),
+ copyObject(pred_const));
+
+#ifndef OMIT_PARTIAL_INDEX
+ test_result = ExecEvalExpr((Node*)test_expr, NULL, &isNull, NULL);
+#endif /* OMIT_PARTIAL_INDEX */
+ if (isNull) {
+ elog(DEBUG, "clause_pred_clause_test: null test result");
+ return false;
+ }
+ return test_result;
+}
+
+
+/****************************************************************************
+ * ---- ROUTINES TO CHECK JOIN CLAUSES ----
+ ****************************************************************************/
+
+/*
+ * indexable-joinclauses--
+ * Finds all groups of join clauses from among 'joininfo-list' that can
+ * be used in conjunction with 'index'.
+ *
+ * The first clause in the group is marked as having the other relation
+ * in the join clause as its outer join relation.
+ *
+ * Returns a list of these clause groups.
+ *
+ */
+static List *
+indexable_joinclauses(Rel *rel, Rel *index, List *joininfo_list)
+{
+ JInfo *joininfo = (JInfo*)NULL;
+ List *cg_list = NIL;
+ List *i = NIL;
+ List *clausegroups = NIL;
+
+ foreach(i,joininfo_list) {
+ joininfo = (JInfo*)lfirst(i);
+ clausegroups =
+ group_clauses_by_indexkey (rel,
+ index,
+ index->indexkeys,
+ index->classlist,
+ joininfo->jinfoclauseinfo,
+ true);
+
+ if (clausegroups != NIL) {
+ List *clauses = lfirst(clausegroups);
+
+ ((CInfo*)lfirst(clauses))->cinfojoinid =
+ joininfo->otherrels;
+ }
+ cg_list = nconc(cg_list,clausegroups);
+ }
+ return(cg_list);
+}
+
+/****************************************************************************
+ * ---- PATH CREATION UTILITIES ----
+ ****************************************************************************/
+
+/*
+ * extract_restrict_clauses -
+ * the list of clause info contains join clauses and restriction clauses.
+ * This routine returns the restriction clauses only.
+ */
+static List *
+extract_restrict_clauses(List *clausegroup)
+{
+ List *restrict_cls = NIL;
+ List *l;
+
+ foreach (l, clausegroup) {
+ CInfo *cinfo = lfirst(l);
+
+ if (!join_clause_p((Node*)cinfo->clause)) {
+ restrict_cls = lappend(restrict_cls, cinfo);
+ }
+ }
+ return restrict_cls;
+}
+
+/*
+ * index-innerjoin--
+ * Creates index path nodes corresponding to paths to be used as inner
+ * relations in nestloop joins.
+ *
+ * 'clausegroup-list' is a list of list of clauseinfo nodes which can use
+ * 'index' on their inner relation.
+ *
+ * Returns a list of index pathnodes.
+ *
+ */
+static List *
+index_innerjoin(Query *root, Rel *rel, List *clausegroup_list, Rel *index)
+{
+ List *clausegroup = NIL;
+ List *cg_list = NIL;
+ List *i = NIL;
+ IndexPath *pathnode = (IndexPath*)NULL;
+ Cost temp_selec;
+ float temp_pages;
+
+ foreach(i,clausegroup_list) {
+ List *attnos, *values, *flags;
+
+ clausegroup = lfirst(i);
+ pathnode = makeNode(IndexPath);
+
+ get_joinvars(lfirsti(rel->relids),clausegroup,
+ &attnos, &values, &flags);
+ index_selectivity(lfirsti(index->relids),
+ index->classlist,
+ get_opnos(clausegroup),
+ getrelid((int)lfirst(rel->relids),
+ root->rtable),
+ attnos,
+ values,
+ flags,
+ length(clausegroup),
+ &temp_pages,
+ &temp_selec);
+ pathnode->path.pathtype = T_IndexScan;
+ pathnode->path.parent = rel;
+ pathnode->indexid = index->relids;
+ pathnode->indexqual = clausegroup;
+
+ pathnode->path.joinid = ((CInfo*)lfirst(clausegroup))->cinfojoinid;
+
+ pathnode->path.path_cost =
+ cost_index((Oid)lfirst(index->relids),
+ (int)temp_pages,
+ temp_selec,
+ rel->pages,
+ rel->tuples,
+ index->pages,
+ index->tuples,
+ true);
+
+ /* copy clauseinfo list into path for expensive function processing
+ -- JMH, 7/7/92 */
+ pathnode->path.locclauseinfo =
+ set_difference(copyObject((Node*)rel->clauseinfo),
+ clausegroup);
+
+#if 0 /* fix xfunc */
+ /* add in cost for expensive functions! -- JMH, 7/7/92 */
+ if (XfuncMode != XFUNC_OFF) {
+ ((Path*)pathnode)->path_cost +=
+ xfunc_get_path_cost((Path*)pathnode);
+ }
+#endif
+ cg_list = lappend(cg_list,pathnode);
+ }
+ return(cg_list);
+}
+
+/*
+ * create-index-paths--
+ * Creates a list of index path nodes for each group of clauses
+ * (restriction or join) that can be used in conjunction with an index.
+ *
+ * 'rel' is the relation for which 'index' is defined
+ * 'clausegroup-list' is the list of clause groups (lists of clauseinfo
+ * nodes) grouped by mergesortorder
+ * 'join' is a flag indicating whether or not the clauses are join
+ * clauses
+ *
+ * Returns a list of new index path nodes.
+ *
+ */
+static List *
+create_index_paths(Query *root,
+ Rel *rel,
+ Rel *index,
+ List *clausegroup_list,
+ bool join)
+{
+ List *clausegroup = NIL;
+ List *ip_list = NIL;
+ List *i = NIL;
+ List *j = NIL;
+ IndexPath *temp_path;
+
+ foreach(i, clausegroup_list) {
+ CInfo *clauseinfo;
+ List *temp_node = NIL;
+ bool temp = true;
+
+ clausegroup = lfirst(i);
+
+ foreach (j,clausegroup) {
+ clauseinfo = (CInfo*)lfirst(j);
+ if (!(join_clause_p((Node*)clauseinfo->clause) &&
+ equal_path_merge_ordering(index->ordering,
+ clauseinfo->mergesortorder))) {
+ temp = false;
+ }
+ }
+
+ if (!join || temp) { /* restriction, ordering scan */
+ temp_path = create_index_path (root, rel,index,clausegroup,join);
+ temp_node =
+ lcons(temp_path, NIL);
+ ip_list = nconc(ip_list,temp_node);
+ }
+ }
+ return(ip_list);
+}
+
+static List *
+add_index_paths(List *indexpaths, List *new_indexpaths)
+{
+ return append(indexpaths, new_indexpaths);
+}
+
+static bool
+function_index_operand(Expr *funcOpnd, Rel *rel, Rel *index)
+{
+ Oid heapRelid = (Oid)lfirst(rel->relids);
+ Func *function;
+ List *funcargs;
+ int *indexKeys = index->indexkeys;
+ List *arg;
+ int i;
+
+ /*
+ * sanity check, make sure we know what we're dealing with here.
+ */
+ if (funcOpnd==NULL ||
+ nodeTag(funcOpnd)!=T_Expr || funcOpnd->opType!=FUNC_EXPR ||
+ funcOpnd->oper==NULL || indexKeys==NULL)
+ return false;
+
+ function = (Func*)funcOpnd->oper;
+ funcargs = funcOpnd->args;
+
+ if (function->funcid != index->indproc)
+ return false;
+
+ /*
+ * Check that the arguments correspond to the same arguments used
+ * to create the functional index. To do this we must check that
+ * 1. refer to the right relatiion.
+ * 2. the args have the right attr. numbers in the right order.
+ *
+ *
+ * Check all args refer to the correct relation (i.e. the one with
+ * the functional index defined on it (rel). To do this we can
+ * simply compare range table entry numbers, they must be the same.
+ */
+ foreach (arg, funcargs) {
+ if (heapRelid != ((Var*)lfirst(arg))->varno)
+ return false;
+ }
+
+ /*
+ * check attr numbers and order.
+ */
+ i = 0;
+ foreach (arg, funcargs) {
+
+ if (indexKeys[i]==0)
+ return (false);
+
+ if (((Var*)lfirst(arg))->varattno != indexKeys[i])
+ return (false);
+
+ i++;
+ }
+
+ return true;
+}
+
+static bool
+SingleAttributeIndex(Rel *index)
+{
+ /*
+ * return false for now as I don't know if we support index scans
+ * on disjunction and the code doesn't work
+ */
+ return (false);
+
+#if 0
+ /*
+ * Non-functional indices.
+ */
+ if (index->indproc == InvalidOid)
+ return (index->indexkeys[0] != 0 &&
+ index->indexkeys[1] == 0);
+
+ /*
+ * We have a functional index which is a single attr index
+ */
+ return true;
+#endif
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * joinpath.c--
+ * Routines to find all possible paths for processing a set of joins
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.1.1.1 1996/07/09 06:21:35 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+
+#include "storage/buf_internals.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/relation.h"
+#include "nodes/plannodes.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/paths.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/keys.h"
+#include "optimizer/cost.h" /* for _enable_{hashjoin, _enable_mergesort} */
+
+static Path *best_innerjoin(List *join_paths, List *outer_relid);
+static List *sort_inner_and_outer(Rel *joinrel, Rel *outerrel, Rel *innerrel,
+ List *mergeinfo_list);
+static List *match_unsorted_outer(Rel *joinrel, Rel *outerrel, Rel *innerrel,
+ List *outerpath_list, Path *cheapest_inner, Path *best_innerjoin,
+ List *mergeinfo_list);
+static List *match_unsorted_inner(Rel *joinrel, Rel *outerrel, Rel *innerrel,
+ List *innerpath_list, List *mergeinfo_list);
+static bool EnoughMemoryForHashjoin(Rel *hashrel);
+static List *hash_inner_and_outer(Rel *joinrel, Rel *outerrel, Rel *innerrel,
+ List *hashinfo_list);
+
+/*
+ * find-all-join-paths--
+ * Creates all possible ways to process joins for each of the join
+ * relations in the list 'joinrels.' Each unique path will be included
+ * in the join relation's 'pathlist' field.
+ *
+ * In postgres, n-way joins are handled left-only(permuting clauseless
+ * joins doesn't usually win much).
+ *
+ * if BushyPlanFlag is true, bushy tree plans will be generated
+ *
+ * 'joinrels' is the list of relation entries to be joined
+ *
+ * Modifies the pathlist field of the appropriate rel node to contain
+ * the unique join paths.
+ * If bushy trees are considered, may modify the relid field of the
+ * join rel nodes to flatten the lists.
+ *
+ * Returns nothing of interest. (?)
+ * It does a destructive modification.
+ */
+void
+find_all_join_paths(Query *root, List *joinrels)
+{
+ List *mergeinfo_list = NIL;
+ List *hashinfo_list = NIL;
+ List *temp_list = NIL;
+ List *path = NIL;
+
+ while (joinrels != NIL) {
+ Rel *joinrel = (Rel *)lfirst(joinrels);
+ List *innerrelids;
+ List *outerrelids;
+ Rel *innerrel;
+ Rel *outerrel;
+ Path *bestinnerjoin;
+ List *pathlist = NIL;
+
+ innerrelids = lsecond(joinrel->relids);
+ outerrelids = lfirst(joinrel->relids);
+
+ /*
+ * base relation id is an integer and join relation relid is a
+ * list of integers.
+ */
+ innerrel = (length(innerrelids)==1)?
+ get_base_rel(root, lfirsti(innerrelids)) : get_join_rel(root,innerrelids);
+ outerrel = (length(outerrelids)==1)?
+ get_base_rel(root, lfirsti(outerrelids)) : get_join_rel(root, outerrelids);
+
+ bestinnerjoin = best_innerjoin(innerrel->innerjoin,
+ outerrel->relids);
+ if( _enable_mergesort_ ) {
+ mergeinfo_list =
+ group_clauses_by_order(joinrel->clauseinfo,
+ lfirsti(innerrel->relids));
+ }
+
+ if( _enable_hashjoin_ ) {
+ hashinfo_list =
+ group_clauses_by_hashop(joinrel->clauseinfo,
+ lfirsti(innerrel->relids));
+ }
+
+ /* need to flatten the relids list */
+ joinrel->relids = intAppend(outerrelids, innerrelids);
+
+ /*
+ * 1. Consider mergesort paths where both relations must be
+ * explicitly sorted.
+ */
+ pathlist = sort_inner_and_outer(joinrel,outerrel,
+ innerrel,mergeinfo_list);
+
+ /*
+ * 2. Consider paths where the outer relation need not be explicitly
+ * sorted. This may include either nestloops and mergesorts where
+ * the outer path is already ordered.
+ */
+ pathlist =
+ add_pathlist(joinrel, pathlist,
+ match_unsorted_outer(joinrel,
+ outerrel,
+ innerrel,
+ outerrel->pathlist,
+ (Path*)innerrel->cheapestpath,
+ bestinnerjoin,
+ mergeinfo_list));
+
+ /*
+ * 3. Consider paths where the inner relation need not be explicitly
+ * sorted. This may include nestloops and mergesorts the actual
+ * nestloop nodes were constructed in (match-unsorted-outer).
+ */
+ pathlist =
+ add_pathlist(joinrel,pathlist,
+ match_unsorted_inner(joinrel,outerrel,
+ innerrel,
+ innerrel->pathlist,
+ mergeinfo_list));
+
+ /*
+ * 4. Consider paths where both outer and inner relations must be
+ * hashed before being joined.
+ */
+
+ pathlist =
+ add_pathlist(joinrel, pathlist,
+ hash_inner_and_outer(joinrel,outerrel,
+ innerrel,hashinfo_list));
+
+ joinrel->pathlist = pathlist;
+
+ /*
+ * 'OuterJoinCost is only valid when calling (match-unsorted-inner)
+ * with the same arguments as the previous invokation of
+ * (match-unsorted-outer), so clear the field before going on.
+ */
+ temp_list = innerrel->pathlist;
+ foreach(path, temp_list) {
+
+ /*
+ * XXX
+ *
+ * This gross hack is to get around an apparent optimizer bug on
+ * Sparc (or maybe it is a bug of ours?) that causes really wierd
+ * behavior.
+ */
+ if (IsA_JoinPath(path)) {
+ ((Path*)lfirst(path))->outerjoincost = (Cost) 0;
+ }
+
+ /* do it iff it is a join path, which is not always
+ true, esp since the base level */
+ }
+
+ joinrels = lnext(joinrels);
+ }
+}
+
+/*
+ * best-innerjoin--
+ * Find the cheapest index path that has already been identified by
+ * (indexable_joinclauses) as being a possible inner path for the given
+ * outer relation in a nestloop join.
+ *
+ * 'join-paths' is a list of join nodes
+ * 'outer-relid' is the relid of the outer join relation
+ *
+ * Returns the pathnode of the selected path.
+ */
+static Path *
+best_innerjoin(List *join_paths, List *outer_relids)
+{
+ Path *cheapest = (Path*)NULL;
+ List *join_path;
+
+ foreach(join_path, join_paths) {
+ Path *path = (Path *)lfirst(join_path);
+
+ if (intMember(lfirsti(path->joinid), outer_relids)
+ && ((cheapest==NULL ||
+ path_is_cheaper((Path*)lfirst(join_path),cheapest)))) {
+
+ cheapest = (Path*)lfirst(join_path);
+ }
+ }
+ return(cheapest);
+}
+
+/*
+ * sort-inner-and-outer--
+ * Create mergesort join paths by explicitly sorting both the outer and
+ * inner join relations on each available merge ordering.
+ *
+ * 'joinrel' is the join relation
+ * 'outerrel' is the outer join relation
+ * 'innerrel' is the inner join relation
+ * 'mergeinfo-list' is a list of nodes containing info on(mergesortable)
+ * clauses for joining the relations
+ *
+ * Returns a list of mergesort paths.
+ */
+static List *
+sort_inner_and_outer(Rel *joinrel,
+ Rel *outerrel,
+ Rel *innerrel,
+ List *mergeinfo_list)
+{
+ List *ms_list = NIL;
+ MInfo *xmergeinfo = (MInfo*)NULL;
+ MergePath *temp_node = (MergePath*)NULL;
+ List *i;
+ List *outerkeys = NIL;
+ List *innerkeys = NIL;
+ List *merge_pathkeys = NIL;
+
+ foreach(i, mergeinfo_list) {
+ xmergeinfo = (MInfo *)lfirst(i);
+
+ outerkeys =
+ extract_path_keys(xmergeinfo->jmethod.jmkeys,
+ outerrel->targetlist,
+ OUTER);
+
+ innerkeys =
+ extract_path_keys(xmergeinfo->jmethod.jmkeys,
+ innerrel->targetlist,
+ INNER);
+
+ merge_pathkeys =
+ new_join_pathkeys(outerkeys, joinrel->targetlist,
+ xmergeinfo->jmethod.clauses);
+
+ temp_node =
+ create_mergesort_path(joinrel,
+ outerrel->size,
+ innerrel->size,
+ outerrel->width,
+ innerrel->width,
+ (Path*)outerrel->cheapestpath,
+ (Path*)innerrel->cheapestpath,
+ merge_pathkeys,
+ xmergeinfo->m_ordering,
+ xmergeinfo->jmethod.clauses,
+ outerkeys,
+ innerkeys);
+
+ ms_list = lappend(ms_list, temp_node);
+ }
+ return(ms_list);
+}
+
+/*
+ * match-unsorted-outer--
+ * Creates possible join paths for processing a single join relation
+ * 'joinrel' by employing either iterative substitution or
+ * mergesorting on each of its possible outer paths(assuming that the
+ * outer relation need not be explicitly sorted).
+ *
+ * 1. The inner path is the cheapest available inner path.
+ * 2. Mergesort wherever possible. Mergesorts are considered if there
+ * are mergesortable join clauses between the outer and inner join
+ * relations such that the outer path is keyed on the variables
+ * appearing in the clauses. The corresponding inner merge path is
+ * either a path whose keys match those of the outer path(if such a
+ * path is available) or an explicit sort on the appropriate inner
+ * join keys, whichever is cheaper.
+ *
+ * 'joinrel' is the join relation
+ * 'outerrel' is the outer join relation
+ * 'innerrel' is the inner join relation
+ * 'outerpath-list' is the list of possible outer paths
+ * 'cheapest-inner' is the cheapest inner path
+ * 'best-innerjoin' is the best inner index path(if any)
+ * 'mergeinfo-list' is a list of nodes containing info on mergesortable
+ * clauses
+ *
+ * Returns a list of possible join path nodes.
+ */
+static List *
+match_unsorted_outer(Rel *joinrel,
+ Rel *outerrel,
+ Rel *innerrel,
+ List *outerpath_list,
+ Path *cheapest_inner,
+ Path *best_innerjoin,
+ List *mergeinfo_list)
+{
+ Path *outerpath = (Path*)NULL;
+ List *jp_list = NIL;
+ List *temp_node = NIL;
+ List *merge_pathkeys = NIL;
+ Path *nestinnerpath =(Path*)NULL;
+ List *paths = NIL;
+ List *i = NIL;
+ PathOrder *outerpath_ordering = NULL;
+
+ foreach(i,outerpath_list) {
+ List *clauses = NIL;
+ List *matchedJoinKeys = NIL;
+ List *matchedJoinClauses = NIL;
+ MInfo *xmergeinfo = (MInfo*)NULL;
+
+ outerpath = (Path*)lfirst(i);
+
+ outerpath_ordering = &outerpath->p_ordering;
+
+ if (outerpath_ordering) {
+ xmergeinfo =
+ match_order_mergeinfo(outerpath_ordering,
+ mergeinfo_list);
+ }
+
+ if (xmergeinfo) {
+ clauses = xmergeinfo->jmethod.clauses;
+ }
+
+ if (clauses) {
+ List *keys = xmergeinfo->jmethod.jmkeys;
+ List *clauses = xmergeinfo->jmethod.clauses;
+
+ matchedJoinKeys =
+ match_pathkeys_joinkeys(outerpath->keys,
+ keys,
+ clauses,
+ OUTER,
+ &matchedJoinClauses);
+ merge_pathkeys =
+ new_join_pathkeys(outerpath->keys,
+ joinrel->targetlist, clauses);
+ } else {
+ merge_pathkeys = outerpath->keys;
+ }
+
+ if(best_innerjoin &&
+ path_is_cheaper(best_innerjoin, cheapest_inner)) {
+ nestinnerpath = best_innerjoin;
+ } else {
+ nestinnerpath = cheapest_inner;
+ }
+
+ paths = lcons(create_nestloop_path(joinrel,
+ outerrel,
+ outerpath,
+ nestinnerpath,
+ merge_pathkeys),
+ NIL);
+
+ if (clauses && matchedJoinKeys) {
+ bool path_is_cheaper_than_sort;
+ List *varkeys = NIL;
+ Path *mergeinnerpath =
+ match_paths_joinkeys(matchedJoinKeys,
+ outerpath_ordering,
+ innerrel->pathlist,
+ INNER);
+
+ path_is_cheaper_than_sort =
+ (bool) (mergeinnerpath &&
+ (mergeinnerpath->path_cost <
+ (cheapest_inner->path_cost +
+ cost_sort(matchedJoinKeys,
+ innerrel->size,
+ innerrel->width,
+ false))));
+ if(!path_is_cheaper_than_sort) {
+ varkeys =
+ extract_path_keys(matchedJoinKeys,
+ innerrel->targetlist,
+ INNER);
+ }
+
+
+ /*
+ * Keep track of the cost of the outer path used with
+ * this ordered inner path for later processing in
+ * (match-unsorted-inner), since it isn't a sort and
+ * thus wouldn't otherwise be considered.
+ */
+ if (path_is_cheaper_than_sort) {
+ mergeinnerpath->outerjoincost = outerpath->path_cost;
+ } else {
+ mergeinnerpath = cheapest_inner;
+ }
+
+ temp_node =
+ lcons(create_mergesort_path(joinrel,
+ outerrel->size,
+ innerrel->size,
+ outerrel->width,
+ innerrel->width,
+ outerpath,
+ mergeinnerpath,
+ merge_pathkeys,
+ xmergeinfo->m_ordering,
+ matchedJoinClauses,
+ NIL,
+ varkeys),
+ paths);
+ } else {
+ temp_node = paths;
+ }
+ jp_list = nconc(jp_list, temp_node);
+ }
+ return(jp_list);
+}
+
+/*
+ * match-unsorted-inner --
+ * Find the cheapest ordered join path for a given(ordered, unsorted)
+ * inner join path.
+ *
+ * Scans through each path available on an inner join relation and tries
+ * matching its ordering keys against those of mergejoin clauses.
+ * If 1. an appropriately-ordered inner path and matching mergeclause are
+ * found, and
+ * 2. sorting the cheapest outer path is cheaper than using an ordered
+ * but unsorted outer path(as was considered in
+ * (match-unsorted-outer)),
+ * then this merge path is considered.
+ *
+ * 'joinrel' is the join result relation
+ * 'outerrel' is the outer join relation
+ * 'innerrel' is the inner join relation
+ * 'innerpath-list' is the list of possible inner join paths
+ * 'mergeinfo-list' is a list of nodes containing info on mergesortable
+ * clauses
+ *
+ * Returns a list of possible merge paths.
+ */
+static List *
+match_unsorted_inner(Rel *joinrel,
+ Rel *outerrel,
+ Rel *innerrel,
+ List *innerpath_list,
+ List *mergeinfo_list)
+{
+ Path *innerpath = (Path*)NULL;
+ List *mp_list = NIL;
+ List *temp_node = NIL;
+ PathOrder *innerpath_ordering = NULL;
+ Cost temp1 = 0.0;
+ bool temp2 = false;
+ List *i = NIL;
+
+ foreach (i, innerpath_list) {
+ MInfo *xmergeinfo = (MInfo*)NULL;
+ List *clauses = NIL;
+ List *matchedJoinKeys = NIL;
+ List *matchedJoinClauses = NIL;
+
+ innerpath = (Path*)lfirst(i);
+
+ innerpath_ordering = &innerpath->p_ordering;
+
+ if (innerpath_ordering) {
+ xmergeinfo =
+ match_order_mergeinfo(innerpath_ordering,
+ mergeinfo_list);
+ }
+
+ if (xmergeinfo) {
+ clauses = ((JoinMethod*)xmergeinfo)->clauses;
+ }
+
+ if (clauses) {
+ List *keys = xmergeinfo->jmethod.jmkeys;
+ List *cls = xmergeinfo->jmethod.clauses;
+
+ matchedJoinKeys =
+ match_pathkeys_joinkeys(innerpath->keys,
+ keys,
+ cls,
+ INNER,
+ &matchedJoinClauses);
+ }
+
+ /*
+ * (match-unsorted-outer) if it is applicable.
+ * 'OuterJoinCost was set above in
+ */
+ if (clauses && matchedJoinKeys) {
+ temp1 = outerrel->cheapestpath->path_cost +
+ cost_sort(matchedJoinKeys, outerrel->size, outerrel->width,
+ false);
+
+ temp2 = (bool) (FLOAT_IS_ZERO(innerpath->outerjoincost)
+ || (innerpath->outerjoincost > temp1));
+
+ if(temp2) {
+ List *outerkeys =
+ extract_path_keys(matchedJoinKeys,
+ outerrel->targetlist,
+ OUTER);
+ List *merge_pathkeys =
+ new_join_pathkeys(outerkeys,
+ joinrel->targetlist,
+ clauses);
+
+ temp_node =
+ lcons(create_mergesort_path(joinrel,
+ outerrel->size,
+ innerrel->size,
+ outerrel->width,
+ innerrel->width,
+ (Path*)outerrel->cheapestpath,
+ innerpath,
+ merge_pathkeys,
+ xmergeinfo->m_ordering,
+ matchedJoinClauses,
+ outerkeys,
+ NIL),
+ NIL);
+
+ mp_list = nconc(mp_list,temp_node);
+ }
+ }
+ }
+ return(mp_list);
+
+}
+
+static bool
+EnoughMemoryForHashjoin(Rel *hashrel)
+{
+ int ntuples;
+ int tupsize;
+ int pages;
+
+ ntuples = hashrel->size;
+ if (ntuples == 0) ntuples = 1000;
+ tupsize = hashrel->width + sizeof(HeapTupleData);
+ pages = page_size(ntuples, tupsize);
+ /*
+ * if amount of buffer space below hashjoin threshold,
+ * return false
+ */
+ if (ceil(sqrt((double)pages)) > NBuffers)
+ return false;
+ return true;
+}
+
+/*
+ * hash-inner-and-outer-- XXX HASH
+ * Create hashjoin join paths by explicitly hashing both the outer and
+ * inner join relations on each available hash op.
+ *
+ * 'joinrel' is the join relation
+ * 'outerrel' is the outer join relation
+ * 'innerrel' is the inner join relation
+ * 'hashinfo-list' is a list of nodes containing info on(hashjoinable)
+ * clauses for joining the relations
+ *
+ * Returns a list of hashjoin paths.
+ */
+static List *
+hash_inner_and_outer(Rel *joinrel,
+ Rel *outerrel,
+ Rel *innerrel,
+ List *hashinfo_list)
+{
+ HInfo *xhashinfo = (HInfo*)NULL;
+ List *hjoin_list = NIL;
+ HashPath *temp_node = (HashPath*)NULL;
+ List *i = NIL;
+ List *outerkeys = NIL;
+ List *innerkeys = NIL;
+ List *hash_pathkeys = NIL;
+
+ foreach (i, hashinfo_list) {
+ xhashinfo = (HInfo*)lfirst(i);
+ outerkeys =
+ extract_path_keys(((JoinMethod*)xhashinfo)->jmkeys,
+ outerrel->targetlist,
+ OUTER);
+ innerkeys =
+ extract_path_keys(((JoinMethod*)xhashinfo)->jmkeys,
+ innerrel->targetlist,
+ INNER);
+ hash_pathkeys =
+ new_join_pathkeys(outerkeys,
+ joinrel->targetlist,
+ ((JoinMethod*)xhashinfo)->clauses);
+
+ if (EnoughMemoryForHashjoin(innerrel)) {
+ temp_node = create_hashjoin_path(joinrel,
+ outerrel->size,
+ innerrel->size,
+ outerrel->width,
+ innerrel->width,
+ (Path*)outerrel->cheapestpath,
+ (Path*)innerrel->cheapestpath,
+ hash_pathkeys,
+ xhashinfo->hashop,
+ ((JoinMethod*)xhashinfo)->clauses,
+ outerkeys,
+ innerkeys);
+ hjoin_list = lappend(hjoin_list, temp_node);
+ }
+ }
+ return(hjoin_list);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * joinrels.c--
+ * Routines to determine which relations should be joined
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.1.1.1 1996/07/09 06:21:36 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/relation.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/cost.h"
+#include "optimizer/paths.h"
+#include "optimizer/tlist.h"
+#include "optimizer/joininfo.h"
+#include "optimizer/pathnode.h"
+
+
+static List *find_clause_joins(Query *root, Rel *outer_rel, List *joininfo_list);
+static List *find_clauseless_joins(Rel *outer_rel, List *inner_rels);
+static Rel *init_join_rel(Rel *outer_rel, Rel *inner_rel, JInfo *joininfo);
+static List *new_join_tlist(List *tlist, List *other_relids,
+ int first_resdomno);
+static List *new_joininfo_list(List *joininfo_list, List *join_relids);
+static void add_superrels(Rel *rel, Rel *super_rel);
+static bool nonoverlap_rels(Rel *rel1, Rel *rel2);
+static bool nonoverlap_sets(List *s1, List *s2);
+static void set_joinrel_size(Rel *joinrel, Rel *outer_rel, Rel *inner_rel,
+ JInfo *jinfo);
+
+/*
+ * find-join-rels--
+ * Find all possible joins for each of the outer join relations in
+ * 'outer-rels'. A rel node is created for each possible join relation,
+ * and the resulting list of nodes is returned. If at all possible, only
+ * those relations for which join clauses exist are considered. If none
+ * of these exist for a given relation, all remaining possibilities are
+ * considered.
+ *
+ * 'outer-rels' is the list of rel nodes
+ *
+ * Returns a list of rel nodes corresponding to the new join relations.
+ */
+List *
+find_join_rels(Query *root, List *outer_rels)
+{
+ List *joins = NIL;
+ List *join_list = NIL;
+ List *r = NIL;
+
+ foreach(r, outer_rels) {
+ Rel *outer_rel = (Rel *)lfirst(r);
+
+ if(!(joins = find_clause_joins(root, outer_rel,outer_rel->joininfo)))
+ if (BushyPlanFlag)
+ joins = find_clauseless_joins(outer_rel,outer_rels);
+ else
+ joins = find_clauseless_joins(outer_rel,root->base_relation_list_);
+
+ join_list = nconc(join_list, joins);
+ }
+
+ return(join_list);
+}
+
+/*
+ * find-clause-joins--
+ * Determines whether joins can be performed between an outer relation
+ * 'outer-rel' and those relations within 'outer-rel's joininfo nodes
+ * (i.e., relations that participate in join clauses that 'outer-rel'
+ * participates in). This is possible if all but one of the relations
+ * contained within the join clauses of the joininfo node are already
+ * contained within 'outer-rel'.
+ *
+ * 'outer-rel' is the relation entry for the outer relation
+ * 'joininfo-list' is a list of join clauses which 'outer-rel'
+ * participates in
+ *
+ * Returns a list of new join relations.
+ */
+static List *
+find_clause_joins(Query *root, Rel *outer_rel, List *joininfo_list)
+{
+ List *join_list = NIL;
+ List *i = NIL;
+
+ foreach (i, joininfo_list) {
+ JInfo *joininfo = (JInfo*)lfirst(i);
+ Rel *rel;
+
+ if(!joininfo->inactive) {
+ List *other_rels = joininfo->otherrels;
+
+ if(other_rels != NIL) {
+ if(length(other_rels) == 1) {
+ rel = init_join_rel(outer_rel,
+ get_base_rel(root, lfirsti(other_rels)),
+ joininfo);
+ } else if (BushyPlanFlag) {
+ rel = init_join_rel(outer_rel,
+ get_join_rel(root, other_rels),
+ joininfo);
+ } else {
+ rel = NULL;
+ }
+
+ if (rel != NULL)
+ join_list = lappend(join_list, rel);
+ }
+ }
+ }
+
+ return(join_list);
+}
+
+/*
+ * find-clauseless-joins--
+ * Given an outer relation 'outer-rel' and a list of inner relations
+ * 'inner-rels', create a join relation between 'outer-rel' and each
+ * member of 'inner-rels' that isn't already included in 'outer-rel'.
+ *
+ * Returns a list of new join relations.
+ */
+static List *
+find_clauseless_joins(Rel *outer_rel, List *inner_rels)
+{
+ Rel *inner_rel;
+ List *t_list = NIL;
+ List *temp_node = NIL;
+ List *i = NIL;
+
+ foreach (i, inner_rels) {
+ inner_rel = (Rel *)lfirst(i);
+ if(nonoverlap_rels(inner_rel, outer_rel)) {
+ temp_node = lcons(init_join_rel(outer_rel,
+ inner_rel,
+ (JInfo*)NULL),
+ NIL);
+ t_list = nconc(t_list,temp_node);
+ }
+ }
+
+ return(t_list);
+}
+
+/*
+ * init-join-rel--
+ * Creates and initializes a new join relation.
+ *
+ * 'outer-rel' and 'inner-rel' are relation nodes for the relations to be
+ * joined
+ * 'joininfo' is the joininfo node(join clause) containing both
+ * 'outer-rel' and 'inner-rel', if any exists
+ *
+ * Returns the new join relation node.
+ */
+static Rel *
+init_join_rel(Rel *outer_rel, Rel *inner_rel, JInfo *joininfo)
+{
+ Rel *joinrel = makeNode(Rel);
+ List *joinrel_joininfo_list = NIL;
+ List *new_outer_tlist;
+ List *new_inner_tlist;
+
+ /*
+ * Create a new tlist by removing irrelevant elements from both
+ * tlists of the outer and inner join relations and then merging
+ * the results together.
+ */
+ new_outer_tlist =
+ new_join_tlist(outer_rel->targetlist, /* XXX 1-based attnos */
+ inner_rel->relids, 1);
+ new_inner_tlist =
+ new_join_tlist(inner_rel->targetlist, /* XXX 1-based attnos */
+ outer_rel->relids,
+ length(new_outer_tlist) + 1);
+
+ joinrel->relids = NIL;
+ joinrel->indexed = false;
+ joinrel->pages = 0;
+ joinrel->tuples = 0;
+ joinrel->width = 0;
+/* joinrel->targetlist = NIL;*/
+ joinrel->pathlist = NIL;
+ joinrel->unorderedpath = (Path *)NULL;
+ joinrel->cheapestpath = (Path *)NULL;
+ joinrel->pruneable = true;
+ joinrel->classlist = NULL;
+ joinrel->relam = InvalidOid;
+ joinrel->ordering = NULL;
+ joinrel->clauseinfo = NIL;
+ joinrel->joininfo = NULL;
+ joinrel->innerjoin = NIL;
+ joinrel->superrels = NIL;
+
+ joinrel->relids = lcons(outer_rel->relids, /* ??? aren't they lists? -ay */
+ lcons(inner_rel->relids, NIL));
+
+ new_outer_tlist = nconc(new_outer_tlist,new_inner_tlist);
+ joinrel->targetlist = new_outer_tlist;
+
+ if (joininfo) {
+ joinrel->clauseinfo = joininfo->jinfoclauseinfo;
+ if (BushyPlanFlag)
+ joininfo->inactive = true;
+ }
+
+ joinrel_joininfo_list =
+ new_joininfo_list(append(outer_rel->joininfo, inner_rel->joininfo),
+ intAppend(outer_rel->relids, inner_rel->relids));
+
+ joinrel->joininfo = joinrel_joininfo_list;
+
+ set_joinrel_size(joinrel, outer_rel, inner_rel, joininfo);
+
+ return(joinrel);
+}
+
+/*
+ * new-join-tlist--
+ * Builds a join relations's target list by keeping those elements that
+ * will be in the final target list and any other elements that are still
+ * needed for future joins. For a target list entry to still be needed
+ * for future joins, its 'joinlist' field must not be empty after removal
+ * of all relids in 'other-relids'.
+ *
+ * 'tlist' is the target list of one of the join relations
+ * 'other-relids' is a list of relids contained within the other
+ * join relation
+ * 'first-resdomno' is the resdom number to use for the first created
+ * target list entry
+ *
+ * Returns the new target list.
+ */
+static List *
+new_join_tlist(List *tlist,
+ List *other_relids,
+ int first_resdomno)
+{
+ int resdomno = first_resdomno - 1;
+ TargetEntry *xtl = NULL;
+ List *temp_node = NIL;
+ List *t_list = NIL;
+ List *i = NIL;
+ List *join_list = NIL;
+ bool in_final_tlist =false;
+
+
+ foreach(i,tlist) {
+ xtl= lfirst(i);
+ in_final_tlist = (join_list==NIL);
+ if( in_final_tlist) {
+ resdomno += 1;
+ temp_node =
+ lcons(create_tl_element(get_expr(xtl),
+ resdomno),
+ NIL);
+ t_list = nconc(t_list,temp_node);
+ }
+ }
+
+ return(t_list);
+}
+
+/*
+ * new-joininfo-list--
+ * Builds a join relation's joininfo list by checking for join clauses
+ * which still need to used in future joins involving this relation. A
+ * join clause is still needed if there are still relations in the clause
+ * not contained in the list of relations comprising this join relation.
+ * New joininfo nodes are only created and added to
+ * 'current-joininfo-list' if a node for a particular join hasn't already
+ * been created.
+ *
+ * 'current-joininfo-list' contains a list of those joininfo nodes that
+ * have already been built
+ * 'joininfo-list' is the list of join clauses involving this relation
+ * 'join-relids' is a list of relids corresponding to the relations
+ * currently being joined
+ *
+ * Returns a list of joininfo nodes, new and old.
+ */
+static List *
+new_joininfo_list(List *joininfo_list, List *join_relids)
+{
+ List *current_joininfo_list = NIL;
+ List *new_otherrels = NIL;
+ JInfo *other_joininfo = (JInfo*)NULL;
+ List *xjoininfo = NIL;
+
+ foreach (xjoininfo, joininfo_list) {
+ JInfo *joininfo = (JInfo*)lfirst(xjoininfo);
+
+ new_otherrels = joininfo->otherrels;
+ if (nonoverlap_sets(new_otherrels,join_relids)) {
+ other_joininfo = joininfo_member(new_otherrels,
+ current_joininfo_list);
+ if(other_joininfo) {
+ other_joininfo->jinfoclauseinfo =
+ (List*)LispUnion(joininfo->jinfoclauseinfo,
+ other_joininfo->jinfoclauseinfo);
+ }else {
+ other_joininfo = makeNode(JInfo);
+
+ other_joininfo->otherrels =
+ joininfo->otherrels;
+ other_joininfo->jinfoclauseinfo =
+ joininfo->jinfoclauseinfo;
+ other_joininfo->mergesortable =
+ joininfo->mergesortable;
+ other_joininfo->hashjoinable =
+ joininfo->hashjoinable;
+ other_joininfo->inactive = false;
+
+ current_joininfo_list = lcons(other_joininfo,
+ current_joininfo_list);
+ }
+ }
+ }
+
+ return(current_joininfo_list);
+}
+
+/*
+ * add-new-joininfos--
+ * For each new join relation, create new joininfos that
+ * use the join relation as inner relation, and add
+ * the new joininfos to those rel nodes that still
+ * have joins with the join relation.
+ *
+ * 'joinrels' is a list of join relations.
+ *
+ * Modifies the joininfo field of appropriate rel nodes.
+ */
+void
+add_new_joininfos(Query *root, List *joinrels, List *outerrels)
+{
+ List *xjoinrel = NIL;
+ List *xrelid = NIL;
+ List *xrel = NIL;
+ List *xjoininfo = NIL;
+
+ foreach(xjoinrel, joinrels) {
+ Rel *joinrel = (Rel *)lfirst(xjoinrel);
+ foreach(xrelid, joinrel->relids) {
+ Relid relid = (Relid)lfirst(xrelid);
+ Rel *rel = get_join_rel(root, relid);
+ add_superrels(rel,joinrel);
+ }
+ }
+ foreach(xjoinrel, joinrels) {
+ Rel *joinrel = (Rel *)lfirst(xjoinrel);
+
+ foreach(xjoininfo, joinrel->joininfo) {
+ JInfo *joininfo = (JInfo*)lfirst(xjoininfo);
+ List *other_rels = joininfo->otherrels;
+ List *clause_info = joininfo->jinfoclauseinfo;
+ bool mergesortable = joininfo->mergesortable;
+ bool hashjoinable = joininfo->hashjoinable;
+
+ foreach(xrelid, other_rels) {
+ Relid relid = (Relid)lfirst(xrelid);
+ Rel *rel = get_join_rel(root, relid);
+ List *super_rels = rel->superrels;
+ List *xsuper_rel = NIL;
+ JInfo *new_joininfo = makeNode(JInfo);
+
+ new_joininfo->otherrels = joinrel->relids;
+ new_joininfo->jinfoclauseinfo = clause_info;
+ new_joininfo->mergesortable = mergesortable;
+ new_joininfo->hashjoinable = hashjoinable;
+ new_joininfo->inactive = false;
+ rel->joininfo =
+ lappend(rel->joininfo, new_joininfo);
+
+ foreach(xsuper_rel, super_rels) {
+ Rel *super_rel = (Rel *)lfirst(xsuper_rel);
+
+ if( nonoverlap_rels(super_rel,joinrel) ) {
+ List *new_relids = super_rel->relids;
+ JInfo *other_joininfo =
+ joininfo_member(new_relids,
+ joinrel->joininfo);
+
+ if (other_joininfo) {
+ other_joininfo->jinfoclauseinfo =
+ (List*)LispUnion(clause_info,
+ other_joininfo->jinfoclauseinfo);
+ } else {
+ JInfo *new_joininfo = makeNode(JInfo);
+
+ new_joininfo->otherrels = new_relids;
+ new_joininfo->jinfoclauseinfo = clause_info;
+ new_joininfo->mergesortable = mergesortable;
+ new_joininfo->hashjoinable = hashjoinable;
+ new_joininfo->inactive = false;
+ joinrel->joininfo =
+ lappend(joinrel->joininfo,
+ new_joininfo);
+ }
+ }
+ }
+ }
+ }
+ }
+ foreach(xrel, outerrels) {
+ Rel *rel = (Rel *)lfirst(xrel);
+ rel->superrels = NIL;
+ }
+}
+
+/*
+ * final-join-rels--
+ * Find the join relation that includes all the original
+ * relations, i.e. the final join result.
+ *
+ * 'join-rel-list' is a list of join relations.
+ *
+ * Returns the list of final join relations.
+ */
+List *
+final_join_rels(List *join_rel_list)
+{
+ List *xrel = NIL;
+ List *temp = NIL;
+ List *t_list = NIL;
+
+ /*
+ * find the relations that has no further joins,
+ * i.e., its joininfos all have otherrels nil.
+ */
+ foreach(xrel,join_rel_list) {
+ Rel *rel = (Rel *)lfirst(xrel);
+ List *xjoininfo = NIL;
+ bool final = true;
+
+ foreach (xjoininfo, rel->joininfo) {
+ JInfo *joininfo = (JInfo*)lfirst(xjoininfo);
+
+ if (joininfo->otherrels != NIL) {
+ final = false;
+ break;
+ }
+ }
+ if (final) {
+ temp = lcons(rel, NIL);
+ t_list = nconc(t_list, temp);
+ }
+ }
+
+ return(t_list);
+}
+
+/*
+ * add_superrels--
+ * add rel to the temporary property list superrels.
+ *
+ * 'rel' a rel node
+ * 'super-rel' rel node of a join relation that includes rel
+ *
+ * Modifies the superrels field of rel
+ */
+static void
+add_superrels(Rel *rel, Rel *super_rel)
+{
+ rel->superrels = lappend(rel->superrels, super_rel);
+}
+
+/*
+ * nonoverlap-rels--
+ * test if two join relations overlap, i.e., includes the same
+ * relation.
+ *
+ * 'rel1' and 'rel2' are two join relations
+ *
+ * Returns non-nil if rel1 and rel2 do not overlap.
+ */
+static bool
+nonoverlap_rels(Rel *rel1, Rel *rel2)
+{
+ return(nonoverlap_sets(rel1->relids, rel2->relids));
+}
+
+static bool
+nonoverlap_sets(List *s1, List *s2)
+{
+ List *x = NIL;
+
+ foreach(x,s1) {
+ int e = lfirsti(x);
+ if(intMember(e,s2))
+ return(false);
+ }
+ return(true);
+}
+
+static void
+set_joinrel_size(Rel *joinrel, Rel *outer_rel, Rel *inner_rel, JInfo *jinfo)
+{
+ int ntuples;
+ float selec;
+
+ /* voodoo magic. but better than a size of 0. I have no idea why
+ we didn't set the size before. -ay 2/95 */
+ if (jinfo==NULL) {
+ /* worst case: the cartesian product */
+ ntuples = outer_rel->tuples * inner_rel->tuples;
+ } else {
+ selec = product_selec(jinfo->jinfoclauseinfo);
+/* ntuples = Min(outer_rel->tuples,inner_rel->tuples) * selec; */
+ ntuples = outer_rel->tuples * inner_rel->tuples * selec;
+ }
+
+ /* I bet sizes less than 1 will screw up optimization so
+ make the best case 1 instead of 0 - jolly*/
+ if (ntuples < 1)
+ ntuples = 1;
+
+ joinrel->tuples = ntuples;
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * joinutils.c--
+ * Utilities for matching and building join and path keys
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/joinutils.c,v 1.1.1.1 1996/07/09 06:21:36 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/relation.h"
+#include "nodes/plannodes.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/paths.h"
+#include "optimizer/var.h"
+#include "optimizer/keys.h"
+#include "optimizer/tlist.h"
+#include "optimizer/joininfo.h"
+#include "optimizer/ordering.h"
+
+
+static int match_pathkey_joinkeys(List *pathkey, List *joinkeys,
+ int which_subkey);
+static bool every_func(List *joinkeys, List *pathkey,
+ int which_subkey);
+static List *new_join_pathkey(List *subkeys,
+ List *considered_subkeys, List *join_rel_tlist,
+ List *joinclauses);
+static List *new_matching_subkeys(Var *subkey, List *considered_subkeys,
+ List *join_rel_tlist, List *joinclauses);
+
+/****************************************************************************
+ * KEY COMPARISONS
+ ****************************************************************************/
+
+/*
+ * match-pathkeys-joinkeys--
+ * Attempts to match the keys of a path against the keys of join clauses.
+ * This is done by looking for a matching join key in 'joinkeys' for
+ * every path key in the list 'pathkeys'. If there is a matching join key
+ * (not necessarily unique) for every path key, then the list of
+ * corresponding join keys and join clauses are returned in the order in
+ * which the keys matched the path keys.
+ *
+ * 'pathkeys' is a list of path keys:
+ * ( ( (var) (var) ... ) ( (var) ... ) )
+ * 'joinkeys' is a list of join keys:
+ * ( (outer inner) (outer inner) ... )
+ * 'joinclauses' is a list of clauses corresponding to the join keys in
+ * 'joinkeys'
+ * 'which-subkey' is a flag that selects the desired subkey of a join key
+ * in 'joinkeys'
+ *
+ * Returns the join keys and corresponding join clauses in a list if all
+ * of the path keys were matched:
+ * (
+ * ( (outerkey0 innerkey0) ... (outerkeyN innerkeyN) )
+ * ( clause0 ... clauseN )
+ * )
+ * and nil otherwise.
+ *
+ * Returns a list of matched join keys and a list of matched join clauses
+ * in matchedJoinClausesPtr. - ay 11/94
+ */
+List *
+match_pathkeys_joinkeys(List *pathkeys,
+ List *joinkeys,
+ List *joinclauses,
+ int which_subkey,
+ List **matchedJoinClausesPtr)
+{
+ List *matched_joinkeys = NIL;
+ List *matched_joinclauses = NIL;
+ List *pathkey = NIL;
+ List *i = NIL;
+ int matched_joinkey_index = -1;
+
+ foreach(i, pathkeys) {
+ pathkey = lfirst(i);
+ matched_joinkey_index =
+ match_pathkey_joinkeys(pathkey, joinkeys, which_subkey);
+
+ if (matched_joinkey_index != -1 ) {
+ List *xjoinkey = nth(matched_joinkey_index,joinkeys);
+ List *joinclause = nth(matched_joinkey_index,joinclauses);
+
+ /* XXX was "push" function */
+ matched_joinkeys = lappend(matched_joinkeys,xjoinkey);
+ matched_joinkeys = nreverse(matched_joinkeys);
+
+ matched_joinclauses = lappend(matched_joinclauses,joinclause);
+ matched_joinclauses = nreverse(matched_joinclauses);
+ joinkeys = LispRemove(xjoinkey,joinkeys);
+ } else {
+ return(NIL);
+ }
+
+ }
+ if(matched_joinkeys==NULL ||
+ length(matched_joinkeys) != length(pathkeys)) {
+ return NIL;
+ }
+
+ *matchedJoinClausesPtr = nreverse(matched_joinclauses);
+ return (nreverse(matched_joinkeys));
+}
+
+/*
+ * match-pathkey-joinkeys--
+ * Returns the 0-based index into 'joinkeys' of the first joinkey whose
+ * outer or inner subkey matches any subkey of 'pathkey'.
+ */
+static int
+match_pathkey_joinkeys(List *pathkey,
+ List *joinkeys,
+ int which_subkey)
+{
+ Var *path_subkey;
+ int pos;
+ List *i = NIL;
+ List *x = NIL;
+ JoinKey *jk;
+
+ foreach(i, pathkey) {
+ path_subkey = (Var *)lfirst(i);
+ pos = 0;
+ foreach(x, joinkeys) {
+ jk = (JoinKey*)lfirst(x);
+ if(var_equal(path_subkey,
+ extract_subkey(jk, which_subkey)))
+ return(pos);
+ pos++;
+ }
+ }
+ return(-1); /* no index found */
+}
+
+/*
+ * match-paths-joinkeys--
+ * Attempts to find a path in 'paths' whose keys match a set of join
+ * keys 'joinkeys'. To match,
+ * 1. the path node ordering must equal 'ordering'.
+ * 2. each subkey of a given path must match(i.e., be(var_equal) to) the
+ * appropriate subkey of the corresponding join key in 'joinkeys',
+ * i.e., the Nth path key must match its subkeys against the subkey of
+ * the Nth join key in 'joinkeys'.
+ *
+ * 'joinkeys' is the list of key pairs to which the path keys must be
+ * matched
+ * 'ordering' is the ordering of the(outer) path to which 'joinkeys'
+ * must correspond
+ * 'paths' is a list of(inner) paths which are to be matched against
+ * each join key in 'joinkeys'
+ * 'which-subkey' is a flag that selects the desired subkey of a join key
+ * in 'joinkeys'
+ *
+ * Returns the matching path node if one exists, nil otherwise.
+ */
+static bool
+every_func(List *joinkeys, List *pathkey, int which_subkey)
+{
+ JoinKey *xjoinkey;
+ Var *temp;
+ Var *tempkey = NULL;
+ bool found = false;
+ List *i = NIL;
+ List *j = NIL;
+
+ foreach(i,joinkeys) {
+ xjoinkey = (JoinKey*)lfirst(i);
+ found = false;
+ foreach(j,pathkey) {
+ temp = (Var*)lfirst((List*)lfirst(j));
+ if(temp == NULL) continue;
+ tempkey = extract_subkey(xjoinkey,which_subkey);
+ if(var_equal(tempkey, temp)) {
+ found = true;
+ break;
+ }
+ }
+ if(found == false)
+ return(false);
+ }
+ return(found);
+}
+
+
+/*
+ * match_paths_joinkeys -
+ * find the cheapest path that matches the join keys
+ */
+Path *
+match_paths_joinkeys(List *joinkeys,
+ PathOrder *ordering,
+ List *paths,
+ int which_subkey)
+{
+ Path *matched_path = NULL ;
+ bool key_match = false;
+ List *i = NIL;
+
+ foreach(i,paths) {
+ Path *path = (Path*)lfirst(i);
+
+ key_match = every_func(joinkeys, path->keys, which_subkey);
+
+ if (equal_path_path_ordering(ordering,
+ &path->p_ordering) &&
+ length(joinkeys) == length(path->keys) &&
+ key_match) {
+
+ if (matched_path) {
+ if (path->path_cost < matched_path->path_cost)
+ matched_path = path;
+ } else {
+ matched_path = path;
+ }
+ }
+ }
+ return matched_path;
+}
+
+
+
+/*
+ * extract-path-keys--
+ * Builds a subkey list for a path by pulling one of the subkeys from
+ * a list of join keys 'joinkeys' and then finding the var node in the
+ * target list 'tlist' that corresponds to that subkey.
+ *
+ * 'joinkeys' is a list of join key pairs
+ * 'tlist' is a relation target list
+ * 'which-subkey' is a flag that selects the desired subkey of a join key
+ * in 'joinkeys'
+ *
+ * Returns a list of pathkeys: ((tlvar1)(tlvar2)...(tlvarN)).
+ * [I've no idea why they have to be list of lists. Should be fixed. -ay 12/94]
+ */
+List *
+extract_path_keys(List *joinkeys,
+ List *tlist,
+ int which_subkey)
+{
+ List *pathkeys = NIL;
+ List *jk;
+
+ foreach(jk, joinkeys) {
+ JoinKey *jkey = (JoinKey*)lfirst(jk);
+ Var *var, *key;
+ List *p;
+
+ /*
+ * find the right Var in the target list for this key
+ */
+ var = (Var*)extract_subkey(jkey, which_subkey);
+ key = (Var*)matching_tlvar(var, tlist);
+
+ /*
+ * include it in the pathkeys list if we haven't already done so
+ */
+ foreach(p, pathkeys) {
+ Var *pkey = lfirst((List*)lfirst(p)); /* XXX fix me */
+ if (key == pkey)
+ break;
+ }
+ if (p!=NIL)
+ continue; /* key already in pathkeys */
+
+ pathkeys =
+ lappend(pathkeys, lcons(key,NIL));
+ }
+ return(pathkeys);
+}
+
+
+/****************************************************************************
+ * NEW PATHKEY FORMATION
+ ****************************************************************************/
+
+/*
+ * new-join-pathkeys--
+ * Find the path keys for a join relation by finding all vars in the list
+ * of join clauses 'joinclauses' such that:
+ * (1) the var corresponding to the outer join relation is a
+ * key on the outer path
+ * (2) the var appears in the target list of the join relation
+ * In other words, add to each outer path key the inner path keys that
+ * are required for qualification.
+ *
+ * 'outer-pathkeys' is the list of the outer path's path keys
+ * 'join-rel-tlist' is the target list of the join relation
+ * 'joinclauses' is the list of restricting join clauses
+ *
+ * Returns the list of new path keys.
+ *
+ */
+List *
+new_join_pathkeys(List *outer_pathkeys,
+ List *join_rel_tlist,
+ List *joinclauses)
+{
+ List *outer_pathkey = NIL;
+ List *t_list = NIL;
+ List *x;
+ List *i = NIL;
+
+ foreach(i, outer_pathkeys) {
+ outer_pathkey = lfirst(i);
+ x = new_join_pathkey(outer_pathkey, NIL,
+ join_rel_tlist,joinclauses);
+ if (x!=NIL) {
+ t_list = lappend(t_list, x);
+ }
+ }
+ return(t_list);
+}
+
+/*
+ * new-join-pathkey--
+ * Finds new vars that become subkeys due to qualification clauses that
+ * contain any previously considered subkeys. These new subkeys plus the
+ * subkeys from 'subkeys' form a new pathkey for the join relation.
+ *
+ * Note that each returned subkey is the var node found in
+ * 'join-rel-tlist' rather than the joinclause var node.
+ *
+ * 'subkeys' is a list of subkeys for which matching subkeys are to be
+ * found
+ * 'considered-subkeys' is the current list of all subkeys corresponding
+ * to a given pathkey
+ *
+ * Returns a new pathkey(list of subkeys).
+ *
+ */
+static List *
+new_join_pathkey(List *subkeys,
+ List *considered_subkeys,
+ List *join_rel_tlist,
+ List *joinclauses)
+{
+ List *t_list = NIL;
+ Var *subkey;
+ List *i = NIL;
+ List *matched_subkeys = NIL;
+ Expr *tlist_key = (Expr*)NULL;
+ List *newly_considered_subkeys = NIL;
+
+ foreach (i, subkeys) {
+ subkey = (Var *)lfirst(i);
+ if(subkey == NULL)
+ break; /* XXX something is wrong */
+ matched_subkeys =
+ new_matching_subkeys(subkey,considered_subkeys,
+ join_rel_tlist,joinclauses);
+ tlist_key = matching_tlvar(subkey,join_rel_tlist);
+ newly_considered_subkeys = NIL;
+
+ if (tlist_key) {
+ if(!member(tlist_key, matched_subkeys))
+ newly_considered_subkeys = lcons(tlist_key,
+ matched_subkeys);
+ }
+ else {
+ newly_considered_subkeys = matched_subkeys;
+ }
+
+ considered_subkeys =
+ append(considered_subkeys, newly_considered_subkeys);
+
+ t_list = nconc(t_list,newly_considered_subkeys);
+ }
+ return(t_list);
+}
+
+/*
+ * new-matching-subkeys--
+ * Returns a list of new subkeys:
+ * (1) which are not listed in 'considered-subkeys'
+ * (2) for which the "other" variable in some clause in 'joinclauses' is
+ * 'subkey'
+ * (3) which are mentioned in 'join-rel-tlist'
+ *
+ * Note that each returned subkey is the var node found in
+ * 'join-rel-tlist' rather than the joinclause var node.
+ *
+ * 'subkey' is the var node for which we are trying to find matching
+ * clauses
+ *
+ * Returns a list of new subkeys.
+ *
+ */
+static List *
+new_matching_subkeys(Var *subkey,
+ List *considered_subkeys,
+ List *join_rel_tlist,
+ List *joinclauses)
+{
+ Expr *joinclause = NULL;
+ List *t_list = NIL;
+ List *temp = NIL;
+ List *i = NIL;
+ Expr *tlist_other_var = (Expr *)NULL;
+
+ foreach(i,joinclauses) {
+ joinclause = lfirst(i);
+ tlist_other_var =
+ matching_tlvar(other_join_clause_var(subkey,joinclause),
+ join_rel_tlist);
+
+ if(tlist_other_var &&
+ !(member(tlist_other_var,considered_subkeys))) {
+
+ /* XXX was "push" function */
+ considered_subkeys = lappend(considered_subkeys,
+ tlist_other_var);
+
+ /* considered_subkeys = nreverse(considered_subkeys);
+ XXX -- I am not sure of this. */
+
+ temp = lcons(tlist_other_var, NIL);
+ t_list = nconc(t_list,temp);
+ }
+ }
+ return(t_list);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * mergeutils.c--
+ * Utilities for finding applicable merge clauses and pathkeys
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/mergeutils.c,v 1.1.1.1 1996/07/09 06:21:36 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/relation.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/paths.h"
+#include "optimizer/clauses.h"
+#include "optimizer/ordering.h"
+
+/*
+ * group-clauses-by-order--
+ * If a join clause node in 'clauseinfo-list' is mergesortable, store
+ * it within a mergeinfo node containing other clause nodes with the same
+ * mergesort ordering.
+ *
+ * 'clauseinfo-list' is the list of clauseinfo nodes
+ * 'inner-relid' is the relid of the inner join relation
+ *
+ * Returns the new list of mergeinfo nodes.
+ *
+ */
+List *
+group_clauses_by_order(List *clauseinfo_list,
+ int inner_relid)
+{
+ List *mergeinfo_list = NIL;
+ List *xclauseinfo = NIL;
+
+ foreach (xclauseinfo, clauseinfo_list) {
+ CInfo *clauseinfo = (CInfo *)lfirst(xclauseinfo);
+ MergeOrder *merge_ordering = clauseinfo->mergesortorder;
+
+ if (merge_ordering) {
+ /*
+ * Create a new mergeinfo node and add it to
+ * 'mergeinfo-list' if one does not yet exist for this
+ * merge ordering.
+ */
+ PathOrder p_ordering;
+ MInfo *xmergeinfo;
+ Expr *clause = clauseinfo->clause;
+ Var *leftop = get_leftop (clause);
+ Var *rightop = get_rightop (clause);
+ JoinKey *keys;
+
+ p_ordering.ordtype = MERGE_ORDER;
+ p_ordering.ord.merge = merge_ordering;
+ xmergeinfo =
+ match_order_mergeinfo(&p_ordering, mergeinfo_list);
+ if (inner_relid == leftop->varno) {
+ keys = makeNode(JoinKey);
+ keys->outer = rightop;
+ keys->inner = leftop;
+ } else {
+ keys = makeNode(JoinKey);
+ keys->outer = leftop;
+ keys->inner = rightop;
+ }
+
+ if (xmergeinfo==NULL) {
+ xmergeinfo = makeNode(MInfo);
+
+ xmergeinfo->m_ordering = merge_ordering;
+ mergeinfo_list = lcons(xmergeinfo,
+ mergeinfo_list);
+ }
+
+ ((JoinMethod *)xmergeinfo)->clauses =
+ lcons(clause,
+ ((JoinMethod *)xmergeinfo)->clauses);
+ ((JoinMethod *)xmergeinfo)->jmkeys =
+ lcons(keys,
+ ((JoinMethod *)xmergeinfo)->jmkeys);
+ }
+ }
+ return(mergeinfo_list);
+}
+
+
+/*
+ * match-order-mergeinfo--
+ * Searches the list 'mergeinfo-list' for a mergeinfo node whose order
+ * field equals 'ordering'.
+ *
+ * Returns the node if it exists.
+ *
+ */
+MInfo *
+match_order_mergeinfo(PathOrder *ordering, List *mergeinfo_list)
+{
+ MergeOrder *xmergeorder;
+ List *xmergeinfo = NIL;
+
+ foreach(xmergeinfo, mergeinfo_list) {
+ MInfo *mergeinfo = (MInfo*)lfirst(xmergeinfo);
+
+ xmergeorder = mergeinfo->m_ordering;
+
+ if ((ordering->ordtype==MERGE_ORDER &&
+ equal_merge_merge_ordering(ordering->ord.merge, xmergeorder)) ||
+ (ordering->ordtype==SORTOP_ORDER &&
+ equal_path_merge_ordering(ordering->ord.sortop, xmergeorder))) {
+
+ return (mergeinfo);
+ }
+ }
+ return((MInfo*) NIL);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * orindxpath.c--
+ * Routines to find index paths that match a set of 'or' clauses
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/orindxpath.c,v 1.1.1.1 1996/07/09 06:21:36 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/relation.h"
+#include "nodes/primnodes.h"
+
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/clauses.h"
+#include "optimizer/clauseinfo.h"
+#include "optimizer/paths.h"
+#include "optimizer/cost.h"
+#include "optimizer/plancat.h"
+#include "optimizer/xfunc.h"
+
+#include "parser/parsetree.h"
+
+
+static void best_or_subclause_indices(Query *root, Rel *rel, List *subclauses,
+ List *indices, List *examined_indexids, Cost subcost, List *selectivities,
+ List **indexids, Cost *cost, List **selecs);
+static void best_or_subclause_index(Query *root, Rel *rel, Expr *subclause,
+ List *indices, int *indexid, Cost *cost, Cost *selec);
+
+
+/*
+ * create-or-index-paths--
+ * Creates index paths for indices that match 'or' clauses.
+ *
+ * 'rel' is the relation entry for which the paths are to be defined on
+ * 'clauses' is the list of available restriction clause nodes
+ *
+ * Returns a list of these index path nodes.
+ *
+ */
+List *
+create_or_index_paths(Query *root,
+ Rel *rel, List *clauses)
+{
+ List *t_list = NIL;
+
+ if (clauses != NIL) {
+ CInfo *clausenode = (CInfo *) (lfirst (clauses));
+
+ /* Check to see if this clause is an 'or' clause, and, if so,
+ * whether or not each of the subclauses within the 'or' clause has
+ * been matched by an index (the 'Index field was set in
+ * (match_or) if no index matches a given subclause, one of the
+ * lists of index nodes returned by (get_index) will be 'nil').
+ */
+ if (valid_or_clause(clausenode) &&
+ clausenode->indexids) {
+ List *temp = NIL;
+ List *index_list = NIL;
+ bool index_flag = true;
+
+ index_list = clausenode->indexids;
+ foreach(temp,index_list) {
+ if (!temp)
+ index_flag = false;
+ }
+ if (index_flag) { /* used to be a lisp every function */
+ IndexPath *pathnode = makeNode(IndexPath);
+ List *indexids;
+ Cost cost;
+ List *selecs;
+
+ best_or_subclause_indices(root,
+ rel,
+ clausenode->clause->args,
+ clausenode->indexids,
+ NIL,
+ (Cost)0,
+ NIL,
+ &indexids,
+ &cost,
+ &selecs);
+
+ pathnode->path.pathtype = T_IndexScan;
+ pathnode->path.parent = rel;
+ pathnode->indexqual =
+ lcons(clausenode,NIL);
+ pathnode->indexid = indexids;
+ pathnode->path.path_cost = cost;
+
+ /* copy clauseinfo list into path for expensive
+ function processing -- JMH, 7/7/92 */
+ pathnode->path.locclauseinfo =
+ set_difference(clauses,
+ copyObject((Node*)
+ rel->clauseinfo));
+
+#if 0 /* fix xfunc */
+ /* add in cost for expensive functions! -- JMH, 7/7/92 */
+ if (XfuncMode != XFUNC_OFF) {
+ ((Path*)pathnode)->path_cost +=
+ xfunc_get_path_cost((Path)pathnode);
+ }
+#endif
+ clausenode->selectivity = (Cost)floatVal(selecs);
+ t_list =
+ lcons(pathnode,
+ create_or_index_paths(root, rel,lnext(clauses)));
+ } else {
+ t_list = create_or_index_paths(root, rel,lnext(clauses));
+ }
+ }
+ }
+
+ return(t_list);
+}
+
+/*
+ * best-or-subclause-indices--
+ * Determines the best index to be used in conjunction with each subclause
+ * of an 'or' clause and the cost of scanning a relation using these
+ * indices. The cost is the sum of the individual index costs.
+ *
+ * 'rel' is the node of the relation on which the index is defined
+ * 'subclauses' are the subclauses of the 'or' clause
+ * 'indices' are those index nodes that matched subclauses of the 'or'
+ * clause
+ * 'examined-indexids' is a list of those index ids to be used with
+ * subclauses that have already been examined
+ * 'subcost' is the cost of using the indices in 'examined-indexids'
+ * 'selectivities' is a list of the selectivities of subclauses that
+ * have already been examined
+ *
+ * Returns a list of the indexids, cost, and selectivities of each
+ * subclause, e.g., ((i1 i2 i3) cost (s1 s2 s3)), where 'i' is an OID,
+ * 'cost' is a flonum, and 's' is a flonum.
+ */
+static void
+best_or_subclause_indices(Query *root,
+ Rel *rel,
+ List *subclauses,
+ List *indices,
+ List *examined_indexids,
+ Cost subcost,
+ List *selectivities,
+ List **indexids, /* return value */
+ Cost *cost, /* return value */
+ List **selecs) /* return value */
+{
+ if (subclauses==NIL) {
+ *indexids = nreverse(examined_indexids);
+ *cost = subcost;
+ *selecs = nreverse(selectivities);
+ } else {
+ int best_indexid;
+ Cost best_cost;
+ Cost best_selec;
+
+ best_or_subclause_index(root, rel, lfirst(subclauses), lfirst(indices),
+ &best_indexid, &best_cost, &best_selec);
+
+ best_or_subclause_indices(root,
+ rel,
+ lnext(subclauses),
+ lnext(indices),
+ lconsi(best_indexid, examined_indexids),
+ subcost + best_cost,
+ lcons(makeFloat(best_selec), selectivities),
+ indexids,
+ cost,
+ selecs);
+ }
+ return;
+}
+
+/*
+ * best-or-subclause-index--
+ * Determines which is the best index to be used with a subclause of
+ * an 'or' clause by estimating the cost of using each index and selecting
+ * the least expensive.
+ *
+ * 'rel' is the node of the relation on which the index is defined
+ * 'subclause' is the subclause
+ * 'indices' is a list of index nodes that match the subclause
+ *
+ * Returns a list (index-id index-subcost index-selectivity)
+ * (a fixnum, a fixnum, and a flonum respectively).
+ *
+ */
+static void
+best_or_subclause_index(Query *root,
+ Rel *rel,
+ Expr *subclause,
+ List *indices,
+ int *retIndexid, /* return value */
+ Cost *retCost, /* return value */
+ Cost *retSelec) /* return value */
+{
+ if (indices != NIL) {
+ Datum value;
+ int flag = 0;
+ Cost subcost;
+ Rel *index = (Rel *)lfirst (indices);
+ AttrNumber attno = (get_leftop (subclause))->varattno ;
+ Oid opno = ((Oper*)subclause->oper)->opno;
+ bool constant_on_right = non_null((Expr*)get_rightop(subclause));
+ float npages, selec;
+ int subclause_indexid;
+ Cost subclause_cost;
+ Cost subclause_selec;
+
+ if(constant_on_right) {
+ value = ((Const*)get_rightop (subclause))->constvalue;
+ } else {
+ value = NameGetDatum("");
+ }
+ if(constant_on_right) {
+ flag = (_SELEC_IS_CONSTANT_ ||_SELEC_CONSTANT_RIGHT_);
+ } else {
+ flag = _SELEC_CONSTANT_RIGHT_;
+ }
+ index_selectivity(lfirsti(index->relids),
+ index->classlist,
+ lconsi(opno,NIL),
+ getrelid(lfirsti(rel->relids),
+ root->rtable),
+ lconsi(attno,NIL),
+ lconsi(value,NIL),
+ lconsi(flag,NIL),
+ 1,
+ &npages,
+ &selec);
+
+ subcost = cost_index((Oid) lfirsti(index->relids),
+ (int)npages,
+ (Cost)selec,
+ rel->pages,
+ rel->tuples,
+ index->pages,
+ index->tuples,
+ false);
+ best_or_subclause_index(root,
+ rel,
+ subclause,
+ lnext(indices),
+ &subclause_indexid,
+ &subclause_cost,
+ &subclause_selec);
+
+ if (subclause_indexid==0 || subcost < subclause_cost) {
+ *retIndexid = lfirsti(index->relids);
+ *retCost = subcost;
+ *retSelec = selec;
+ } else {
+ *retIndexid = 0;
+ *retCost = 0.0;
+ *retSelec = 0.0;
+ }
+ }
+ return;
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * predmig.c--
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/predmig.c,v 1.1.1.1 1996/07/09 06:21:36 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+** DESCRIPTION
+** Main Routines to handle Predicate Migration (i.e. correct optimization
+** of queries with expensive functions.)
+**
+** The reasoning behind some of these algorithms is rather detailed.
+** Have a look at Sequoia Tech Report 92/13 for more info. Also
+** see Monma and Sidney's paper "Sequencing with Series-Parallel
+** Precedence Constraints", in "Mathematics of Operations Research",
+** volume 4 (1979), pp. 215-224.
+**
+** The main thing that this code does that wasn't handled in xfunc.c is
+** it considers the possibility that two joins in a stream may not
+** be ordered by ascending rank -- in such a scenario, it may be optimal
+** to pullup more restrictions than we did via xfunc_try_pullup.
+**
+** This code in some sense generalizes xfunc_try_pullup; if you
+** run postgres -x noprune, you'll turn off xfunc_try_pullup, and this
+** code will do everything that xfunc_try_pullup would have, and maybe
+** more. However, this results in no pruning, which may slow down the
+** optimizer and/or cause the system to run out of memory.
+** -- JMH, 11/13/92
+*/
+
+#include "nodes/pg_list.h"
+#include "nodes/nodes.h"
+#include "nodes/primnodes.h"
+#include "nodes/relation.h"
+#include "utils/palloc.h"
+#include "utils/elog.h"
+#include "planner/xfunc.h"
+#include "planner/pathnode.h"
+#include "planner/internal.h"
+#include "planner/cost.h"
+#include "planner/keys.h"
+#include "planner/tlist.h"
+#include "lib/qsort.h"
+
+#define is_clause(node) (get_cinfo(node)) /* a stream node represents a
+ clause (not a join) iff it
+ has a non-NULL cinfo field */
+
+static void xfunc_predmig(JoinPath pathnode, Stream streamroot,
+ Stream laststream, bool *progressp);
+static bool xfunc_series_llel(Stream stream);
+static bool xfunc_llel_chains(Stream root, Stream bottom);
+static Stream xfunc_complete_stream(Stream stream);
+static bool xfunc_prdmig_pullup(Stream origstream, Stream pullme,
+ JoinPath joinpath);
+static void xfunc_form_groups(Stream root, Stream bottom);
+static void xfunc_free_stream(Stream root);
+static Stream xfunc_add_clauses(Stream current);
+static void xfunc_setup_group(Stream node, Stream bottom);
+static Stream xfunc_streaminsert(CInfo clauseinfo, Stream current,
+ int clausetype);
+static int xfunc_num_relids(Stream node);
+static StreamPtr xfunc_get_downjoin(Stream node);
+static StreamPtr xfunc_get_upjoin(Stream node);
+static Stream xfunc_stream_qsort(Stream root, Stream bottom);
+static int xfunc_stream_compare(void *arg1, void *arg2);
+static bool xfunc_check_stream(Stream node);
+static bool xfunc_in_stream(Stream node, Stream stream);
+
+/* ----------------- MAIN FUNCTIONS ------------------------ */
+/*
+** xfunc_do_predmig
+** wrapper for Predicate Migration. It calls xfunc_predmig until no
+** more progress is made.
+** return value says if any changes were ever made.
+*/
+bool xfunc_do_predmig(Path root)
+{
+ bool progress, changed = false;
+
+ if (is_join(root))
+ do
+ {
+ progress = false;
+ Assert(IsA(root,JoinPath));
+ xfunc_predmig((JoinPath)root, (Stream)NULL, (Stream)NULL,
+ &progress);
+ if (changed && progress)
+ elog(DEBUG, "Needed to do a second round of predmig!\n");
+ if (progress) changed = true;
+ } while (progress);
+ return(changed);
+}
+
+
+/*
+ ** xfunc_predmig
+ ** The main routine for Predicate Migration. It traverses a join tree,
+ ** and for each root-to-leaf path in the plan tree it constructs a
+ ** "Stream", which it passes to xfunc_series_llel for optimization.
+ ** Destructively modifies the join tree (via predicate pullup).
+ */
+static void
+xfunc_predmig(JoinPath pathnode, /* root of the join tree */
+ Stream streamroot,
+ Stream laststream, /* for recursive calls -- these are
+ the root of the stream under
+ construction, and the lowest node
+ created so far */
+ bool *progressp)
+{
+ Stream newstream;
+
+ /*
+ ** traverse the join tree dfs-style, constructing a stream as you go.
+ ** When you hit a scan node, pass the stream off to xfunc_series_llel.
+ */
+
+ /* sanity check */
+ if ((!streamroot && laststream) ||
+ (streamroot && !laststream))
+ elog(WARN, "called xfunc_predmig with bad inputs");
+ if (streamroot) Assert(xfunc_check_stream(streamroot));
+
+ /* add path node to stream */
+ newstream = RMakeStream();
+ if (!streamroot)
+ streamroot = newstream;
+ set_upstream(newstream, (StreamPtr)laststream);
+ if (laststream)
+ set_downstream(laststream, (StreamPtr)newstream);
+ set_downstream(newstream, (StreamPtr)NULL);
+ set_pathptr(newstream, (pathPtr)pathnode);
+ set_cinfo(newstream, (CInfo)NULL);
+ set_clausetype(newstream, XFUNC_UNKNOWN);
+
+ /* base case: we're at a leaf, call xfunc_series_llel */
+ if (!is_join(pathnode))
+ {
+ /* form a fleshed-out copy of the stream */
+ Stream fullstream = xfunc_complete_stream(streamroot);
+
+ /* sort it via series-llel */
+ if (xfunc_series_llel(fullstream))
+ *progressp = true;
+
+ /* free up the copy */
+ xfunc_free_stream(fullstream);
+ }
+ else
+ {
+ /* visit left child */
+ xfunc_predmig((JoinPath)get_outerjoinpath(pathnode),
+ streamroot, newstream, progressp);
+
+ /* visit right child */
+ xfunc_predmig((JoinPath)get_innerjoinpath(pathnode),
+ streamroot, newstream, progressp);
+ }
+
+ /* remove this node */
+ if (get_upstream(newstream))
+ set_downstream((Stream)get_upstream(newstream), (StreamPtr)NULL);
+ pfree(newstream);
+}
+
+/*
+ ** xfunc_series_llel
+ ** A flavor of Monma and Sidney's Series-Parallel algorithm.
+ ** Traverse stream downwards. When you find a node with restrictions on it,
+ ** call xfunc_llel_chains on the substream from root to that node.
+ */
+static bool xfunc_series_llel(Stream stream)
+{
+ Stream temp, next;
+ bool progress = false;
+
+ for (temp = stream; temp != (Stream)NULL; temp = next)
+ {
+ next = (Stream)xfunc_get_downjoin(temp);
+ /*
+ ** if there are restrictions/secondary join clauses above this
+ ** node, call xfunc_llel_chains
+ */
+ if (get_upstream(temp) && is_clause((Stream)get_upstream(temp)))
+ if (xfunc_llel_chains(stream, temp))
+ progress = true;
+ }
+ return(progress);
+}
+
+/*
+ ** xfunc_llel_chains
+ ** A flavor of Monma and Sidney's Parallel Chains algorithm.
+ ** Given a stream which has been well-ordered except for its lowermost
+ ** restrictions/2-ary joins, pull up the restrictions/2-arys as appropriate.
+ ** What that means here is to form groups in the chain above the lowest
+ ** join node above bottom inclusive, and then take all the restrictions
+ ** following bottom, and try to pull them up as far as possible.
+ */
+static bool xfunc_llel_chains(Stream root, Stream bottom)
+{
+ bool progress = false;
+ Stream origstream;
+ Stream tmpstream, pathstream;
+ Stream rootcopy = root;
+
+ Assert(xfunc_check_stream(root));
+
+ /* xfunc_prdmig_pullup will need an unmodified copy of the stream */
+ origstream = (Stream)copyObject((Node)root);
+
+ /* form groups among ill-ordered nodes */
+ xfunc_form_groups(root, bottom);
+
+ /* sort chain by rank */
+ Assert(xfunc_in_stream(bottom, root));
+ rootcopy = xfunc_stream_qsort(root, bottom);
+
+ /*
+ ** traverse sorted stream -- if any restriction has moved above a join,
+ ** we must pull it up in the plan. That is, make plan tree
+ ** reflect order of sorted stream.
+ */
+ for (tmpstream = rootcopy,
+ pathstream = (Stream)xfunc_get_downjoin(rootcopy);
+ tmpstream != (Stream)NULL && pathstream != (Stream)NULL;
+ tmpstream = (Stream)get_downstream(tmpstream))
+ {
+ if (is_clause(tmpstream)
+ && get_pathptr(pathstream) != get_pathptr(tmpstream))
+ {
+ /*
+ ** If restriction moved above a Join after sort, we pull it
+ ** up in the join plan.
+ ** If restriction moved down, we ignore it.
+ ** This is because Joey's Sequoia paper proves that
+ ** restrictions should never move down. If this
+ ** one were moved down, it would violate "semantic correctness",
+ ** i.e. it would be lower than the attributes it references.
+ */
+ Assert(xfunc_num_relids(pathstream)>xfunc_num_relids(tmpstream));
+ progress =
+ xfunc_prdmig_pullup(origstream, tmpstream,
+ (JoinPath)get_pathptr(pathstream));
+ }
+ if (get_downstream(tmpstream))
+ pathstream =
+ (Stream)xfunc_get_downjoin((Stream)get_downstream(tmpstream));
+ }
+
+ /* free up origstream */
+ xfunc_free_stream(origstream);
+ return(progress);
+}
+
+/*
+ ** xfunc_complete_stream --
+ ** Given a stream composed of join nodes only, make a copy containing the
+ ** join nodes along with the associated restriction nodes.
+ */
+static Stream xfunc_complete_stream(Stream stream)
+{
+ Stream tmpstream, copystream, curstream = (Stream)NULL;
+
+ copystream = (Stream)copyObject((Node)stream);
+ Assert(xfunc_check_stream(copystream));
+
+ curstream = copystream;
+ Assert(!is_clause(curstream));
+
+ /* curstream = (Stream)xfunc_get_downjoin(curstream); */
+
+ while(curstream != (Stream)NULL)
+ {
+ xfunc_add_clauses(curstream);
+ curstream = (Stream)xfunc_get_downjoin(curstream);
+ }
+
+ /* find top of stream and return it */
+ for (tmpstream = copystream; get_upstream(tmpstream) != (StreamPtr)NULL;
+ tmpstream = (Stream)get_upstream(tmpstream))
+ /* no body in for loop */;
+
+ return(tmpstream);
+}
+
+/*
+ ** xfunc_prdmig_pullup
+ ** pullup a clause in a path above joinpath. Since the JoinPath tree
+ ** doesn't have upward pointers, it's difficult to deal with. Thus we
+ ** require the original stream, which maintains pointers to all the path
+ ** nodes. We use the original stream to find out what joins are
+ ** above the clause.
+ */
+static bool
+xfunc_prdmig_pullup(Stream origstream, Stream pullme, JoinPath joinpath)
+{
+ CInfo clauseinfo = get_cinfo(pullme);
+ bool progress = false;
+ Stream upjoin, orignode, temp;
+ int whichchild;
+
+ /* find node in origstream that contains clause */
+ for (orignode = origstream;
+ orignode != (Stream) NULL
+ && get_cinfo(orignode) != clauseinfo;
+ orignode = (Stream)get_downstream(orignode))
+ /* empty body in for loop */ ;
+ if (!orignode)
+ elog(WARN, "Didn't find matching node in original stream");
+
+
+ /* pull up this node as far as it should go */
+ for (upjoin = (Stream)xfunc_get_upjoin(orignode);
+ upjoin != (Stream)NULL
+ && (JoinPath)get_pathptr((Stream)xfunc_get_downjoin(upjoin))
+ != joinpath;
+ upjoin = (Stream)xfunc_get_upjoin(upjoin))
+ {
+#ifdef DEBUG
+ elog(DEBUG, "pulling up in xfunc_predmig_pullup!");
+#endif
+ /* move clause up in path */
+ if (get_pathptr((Stream)get_downstream(upjoin))
+ == (pathPtr)get_outerjoinpath((JoinPath)get_pathptr(upjoin)))
+ whichchild = OUTER;
+ else whichchild = INNER;
+ clauseinfo = xfunc_pullup((Path)get_pathptr((Stream)get_downstream(upjoin)),
+ (JoinPath)get_pathptr(upjoin),
+ clauseinfo,
+ whichchild,
+ get_clausetype(orignode));
+ set_pathptr(pullme, get_pathptr(upjoin));
+ /* pullme has been moved into locclauseinfo */
+ set_clausetype(pullme, XFUNC_LOCPRD);
+
+ /*
+ ** xfunc_pullup makes new path nodes for children of
+ ** get_pathptr(current). We must modify the stream nodes to point
+ ** to these path nodes
+ */
+ if (whichchild == OUTER)
+ {
+ for(temp = (Stream)get_downstream(upjoin); is_clause(temp);
+ temp = (Stream)get_downstream(temp))
+ set_pathptr
+ (temp, (pathPtr)
+ get_outerjoinpath((JoinPath)get_pathptr(upjoin)));
+ set_pathptr
+ (temp,
+ (pathPtr)get_outerjoinpath((JoinPath)get_pathptr(upjoin)));
+ }
+ else
+ {
+ for(temp = (Stream)get_downstream(upjoin); is_clause(temp);
+ temp = (Stream)get_downstream(temp))
+ set_pathptr
+ (temp, (pathPtr)
+ get_innerjoinpath((JoinPath)get_pathptr(upjoin)));
+ set_pathptr
+ (temp, (pathPtr)
+ get_innerjoinpath((JoinPath)get_pathptr(upjoin)));
+ }
+ progress = true;
+ }
+ if (!progress)
+ elog(DEBUG, "didn't succeed in pulling up in xfunc_prdmig_pullup");
+ return(progress);
+}
+
+/*
+ ** xfunc_form_groups --
+ ** A group is a pair of stream nodes a,b such that a is constrained to
+ ** precede b (for instance if a and b are both joins), but rank(a) > rank(b).
+ ** In such a situation, Monma and Sidney prove that no clauses should end
+ ** up between a and b, and therefore we may treat them as a group, with
+ ** selectivity equal to the product of their selectivities, and cost
+ ** equal to the cost of the first plus the selectivity of the first times the
+ ** cost of the second. We define each node to be in a group by itself,
+ ** and then repeatedly find adjacent groups which are ordered by descending
+ ** rank, and make larger groups. You know that two adjacent nodes are in a
+ ** group together if the lower has groupup set to true. They will both have
+ ** the same groupcost and groupsel (since they're in the same group!)
+ */
+static void xfunc_form_groups(Query* queryInfo, Stream root, Stream bottom)
+{
+ Stream temp, parent;
+ int lowest = xfunc_num_relids((Stream)xfunc_get_upjoin(bottom));
+ bool progress;
+ LispValue primjoin;
+ int whichchild;
+
+ if (!lowest) return; /* no joins in stream, so no groups */
+
+ /* initialize groups to be single nodes */
+ for (temp = root;
+ temp != (Stream)NULL && temp != bottom;
+ temp = (Stream)get_downstream(temp))
+ {
+ /* if a Join node */
+ if (!is_clause(temp))
+ {
+ if (get_pathptr((Stream)get_downstream(temp))
+ == (pathPtr)get_outerjoinpath((JoinPath)get_pathptr(temp)))
+ whichchild = OUTER;
+ else whichchild = INNER;
+ set_groupcost(temp,
+ xfunc_join_expense((JoinPath)get_pathptr(temp),
+ whichchild));
+ if (primjoin = xfunc_primary_join((JoinPath)get_pathptr(temp)))
+ {
+ set_groupsel(temp,
+ compute_clause_selec(queryInfo,
+ primjoin, NIL));
+ }
+ else
+ {
+ set_groupsel(temp,1.0);
+ }
+ }
+ else /* a restriction, or 2-ary join pred */
+ {
+ set_groupcost(temp,
+ xfunc_expense(queryInfo,
+ get_clause(get_cinfo(temp))));
+ set_groupsel(temp,
+ compute_clause_selec(queryInfo,
+ get_clause(get_cinfo(temp)),
+ NIL));
+ }
+ set_groupup(temp,false);
+ }
+
+ /* make passes upwards, forming groups */
+ do
+ {
+ progress = false;
+ for (temp = (Stream)get_upstream(bottom);
+ temp != (Stream)NULL;
+ temp = (Stream)get_upstream(temp))
+ {
+ /* check for grouping with node upstream */
+ if (!get_groupup(temp) && /* not already grouped */
+ (parent = (Stream)get_upstream(temp)) != (Stream)NULL &&
+ /* temp is a join or temp is the top of a group */
+ (is_join((Path)get_pathptr(temp)) ||
+ get_downstream(temp) &&
+ get_groupup((Stream)get_downstream(temp))) &&
+ get_grouprank(parent) < get_grouprank(temp))
+ {
+ progress = true; /* we formed a new group */
+ set_groupup(temp,true);
+ set_groupcost(temp,
+ get_groupcost(temp) +
+ get_groupsel(temp) * get_groupcost(parent));
+ set_groupsel(temp,get_groupsel(temp) * get_groupsel(parent));
+
+ /* fix costs and sels of all members of group */
+ xfunc_setup_group(temp, bottom);
+ }
+ }
+ } while(progress);
+}
+
+
+/* ------------------- UTILITY FUNCTIONS ------------------------- */
+
+/*
+ ** xfunc_free_stream --
+ ** walk down a stream and pfree it
+ */
+static void xfunc_free_stream(Stream root)
+{
+ Stream cur, next;
+
+ Assert(xfunc_check_stream(root));
+
+ if (root != (Stream)NULL)
+ for (cur = root; cur != (Stream)NULL; cur = next)
+ {
+ next = (Stream)get_downstream(cur);
+ pfree(cur);
+ }
+}
+
+/*
+ ** xfunc_add<_clauses
+ ** find any clauses above current, and insert them into stream as
+ ** appropriate. Return uppermost clause inserted, or current if none.
+ */
+static Stream xfunc_add_clauses(Stream current)
+{
+ Stream topnode = current;
+ LispValue temp;
+ LispValue primjoin;
+
+ /* first add in the local clauses */
+ foreach(temp, get_locclauseinfo((Path)get_pathptr(current)))
+ {
+ topnode =
+ xfunc_streaminsert((CInfo)lfirst(temp), topnode,
+ XFUNC_LOCPRD);
+ }
+
+ /* and add in the join clauses */
+ if (IsA(get_pathptr(current),JoinPath))
+ {
+ primjoin = xfunc_primary_join((JoinPath)get_pathptr(current));
+ foreach(temp, get_pathclauseinfo((JoinPath)get_pathptr(current)))
+ {
+ if (!equal(get_clause((CInfo)lfirst(temp)), primjoin))
+ topnode =
+ xfunc_streaminsert((CInfo)lfirst(temp), topnode,
+ XFUNC_JOINPRD);
+ }
+ }
+ return(topnode);
+}
+
+
+/*
+ ** xfunc_setup_group
+ ** find all elements of stream that are grouped with node and are above
+ ** bottom, and set their groupcost and groupsel to be the same as node's.
+ */
+static void xfunc_setup_group(Stream node, Stream bottom)
+{
+ Stream temp;
+
+ if (node != bottom)
+ /* traverse downwards */
+ for (temp = (Stream)get_downstream(node);
+ temp != (Stream)NULL && temp != bottom;
+ temp = (Stream)get_downstream(temp))
+ {
+ if (!get_groupup(temp)) break;
+ else
+ {
+ set_groupcost(temp, get_groupcost(node));
+ set_groupsel(temp, get_groupsel(node));
+ }
+ }
+
+ /* traverse upwards */
+ for (temp = (Stream)get_upstream(node); temp != (Stream)NULL;
+ temp = (Stream)get_upstream(temp))
+ {
+ if (!get_groupup((Stream)get_downstream(temp))) break;
+ else
+ {
+ set_groupcost(temp, get_groupcost(node));
+ set_groupsel(temp, get_groupsel(node));
+ }
+ }
+}
+
+
+/*
+ ** xfunc_streaminsert
+ ** Make a new Stream node to hold clause, and insert it above current.
+ ** Return new node.
+ */
+static Stream
+xfunc_streaminsert(CInfo clauseinfo,
+ Stream current,
+ int clausetype) /* XFUNC_LOCPRD or XFUNC_JOINPRD */
+{
+ Stream newstream = RMakeStream();
+ set_upstream(newstream, get_upstream(current));
+ if (get_upstream(current))
+ set_downstream((Stream)(get_upstream(current)), (StreamPtr)newstream);
+ set_upstream(current, (StreamPtr)newstream);
+ set_downstream(newstream, (StreamPtr)current);
+ set_pathptr(newstream, get_pathptr(current));
+ set_cinfo(newstream, clauseinfo);
+ set_clausetype(newstream, clausetype);
+ return(newstream);
+}
+
+/*
+ ** Given a Stream node, find the number of relids referenced in the pathnode
+ ** associated with the stream node. The number of relids gives a unique
+ ** ordering on the joins in a stream, which we use to compare the height of
+ ** join nodes.
+ */
+static int xfunc_num_relids(Stream node)
+{
+ if (!node || !IsA(get_pathptr(node),JoinPath))
+ return(0);
+ else return(length
+ (get_relids(get_parent((JoinPath)get_pathptr(node)))));
+}
+
+/*
+ ** xfunc_get_downjoin --
+ ** Given a stream node, find the next lowest node which points to a
+ ** join predicate or a scan node.
+ */
+static StreamPtr xfunc_get_downjoin(Stream node)
+{
+ Stream temp;
+
+ if (!is_clause(node)) /* if this is a join */
+ node = (Stream)get_downstream(node);
+ for (temp = node; temp && is_clause(temp);
+ temp = (Stream)get_downstream(temp))
+ /* empty body in for loop */ ;
+
+ return((StreamPtr)temp);
+}
+
+/*
+ ** xfunc_get_upjoin --
+ ** same as above, but upwards.
+ */
+static StreamPtr xfunc_get_upjoin(Stream node)
+{
+ Stream temp;
+
+ if (!is_clause(node)) /* if this is a join */
+ node = (Stream)get_upstream(node);
+ for (temp = node; temp && is_clause(temp);
+ temp = (Stream)get_upstream(temp))
+ /* empty body in for loop */ ;
+
+ return((StreamPtr)temp);
+}
+
+/*
+ ** xfunc_stream_qsort --
+ ** Given a stream, sort by group rank the elements in the stream from the
+ ** node "bottom" up. DESTRUCTIVELY MODIFIES STREAM! Returns new root.
+ */
+static Stream xfunc_stream_qsort(Stream root, Stream bottom)
+{
+ int i;
+ size_t num;
+ Stream *nodearray, output;
+ Stream tmp;
+
+ /* find size of list */
+ for (num = 0, tmp = root; tmp != bottom;
+ tmp = (Stream)get_downstream(tmp))
+ num ++;
+ if (num <= 1) return (root);
+
+ /* copy elements of the list into an array */
+ nodearray = (Stream *) palloc(num * sizeof(Stream));
+
+ for (tmp = root, i = 0; tmp != bottom;
+ tmp = (Stream)get_downstream(tmp), i++)
+ nodearray[i] = tmp;
+
+ /* sort the array */
+ pg_qsort(nodearray, num, sizeof(LispValue), xfunc_stream_compare);
+
+ /* paste together the array elements */
+ output = nodearray[num - 1];
+ set_upstream(output, (StreamPtr)NULL);
+ for (i = num - 2; i >= 0; i--)
+ {
+ set_downstream(nodearray[i+1], (StreamPtr)nodearray[i]);
+ set_upstream(nodearray[i], (StreamPtr)nodearray[i+1]);
+ }
+ set_downstream(nodearray[0], (StreamPtr)bottom);
+ if (bottom)
+ set_upstream(bottom, (StreamPtr)nodearray[0]);
+
+ Assert(xfunc_check_stream(output));
+ return(output);
+}
+
+/*
+ ** xfunc_stream_compare
+ ** comparison function for xfunc_stream_qsort.
+ ** Compare nodes by group rank. If group ranks are equal, ensure that
+ ** join nodes appear in same order as in plan tree.
+ */
+static int xfunc_stream_compare(void *arg1, void *arg2)
+{
+ Stream stream1 = *(Stream *) arg1;
+ Stream stream2 = *(Stream *) arg2;
+ Cost rank1, rank2;
+
+ rank1 = get_grouprank(stream1);
+ rank2 = get_grouprank(stream2);
+
+ if (rank1 > rank2) return(1);
+ else if (rank1 < rank2) return(-1);
+ else
+ {
+ if (is_clause(stream1) && is_clause(stream2))
+ return(0); /* doesn't matter what order if both are restrictions */
+ else if (!is_clause(stream1) && !is_clause(stream2))
+ {
+ if (xfunc_num_relids(stream1) < xfunc_num_relids(stream2))
+ return(-1);
+ else return(1);
+ }
+ else if (is_clause(stream1) && !is_clause(stream2))
+ {
+ if (xfunc_num_relids(stream1) == xfunc_num_relids(stream2))
+ /* stream1 is a restriction over stream2 */
+ return(1);
+ else return(-1);
+ }
+ else if (!is_clause(stream1) && is_clause(stream2))
+ {
+ /* stream2 is a restriction over stream1: never push down */
+ return(-1);
+ }
+ }
+}
+
+/* ------------------ DEBUGGING ROUTINES ---------------------------- */
+
+/*
+ ** Make sure all pointers in stream make sense. Make sure no joins are
+ ** out of order.
+ */
+static bool xfunc_check_stream(Stream node)
+{
+ Stream temp;
+ int numrelids, tmp;
+
+ /* set numrelids higher than max */
+ if (!is_clause(node))
+ numrelids = xfunc_num_relids(node) + 1;
+ else if (xfunc_get_downjoin(node))
+ numrelids = xfunc_num_relids((Stream)xfunc_get_downjoin(node)) + 1;
+ else numrelids = 1;
+
+ for (temp = node; get_downstream(temp); temp = (Stream)get_downstream(temp))
+ {
+ if ((Stream)get_upstream((Stream)get_downstream(temp)) != temp)
+ {
+ elog(WARN, "bad pointers in stream");
+ return(false);
+ }
+ if (!is_clause(temp))
+ {
+ if ((tmp = xfunc_num_relids(temp)) >= numrelids)
+ {
+ elog(WARN, "Joins got reordered!");
+ return(false);
+ }
+ numrelids = tmp;
+ }
+ }
+
+ return(true);
+}
+
+/*
+ ** xfunc_in_stream
+ ** check if node is in stream
+ */
+static bool xfunc_in_stream(Stream node, Stream stream)
+{
+ Stream temp;
+
+ for (temp = stream; temp; temp = (Stream)get_downstream(temp))
+ if (temp == node) return(1);
+ return(0);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * prune.c--
+ * Routines to prune redundant paths and relations
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/prune.c,v 1.1.1.1 1996/07/09 06:21:36 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/relation.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/cost.h"
+#include "optimizer/paths.h"
+#include "optimizer/pathnode.h"
+
+#include "utils/elog.h"
+
+
+static List *prune_joinrel(Rel *rel, List *other_rels);
+
+/*
+ * prune-joinrels--
+ * Removes any redundant relation entries from a list of rel nodes
+ * 'rel-list'.
+ *
+ * Returns the resulting list.
+ *
+ */
+List *prune_joinrels(List *rel_list)
+{
+ List *temp_list = NIL;
+
+ if (rel_list != NIL) {
+ temp_list = lcons(lfirst(rel_list),
+ prune_joinrels(prune_joinrel((Rel*)lfirst(rel_list),
+ lnext(rel_list))));
+ }
+ return(temp_list);
+}
+
+/*
+ * prune-joinrel--
+ * Prunes those relations from 'other-rels' that are redundant with
+ * 'rel'. A relation is redundant if it is built up of the same
+ * relations as 'rel'. Paths for the redundant relation are merged into
+ * the pathlist of 'rel'.
+ *
+ * Returns a list of non-redundant relations, and sets the pathlist field
+ * of 'rel' appropriately.
+ *
+ */
+static List *
+prune_joinrel(Rel *rel, List *other_rels)
+{
+ List *i = NIL;
+ List *t_list = NIL;
+ List *temp_node = NIL;
+ Rel *other_rel = (Rel *)NULL;
+
+ foreach(i, other_rels) {
+ other_rel = (Rel*)lfirst(i);
+ if(same(rel->relids, other_rel->relids)) {
+ rel->pathlist = add_pathlist(rel,
+ rel->pathlist,
+ other_rel->pathlist);
+ t_list = nconc(t_list, NIL); /* XXX is this right ? */
+ } else {
+ temp_node = lcons(other_rel, NIL);
+ t_list = nconc(t_list,temp_node);
+ }
+ }
+ return(t_list);
+}
+
+/*
+ * prune-rel-paths--
+ * For each relation entry in 'rel-list' (which corresponds to a join
+ * relation), set pointers to the unordered path and cheapest paths
+ * (if the unordered path isn't the cheapest, it is pruned), and
+ * reset the relation's size field to reflect the join.
+ *
+ * Returns nothing of interest.
+ *
+ */
+void
+prune_rel_paths(List *rel_list)
+{
+ List *x = NIL;
+ List *y = NIL;
+ Path *path;
+ Rel *rel = (Rel*)NULL;
+ JoinPath *cheapest = (JoinPath*)NULL;
+
+ foreach(x, rel_list) {
+ rel = (Rel*)lfirst(x);
+ foreach(y, rel->pathlist) {
+ path = (Path*)lfirst(y);
+
+ if(!path->p_ordering.ord.sortop) {
+ break;
+ }
+ }
+ cheapest = (JoinPath*)prune_rel_path(rel, path);
+ if (IsA_JoinPath(cheapest))
+ {
+ rel->size = compute_joinrel_size(cheapest);
+ }
+ else
+ elog(WARN, "non JoinPath called");
+ }
+}
+
+
+/*
+ * prune-rel-path--
+ * Compares the unordered path for a relation with the cheapest path. If
+ * the unordered path is not cheapest, it is pruned.
+ *
+ * Resets the pointers in 'rel' for unordered and cheapest paths.
+ *
+ * Returns the cheapest path.
+ *
+ */
+Path *
+prune_rel_path(Rel *rel, Path *unorderedpath)
+{
+ Path *cheapest = set_cheapest(rel, rel->pathlist);
+
+ /* don't prune if not pruneable -- JMH, 11/23/92 */
+ if(unorderedpath != cheapest
+ && rel->pruneable) {
+
+ rel->unorderedpath = (Path *)NULL;
+ rel->pathlist = lremove(unorderedpath, rel->pathlist);
+ } else {
+ rel->unorderedpath = (Path *)unorderedpath;
+ }
+
+ return(cheapest);
+}
+
+/*
+ * merge-joinrels--
+ * Given two lists of rel nodes that are already
+ * pruned, merge them into one pruned rel node list
+ *
+ * 'rel-list1' and
+ * 'rel-list2' are the rel node lists
+ *
+ * Returns one pruned rel node list
+ */
+List *
+merge_joinrels(List *rel_list1, List *rel_list2)
+{
+ List *xrel = NIL;
+
+ foreach(xrel,rel_list1) {
+ Rel *rel = (Rel*)lfirst(xrel);
+ rel_list2 = prune_joinrel(rel,rel_list2);
+ }
+ return(append(rel_list1, rel_list2));
+}
+
+/*
+ * prune_oldrels--
+ * If all the joininfo's in a rel node are inactive,
+ * that means that this node has been joined into
+ * other nodes in all possible ways, therefore
+ * this node can be discarded. If not, it will cause
+ * extra complexity of the optimizer.
+ *
+ * old_rels is a list of rel nodes
+ *
+ * Returns a new list of rel nodes
+ */
+List *prune_oldrels(List *old_rels)
+{
+ Rel *rel;
+ List *joininfo_list, *xjoininfo;
+
+ if(old_rels == NIL)
+ return(NIL);
+
+ rel = (Rel*)lfirst(old_rels);
+ joininfo_list = rel->joininfo;
+ if(joininfo_list == NIL)
+ return (lcons(rel, prune_oldrels(lnext(old_rels))));
+
+ foreach(xjoininfo, joininfo_list) {
+ JInfo *joininfo = (JInfo*)lfirst(xjoininfo);
+ if(!joininfo->inactive)
+ return (lcons(rel, prune_oldrels(lnext(old_rels))));
+ }
+ return(prune_oldrels(lnext(old_rels)));
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * xfunc.c--
+ * Utility routines to handle expensive function optimization.
+ * Includes xfunc_trypullup(), which attempts early pullup of predicates
+ * to allow for maximal pruning.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/xfunc.c,v 1.1.1.1 1996/07/09 06:21:36 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef WIN32
+#include /* for MAXFLOAT on most systems */
+#else
+#include
+#define MAXFLOAT DBL_MAX
+#endif /* WIN32 */
+
+#include /* for MAXFLOAT on SunOS */
+#include
+
+#include "postgres.h"
+#include "nodes/pg_list.h"
+#include "nodes/nodes.h"
+#include "nodes/primnodes.h"
+#include "nodes/relation.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/syscache.h"
+#include "catalog/pg_proc.h"
+#include "catalog/pg_type.h"
+#include "utils/syscache.h"
+#include "catalog/pg_language.h"
+#include "planner/xfunc.h"
+#include "planner/clauses.h"
+#include "planner/pathnode.h"
+#include "planner/internal.h"
+#include "planner/cost.h"
+#include "planner/keys.h"
+#include "planner/tlist.h"
+#include "lib/lispsort.h"
+#include "access/heapam.h"
+#include "tcop/dest.h"
+#include "storage/buf_internals.h" /* for NBuffers */
+#include "optimizer/tlist.h" /* for get_expr */
+
+#define ever ; 1 ;
+
+/* local funcs */
+static int xfunc_card_unreferenced(Query *queryInfo,
+ Expr *clause, Relid referenced); */
+
+/*
+** xfunc_trypullup --
+** Preliminary pullup of predicates, to allow for maximal pruning.
+** Given a relation, check each of its paths and see if you can
+** pullup clauses from its inner and outer.
+*/
+
+void xfunc_trypullup(Rel rel)
+{
+ LispValue y; /* list ptr */
+ CInfo maxcinfo; /* The CInfo to pull up, as calculated by
+ xfunc_shouldpull() */
+ JoinPath curpath; /* current path in list */
+ int progress; /* has progress been made this time through? */
+ int clausetype;
+
+ do {
+ progress = false; /* no progress yet in this iteration */
+ foreach(y, get_pathlist(rel)) {
+ curpath = (JoinPath)lfirst(y);
+
+ /*
+ ** for each operand, attempt to pullup predicates until first
+ ** failure.
+ */
+ for(ever) {
+ /* No, the following should NOT be '==' !! */
+ if (clausetype =
+ xfunc_shouldpull((Path)get_innerjoinpath(curpath),
+ curpath, INNER, &maxcinfo)) {
+
+ xfunc_pullup((Path)get_innerjoinpath(curpath),
+ curpath, maxcinfo, INNER, clausetype);
+ progress = true;
+ }else
+ break;
+ }
+ for(ever) {
+
+ /* No, the following should NOT be '==' !! */
+ if (clausetype =
+ xfunc_shouldpull((Path)get_outerjoinpath(curpath),
+ curpath, OUTER, &maxcinfo)) {
+
+ xfunc_pullup((Path)get_outerjoinpath(curpath),
+ curpath, maxcinfo, OUTER, clausetype);
+ progress = true;
+ }else
+ break;
+ }
+
+ /*
+ ** make sure the unpruneable flag bubbles up, i.e.
+ ** if anywhere below us in the path pruneable is false,
+ ** then pruneable should be false here
+ */
+ if (get_pruneable(get_parent(curpath)) &&
+ (!get_pruneable(get_parent
+ ((Path)get_innerjoinpath(curpath))) ||
+ !get_pruneable(get_parent((Path)
+ get_outerjoinpath(curpath))))) {
+
+ set_pruneable(get_parent(curpath),false);
+ progress = true;
+ }
+ }
+ } while(progress);
+}
+
+/*
+ ** xfunc_shouldpull --
+ ** find clause with highest rank, and decide whether to pull it up
+ ** from child to parent. Currently we only pullup secondary join clauses
+ ** that are in the pathclauseinfo. Secondary hash and sort clauses are
+ ** left where they are.
+ ** If we find an expensive function but decide *not* to pull it up,
+ ** we'd better set the unpruneable flag. -- JMH, 11/11/92
+ **
+ ** Returns: 0 if nothing left to pullup
+ ** XFUNC_LOCPRD if a local predicate is to be pulled up
+ ** XFUNC_JOINPRD if a secondary join predicate is to be pulled up
+ */
+int xfunc_shouldpull(Query* queryInfo,
+ Path childpath,
+ JoinPath parentpath,
+ int whichchild,
+ CInfo *maxcinfopt) /* Out: pointer to clause to pullup */
+{
+ LispValue clauselist, tmplist; /* lists of clauses */
+ CInfo maxcinfo; /* clause to pullup */
+ LispValue primjoinclause /* primary join clause */
+ = xfunc_primary_join(parentpath);
+ Cost tmprank, maxrank = (-1 * MAXFLOAT); /* ranks of clauses */
+ Cost joinselec = 0; /* selectivity of the join predicate */
+ Cost joincost = 0; /* join cost + primjoinclause cost */
+ int retval = XFUNC_LOCPRD;
+
+ clauselist = get_locclauseinfo(childpath);
+
+ if (clauselist != LispNil) {
+ /* find local predicate with maximum rank */
+ for (tmplist = clauselist,
+ maxcinfo = (CInfo) lfirst(tmplist),
+ maxrank = xfunc_rank(get_clause(maxcinfo));
+ tmplist != LispNil;
+ tmplist = lnext(tmplist)) {
+
+ if ((tmprank = xfunc_rank(get_clause((CInfo)lfirst(tmplist))))
+ > maxrank) {
+ maxcinfo = (CInfo) lfirst(tmplist);
+ maxrank = tmprank;
+ }
+ }
+ }
+
+ /*
+ ** If child is a join path, and there are multiple join clauses,
+ ** see if any join clause has even higher rank than the highest
+ ** local predicate
+ */
+ if (is_join(childpath) && xfunc_num_join_clauses((JoinPath)childpath) > 1)
+ for (tmplist = get_pathclauseinfo((JoinPath)childpath);
+ tmplist != LispNil;
+ tmplist = lnext(tmplist)) {
+
+ if (tmplist != LispNil &&
+ (tmprank = xfunc_rank(get_clause((CInfo) lfirst(tmplist))))
+ > maxrank) {
+ maxcinfo = (CInfo) lfirst(tmplist);
+ maxrank = tmprank;
+ retval = XFUNC_JOINPRD;
+ }
+ }
+ if (maxrank == (-1 * MAXFLOAT)) /* no expensive clauses */
+ return(0);
+
+ /*
+ ** Pullup over join if clause is higher rank than join, or if
+ ** join is nested loop and current path is inner child (note that
+ ** restrictions on the inner of a nested loop don't buy you anything --
+ ** you still have to scan the entire inner relation each time).
+ ** Note that the cost of a secondary join clause is only what's
+ ** calculated by xfunc_expense(), since the actual joining
+ ** (i.e. the usual path_cost) is paid for by the primary join clause.
+ */
+ if (primjoinclause != LispNil) {
+ joinselec = compute_clause_selec(queryInfo, primjoinclause, LispNil);
+ joincost = xfunc_join_expense(parentpath, whichchild);
+
+ if (XfuncMode == XFUNC_PULLALL ||
+ (XfuncMode != XFUNC_WAIT &&
+ ((joincost != 0 &&
+ (maxrank = xfunc_rank(get_clause(maxcinfo))) >
+ ((joinselec - 1.0) / joincost))
+ || (joincost == 0 && joinselec < 1)
+ || (!is_join(childpath)
+ && (whichchild == INNER)
+ && IsA(parentpath,JoinPath)
+ && !IsA(parentpath,HashPath)
+ && !IsA(parentpath,MergePath))))) {
+
+ *maxcinfopt = maxcinfo;
+ return(retval);
+
+ }else if (maxrank != -(MAXFLOAT)) {
+ /*
+ ** we've left an expensive restriction below a join. Since
+ ** we may pullup this restriction in predmig.c, we'd best
+ ** set the Rel of this join to be unpruneable
+ */
+ set_pruneable(get_parent(parentpath), false);
+ /* and fall through */
+ }
+ }
+ return(0);
+}
+
+
+/*
+ ** xfunc_pullup --
+ ** move clause from child pathnode to parent pathnode. This operation
+ ** makes the child pathnode produce a larger relation than it used to.
+ ** This means that we must construct a new Rel just for the childpath,
+ ** although this Rel will not be added to the list of Rels to be joined up
+ ** in the query; it's merely a parent for the new childpath.
+ ** We also have to fix up the path costs of the child and parent.
+ **
+ ** Now returns a pointer to the new pulled-up CInfo. -- JMH, 11/18/92
+ */
+CInfo xfunc_pullup(Query* queryInfo,
+ Path childpath,
+ JoinPath parentpath,
+ CInfo cinfo, /* clause to pull up */
+ int whichchild,/* whether child is INNER or OUTER of join */
+ int clausetype)/* whether clause to pull is join or local */
+{
+ Path newkid;
+ Rel newrel;
+ Cost pulled_selec;
+ Cost cost;
+ CInfo newinfo;
+
+ /* remove clause from childpath */
+ newkid = (Path)copyObject((Node)childpath);
+ if (clausetype == XFUNC_LOCPRD) {
+ set_locclauseinfo(newkid,
+ xfunc_LispRemove((LispValue)cinfo,
+ (List)get_locclauseinfo(newkid)));
+ }else {
+ set_pathclauseinfo
+ ((JoinPath)newkid,
+ xfunc_LispRemove((LispValue)cinfo,
+ (List)get_pathclauseinfo((JoinPath)newkid)));
+ }
+
+ /*
+ ** give the new child path its own Rel node that reflects the
+ ** lack of the pulled-up predicate
+ */
+ pulled_selec = compute_clause_selec(queryInfo,
+ get_clause(cinfo), LispNil);
+ xfunc_copyrel(get_parent(newkid), &newrel);
+ set_parent(newkid, newrel);
+ set_pathlist(newrel, lcons(newkid, NIL));
+ set_unorderedpath(newrel, (PathPtr)newkid);
+ set_cheapestpath(newrel, (PathPtr)newkid);
+ set_size(newrel,
+ (Count)((Cost)get_size(get_parent(childpath)) / pulled_selec));
+
+ /*
+ ** fix up path cost of newkid. To do this we subtract away all the
+ ** xfunc_costs of childpath, then recompute the xfunc_costs of newkid
+ */
+ cost = get_path_cost(newkid) - xfunc_get_path_cost(childpath);
+ Assert(cost >= 0);
+ set_path_cost(newkid, cost);
+ cost = get_path_cost(newkid) + xfunc_get_path_cost(newkid);
+ set_path_cost(newkid, cost);
+
+ /*
+ ** We copy the cinfo, since it may appear in other plans, and we're going
+ ** to munge it. -- JMH, 7/22/92
+ */
+ newinfo = (CInfo)copyObject((Node)cinfo);
+
+ /*
+ ** Fix all vars in the clause
+ ** to point to the right varno and varattno in parentpath
+ */
+ xfunc_fixvars(get_clause(newinfo), newrel, whichchild);
+
+ /* add clause to parentpath, and fix up its cost. */
+ set_locclauseinfo(parentpath,
+ lispCons((LispValue)newinfo,
+ (LispValue)get_locclauseinfo(parentpath)));
+ /* put new childpath into the path tree */
+ if (whichchild == INNER) {
+ set_innerjoinpath(parentpath, (pathPtr)newkid);
+ }else {
+ set_outerjoinpath(parentpath, (pathPtr)newkid);
+ }
+
+ /*
+ ** recompute parentpath cost from scratch -- the cost
+ ** of the join method has changed
+ */
+ cost = xfunc_total_path_cost(parentpath);
+ set_path_cost(parentpath, cost);
+
+ return(newinfo);
+}
+
+/*
+ ** calculate (selectivity-1)/cost.
+ */
+Cost xfunc_rank(Query *queryInfo,LispValue clause)
+{
+ Cost selec = compute_clause_selec(queryInfo, clause, LispNil);
+ Cost cost = xfunc_expense(queryInfo,clause);
+
+ if (cost == 0)
+ if (selec > 1) return(MAXFLOAT);
+ else return(-(MAXFLOAT));
+ return((selec - 1)/cost);
+}
+
+/*
+ ** Find the "global" expense of a clause; i.e. the local expense divided
+ ** by the cardinalities of all the base relations of the query that are *not*
+ ** referenced in the clause.
+ */
+Cost xfunc_expense(Query* queryInfo, clause)
+ LispValue clause;
+{
+ Cost cost = xfunc_local_expense(clause);
+
+ if (cost)
+ {
+ Count card = xfunc_card_unreferenced(queryInfo, clause, LispNil);
+ if (card)
+ cost /= card;
+ }
+
+ return(cost);
+}
+
+/*
+ ** xfunc_join_expense --
+ ** Find global expense of a join clause
+ */
+Cost xfunc_join_expense(Query *queryInfo, JoinPath path, int whichchild)
+{
+ LispValue primjoinclause = xfunc_primary_join(path);
+
+ /*
+ ** the second argument to xfunc_card_unreferenced reflects all the
+ ** relations involved in the join clause, i.e. all the relids in the Rel
+ ** of the join clause
+ */
+ Count card = 0;
+ Cost cost = xfunc_expense_per_tuple(path, whichchild);
+
+ card = xfunc_card_unreferenced(queryInfo,
+ primjoinclause,
+ get_relids(get_parent(path)));
+ if (primjoinclause)
+ cost += xfunc_local_expense(primjoinclause);
+
+ if (card) cost /= card;
+
+ return(cost);
+}
+
+/*
+ ** Recursively find the per-tuple expense of a clause. See
+ ** xfunc_func_expense for more discussion.
+ */
+Cost xfunc_local_expense(LispValue clause)
+{
+ Cost cost = 0; /* running expense */
+ LispValue tmpclause;
+
+ /* First handle the base case */
+ if (IsA(clause,Const) || IsA(clause,Var) || IsA(clause,Param))
+ return(0);
+ /* now other stuff */
+ else if (IsA(clause,Iter))
+ /* Too low. Should multiply by the expected number of iterations. */
+ return(xfunc_local_expense(get_iterexpr((Iter)clause)));
+ else if (IsA(clause,ArrayRef))
+ return(xfunc_local_expense(get_refexpr((ArrayRef)clause)));
+ else if (fast_is_clause(clause))
+ return(xfunc_func_expense((LispValue)get_op(clause),
+ (LispValue)get_opargs(clause)));
+ else if (fast_is_funcclause(clause))
+ return(xfunc_func_expense((LispValue)get_function(clause),
+ (LispValue)get_funcargs(clause)));
+ else if (fast_not_clause(clause))
+ return(xfunc_local_expense(lsecond(clause)));
+ else if (fast_or_clause(clause)) {
+ /* find cost of evaluating each disjunct */
+ for (tmpclause = lnext(clause); tmpclause != LispNil;
+ tmpclause = lnext(tmpclause))
+ cost += xfunc_local_expense(lfirst(tmpclause));
+ return(cost);
+ }else {
+ elog(WARN, "Clause node of undetermined type");
+ return(-1);
+ }
+}
+
+/*
+ ** xfunc_func_expense --
+ ** given a Func or Oper and its args, find its expense.
+ ** Note: in Stonebraker's SIGMOD '91 paper, he uses a more complicated metric
+ ** than the one here. We can ignore the expected number of tuples for
+ ** our calculations; we just need the per-tuple expense. But he also
+ ** proposes components to take into account the costs of accessing disk and
+ ** archive. We didn't adopt that scheme here; eventually the vacuum
+ ** cleaner should be able to tell us what percentage of bytes to find on
+ ** which storage level, and that should be multiplied in appropriately
+ ** in the cost function below. Right now we don't model the cost of
+ ** accessing secondary or tertiary storage, since we don't have sufficient
+ ** stats to do it right.
+ */
+Cost xfunc_func_expense(LispValue node, LispValue args)
+{
+ HeapTuple tupl; /* the pg_proc tuple for each function */
+ Form_pg_proc proc; /* a data structure to hold the pg_proc tuple */
+ int width = 0; /* byte width of the field referenced by each clause */
+ RegProcedure funcid; /* ID of function associate with node */
+ Cost cost = 0; /* running expense */
+ LispValue tmpclause;
+ LispValue operand; /* one operand of an operator */
+
+ if (IsA(node,Oper)) {
+ /* don't trust the opid in the Oper node. Use the opno. */
+ if (!(funcid = get_opcode(get_opno((Oper)node))))
+ elog(WARN, "Oper's function is undefined");
+ }else {
+ funcid = get_funcid((Func)node);
+ }
+
+ /* look up tuple in cache */
+ tupl = SearchSysCacheTuple(PROOID, ObjectIdGetDatum(funcid),0,0,0);
+ if (!HeapTupleIsValid(tupl))
+ elog(WARN, "Cache lookup failed for procedure %d", funcid);
+ proc = (Form_pg_proc) GETSTRUCT(tupl);
+
+ /*
+ ** if it's a Postquel function, its cost is stored in the
+ ** associated plan.
+ */
+ if (proc->prolang == SQLlanguageId) {
+ LispValue tmpplan;
+ List planlist;
+
+ if (IsA(node,Oper) || get_func_planlist((Func)node) == LispNil) {
+ Oid *argOidVect; /* vector of argtypes */
+ char *pq_src; /* text of PQ function */
+ int nargs; /* num args to PQ function */
+ QueryTreeList *queryTree_list; /* dummy variable */
+
+ /*
+ ** plan the function, storing it in the Func node for later
+ ** use by the executor.
+ */
+ pq_src = (char *) textout(&(proc->prosrc));
+ nargs = proc->pronargs;
+ if (nargs > 0)
+ argOidVect = proc->proargtypes;
+ planlist = (List)pg_plan(pq_src, argOidVect, nargs,
+ &parseTree_list, None);
+ if (IsA(node,Func))
+ set_func_planlist((Func)node, planlist);
+
+ }else {/* plan has been cached inside the Func node already */
+ planlist = get_func_planlist((Func)node);
+ }
+
+ /*
+ ** Return the sum of the costs of the plans (the PQ function
+ ** may have many queries in its body).
+ */
+ foreach(tmpplan, planlist)
+ cost += get_cost((Plan)lfirst(tmpplan));
+ return(cost);
+ }else { /* it's a C function */
+ /*
+ ** find the cost of evaluating the function's arguments
+ ** and the width of the operands
+ */
+ for (tmpclause = args; tmpclause != LispNil;
+ tmpclause = lnext(tmpclause)) {
+
+ if ((operand = lfirst(tmpclause)) != LispNil) {
+ cost += xfunc_local_expense(operand);
+ width += xfunc_width(operand);
+ }
+ }
+
+ /*
+ ** when stats become available, add in cost of accessing secondary
+ ** and tertiary storage here.
+ */
+ return(cost +
+ (Cost)proc->propercall_cpu +
+ (Cost)proc->properbyte_cpu * (Cost)proc->probyte_pct/100.00 *
+ (Cost)width
+ /*
+ * Pct_of_obj_in_mem
+ DISK_COST * proc->probyte_pct/100.00 * width
+ * Pct_of_obj_on_disk +
+ ARCH_COST * proc->probyte_pct/100.00 * width
+ * Pct_of_obj_on_arch
+ */
+ );
+ }
+}
+
+/*
+ ** xfunc_width --
+ ** recursively find the width of a expression
+ */
+
+int xfunc_width(LispValue clause)
+{
+ Relation rd; /* Relation Descriptor */
+ HeapTuple tupl; /* structure to hold a cached tuple */
+ TypeTupleForm type; /* structure to hold a type tuple */
+ int retval = 0;
+
+ if (IsA(clause,Const)) {
+ /* base case: width is the width of this constant */
+ retval = get_constlen((Const) clause);
+ goto exit;
+ }else if (IsA(clause,ArrayRef)) {
+ /* base case: width is width of the refelem within the array */
+ retval = get_refelemlength((ArrayRef)clause);
+ goto exit;
+ }else if (IsA(clause,Var)) {
+ /* base case: width is width of this attribute */
+ tupl = SearchSysCacheTuple(TYPOID,
+ PointerGetDatum(get_vartype((Var)clause)),
+ 0,0,0);
+ if (!HeapTupleIsValid(tupl))
+ elog(WARN, "Cache lookup failed for type %d",
+ get_vartype((Var)clause));
+ type = (TypeTupleForm) GETSTRUCT(tupl);
+ if (get_varattno((Var)clause) == 0) {
+ /* clause is a tuple. Get its width */
+ rd = heap_open(type->typrelid);
+ retval = xfunc_tuple_width(rd);
+ heap_close(rd);
+ }else {
+ /* attribute is a base type */
+ retval = type->typlen;
+ }
+ goto exit;
+ }else if (IsA(clause,Param)) {
+ if (typeid_get_relid(get_paramtype((Param)clause))) {
+ /* Param node returns a tuple. Find its width */
+ rd = heap_open(typeid_get_relid(get_paramtype((Param)clause)));
+ retval = xfunc_tuple_width(rd);
+ heap_close(rd);
+ }else if (get_param_tlist((Param)clause) != LispNil) {
+ /* Param node projects a complex type */
+ Assert(length(get_param_tlist((Param)clause)) == 1); /* sanity */
+ retval =
+ xfunc_width((LispValue)
+ get_expr(lfirst(get_param_tlist((Param)clause))));
+ }else {
+ /* Param node returns a base type */
+ retval = tlen(get_id_type(get_paramtype((Param)clause)));
+ }
+ goto exit;
+ }else if (IsA(clause,Iter)) {
+ /*
+ ** An Iter returns a setof things, so return the width of a single
+ ** thing.
+ ** Note: THIS MAY NOT WORK RIGHT WHEN AGGS GET FIXED,
+ ** SINCE AGG FUNCTIONS CHEW ON THE WHOLE SETOF THINGS!!!!
+ ** This whole Iter business is bogus, anyway.
+ */
+ retval = xfunc_width(get_iterexpr((Iter)clause));
+ goto exit;
+ }else if (fast_is_clause(clause)) {
+ /*
+ ** get function associated with this Oper, and treat this as
+ ** a Func
+ */
+ tupl = SearchSysCacheTuple(OPROID,
+ ObjectIdGetDatum(get_opno((Oper)get_op(clause))),
+ 0,0,0);
+ if (!HeapTupleIsValid(tupl))
+ elog(WARN, "Cache lookup failed for procedure %d",
+ get_opno((Oper)get_op(clause)));
+ return(xfunc_func_width
+ ((RegProcedure)(((OperatorTupleForm)(GETSTRUCT(tupl)))->oprcode),
+ (LispValue)get_opargs(clause)));
+ }else if (fast_is_funcclause(clause)) {
+ Func func = (Func)get_function(clause);
+ if (get_func_tlist(func) != LispNil) {
+ /* this function has a projection on it. Get the length
+ of the projected attribute */
+ Assert(length(get_func_tlist(func)) == 1); /* sanity */
+ retval =
+ xfunc_width((LispValue)
+ get_expr(lfirst(get_func_tlist(func))));
+ goto exit;
+ }else {
+ return(xfunc_func_width((RegProcedure)get_funcid(func),
+ (LispValue)get_funcargs(clause)));
+ }
+ }else {
+ elog(WARN, "Clause node of undetermined type");
+ return(-1);
+ }
+
+ exit:
+ if (retval == -1)
+ retval = VARLEN_DEFAULT;
+ return(retval);
+}
+
+/*
+ ** xfunc_card_unreferenced:
+ ** find all relations not referenced in clause, and multiply their
+ ** cardinalities. Ignore relation of cardinality 0.
+ ** User may pass in referenced list, if they know it (useful
+ ** for joins).
+ */
+static Count
+xfunc_card_unreferenced(Query *queryInfo,
+ LispValue clause, Relid referenced)
+{
+ Relid unreferenced, allrelids = LispNil;
+ LispValue temp;
+
+ /* find all relids of base relations referenced in query */
+ foreach (temp,queryInfo->base_relation_list_)
+ {
+ Assert(lnext(get_relids((Rel)lfirst(temp))) == LispNil);
+ allrelids = lappend(allrelids,
+ lfirst(get_relids((Rel)lfirst(temp))));
+ }
+
+ /* find all relids referenced in query but not in clause */
+ if (!referenced)
+ referenced = xfunc_find_references(clause);
+ unreferenced = set_difference(allrelids, referenced);
+
+ return(xfunc_card_product(unreferenced));
+}
+
+/*
+ ** xfunc_card_product
+ ** multiple together cardinalities of a list relations.
+ */
+Count xfunc_card_product(Query *queryInfo, Relid relids)
+{
+ LispValue cinfonode;
+ LispValue temp;
+ Rel currel;
+ Cost tuples;
+ Count retval = 0;
+
+ foreach(temp,relids) {
+ currel = get_rel(lfirst(temp));
+ tuples = get_tuples(currel);
+
+ if (tuples) { /* not of cardinality 0 */
+ /* factor in the selectivity of all zero-cost clauses */
+ foreach (cinfonode, get_clauseinfo(currel)) {
+ if (!xfunc_expense(queryInfo,get_clause((CInfo)lfirst(cinfonode))))
+ tuples *=
+ compute_clause_selec(queryInfo,
+ get_clause((CInfo)lfirst(cinfonode)),
+ LispNil);
+ }
+
+ if (retval == 0) retval = tuples;
+ else retval *= tuples;
+ }
+ }
+ if (retval == 0) retval = 1; /* saves caller from dividing by zero */
+ return(retval);
+}
+
+
+/*
+ ** xfunc_find_references:
+ ** Traverse a clause and find all relids referenced in the clause.
+ */
+List xfunc_find_references(LispValue clause)
+{
+ List retval = (List)LispNil;
+ LispValue tmpclause;
+
+ /* Base cases */
+ if (IsA(clause,Var))
+ return(lispCons(lfirst(get_varid((Var)clause)), LispNil));
+ else if (IsA(clause,Const) || IsA(clause,Param))
+ return((List)LispNil);
+
+ /* recursion */
+ else if (IsA(clause,Iter))
+ /* Too low. Should multiply by the expected number of iterations. maybe */
+ return(xfunc_find_references(get_iterexpr((Iter)clause)));
+ else if (IsA(clause,ArrayRef))
+ return(xfunc_find_references(get_refexpr((ArrayRef)clause)));
+ else if (fast_is_clause(clause)) {
+ /* string together result of all operands of Oper */
+ for (tmpclause = (LispValue)get_opargs(clause); tmpclause != LispNil;
+ tmpclause = lnext(tmpclause))
+ retval = nconc(retval, xfunc_find_references(lfirst(tmpclause)));
+ return(retval);
+ }else if (fast_is_funcclause(clause)) {
+ /* string together result of all args of Func */
+ for (tmpclause = (LispValue)get_funcargs(clause);
+ tmpclause != LispNil;
+ tmpclause = lnext(tmpclause))
+ retval = nconc(retval, xfunc_find_references(lfirst(tmpclause)));
+ return(retval);
+ }else if (fast_not_clause(clause))
+ return(xfunc_find_references(lsecond(clause)));
+ else if (fast_or_clause(clause)) {
+ /* string together result of all operands of OR */
+ for (tmpclause = lnext(clause); tmpclause != LispNil;
+ tmpclause = lnext(tmpclause))
+ retval = nconc(retval, xfunc_find_references(lfirst(tmpclause)));
+ return(retval);
+ }else {
+ elog(WARN, "Clause node of undetermined type");
+ return((List)LispNil);
+ }
+}
+
+/*
+ ** xfunc_primary_join:
+ ** Find the primary join clause: for Hash and Merge Joins, this is the
+ ** min rank Hash or Merge clause, while for Nested Loop it's the
+ ** min rank pathclause
+ */
+LispValue xfunc_primary_join(JoinPath pathnode)
+{
+ LispValue joinclauselist = get_pathclauseinfo(pathnode);
+ CInfo mincinfo;
+ LispValue tmplist;
+ LispValue minclause = LispNil;
+ Cost minrank, tmprank;
+
+ if (IsA(pathnode,MergePath))
+ {
+ for(tmplist = get_path_mergeclauses((MergePath)pathnode),
+ minclause = lfirst(tmplist),
+ minrank = xfunc_rank(minclause);
+ tmplist != LispNil;
+ tmplist = lnext(tmplist))
+ if ((tmprank = xfunc_rank(lfirst(tmplist)))
+ < minrank)
+ {
+ minrank = tmprank;
+ minclause = lfirst(tmplist);
+ }
+ return(minclause);
+ }
+ else if (IsA(pathnode,HashPath))
+ {
+ for(tmplist = get_path_hashclauses((HashPath)pathnode),
+ minclause = lfirst(tmplist),
+ minrank = xfunc_rank(minclause);
+ tmplist != LispNil;
+ tmplist = lnext(tmplist))
+ if ((tmprank = xfunc_rank(lfirst(tmplist)))
+ < minrank)
+ {
+ minrank = tmprank;
+ minclause = lfirst(tmplist);
+ }
+ return(minclause);
+ }
+
+ /* if we drop through, it's nested loop join */
+ if (joinclauselist == LispNil)
+ return(LispNil);
+
+ for(tmplist = joinclauselist, mincinfo = (CInfo) lfirst(joinclauselist),
+ minrank = xfunc_rank(get_clause((CInfo) lfirst(tmplist)));
+ tmplist != LispNil;
+ tmplist = lnext(tmplist))
+ if ((tmprank = xfunc_rank(get_clause((CInfo) lfirst(tmplist))))
+ < minrank)
+ {
+ minrank = tmprank;
+ mincinfo = (CInfo) lfirst(tmplist);
+ }
+ return((LispValue)get_clause(mincinfo));
+}
+
+/*
+ ** xfunc_get_path_cost
+ ** get the expensive function costs of the path
+ */
+Cost xfunc_get_path_cost(Query *queryInfo, Path pathnode)
+{
+ Cost cost = 0;
+ LispValue tmplist;
+ Cost selec = 1.0;
+
+ /*
+ ** first add in the expensive local function costs.
+ ** We ensure that the clauses are sorted by rank, so that we
+ ** know (via selectivities) the number of tuples that will be checked
+ ** by each function. If we're not doing any optimization of expensive
+ ** functions, we don't sort.
+ */
+ if (XfuncMode != XFUNC_OFF)
+ set_locclauseinfo(pathnode, lisp_qsort(get_locclauseinfo(pathnode),
+ xfunc_cinfo_compare));
+ for(tmplist = get_locclauseinfo(pathnode), selec = 1.0;
+ tmplist != LispNil;
+ tmplist = lnext(tmplist))
+ {
+ cost += (Cost)(xfunc_local_expense(get_clause((CInfo)lfirst(tmplist)))
+ * (Cost)get_tuples(get_parent(pathnode)) * selec);
+ selec *= compute_clause_selec(queryInfo,
+ get_clause((CInfo)lfirst(tmplist)),
+ LispNil);
+ }
+
+ /*
+ ** Now add in any node-specific expensive function costs.
+ ** Again, we must ensure that the clauses are sorted by rank.
+ */
+ if (IsA(pathnode,JoinPath))
+ {
+ if (XfuncMode != XFUNC_OFF)
+ set_pathclauseinfo((JoinPath)pathnode, lisp_qsort
+ (get_pathclauseinfo((JoinPath)pathnode),
+ xfunc_cinfo_compare));
+ for(tmplist = get_pathclauseinfo((JoinPath)pathnode), selec = 1.0;
+ tmplist != LispNil;
+ tmplist = lnext(tmplist))
+ {
+ cost += (Cost)(xfunc_local_expense(get_clause((CInfo)lfirst(tmplist)))
+ * (Cost)get_tuples(get_parent(pathnode)) * selec);
+ selec *= compute_clause_selec(queryInfo,
+ get_clause((CInfo)lfirst(tmplist)),
+ LispNil);
+ }
+ }
+ if (IsA(pathnode,HashPath))
+ {
+ if (XfuncMode != XFUNC_OFF)
+ set_path_hashclauses
+ ((HashPath)pathnode,
+ lisp_qsort(get_path_hashclauses((HashPath)pathnode),
+ xfunc_clause_compare));
+ for(tmplist = get_path_hashclauses((HashPath)pathnode), selec = 1.0;
+ tmplist != LispNil;
+ tmplist = lnext(tmplist))
+ {
+ cost += (Cost)(xfunc_local_expense(lfirst(tmplist))
+ * (Cost)get_tuples(get_parent(pathnode)) * selec);
+ selec *= compute_clause_selec(queryInfo,
+ lfirst(tmplist), LispNil);
+ }
+ }
+ if (IsA(pathnode,MergePath))
+ {
+ if (XfuncMode != XFUNC_OFF)
+ set_path_mergeclauses
+ ((MergePath)pathnode,
+ lisp_qsort(get_path_mergeclauses((MergePath)pathnode),
+ xfunc_clause_compare));
+ for(tmplist = get_path_mergeclauses((MergePath)pathnode), selec = 1.0;
+ tmplist != LispNil;
+ tmplist = lnext(tmplist))
+ {
+ cost += (Cost)(xfunc_local_expense(lfirst(tmplist))
+ * (Cost)get_tuples(get_parent(pathnode)) * selec);
+ selec *= compute_clause_selec(queryInfo,
+ lfirst(tmplist), LispNil);
+ }
+ }
+ Assert(cost >= 0);
+ return(cost);
+}
+
+/*
+ ** Recalculate the cost of a path node. This includes the basic cost of the
+ ** node, as well as the cost of its expensive functions.
+ ** We need to do this to the parent after pulling a clause from a child into a
+ ** parent. Thus we should only be calling this function on JoinPaths.
+ */
+Cost xfunc_total_path_cost(JoinPath pathnode)
+{
+ Cost cost = xfunc_get_path_cost((Path)pathnode);
+
+ Assert(IsA(pathnode,JoinPath));
+ if (IsA(pathnode,MergePath))
+ {
+ MergePath mrgnode = (MergePath)pathnode;
+ cost += cost_mergesort(get_path_cost((Path)get_outerjoinpath(mrgnode)),
+ get_path_cost((Path)get_innerjoinpath(mrgnode)),
+ get_outersortkeys(mrgnode),
+ get_innersortkeys(mrgnode),
+ get_tuples(get_parent((Path)get_outerjoinpath
+ (mrgnode))),
+ get_tuples(get_parent((Path)get_innerjoinpath
+ (mrgnode))),
+ get_width(get_parent((Path)get_outerjoinpath
+ (mrgnode))),
+ get_width(get_parent((Path)get_innerjoinpath
+ (mrgnode))));
+ Assert(cost >= 0);
+ return(cost);
+ }
+ else if (IsA(pathnode,HashPath))
+ {
+ HashPath hashnode = (HashPath)pathnode;
+ cost += cost_hashjoin(get_path_cost((Path)get_outerjoinpath(hashnode)),
+ get_path_cost((Path)get_innerjoinpath(hashnode)),
+ get_outerhashkeys(hashnode),
+ get_innerhashkeys(hashnode),
+ get_tuples(get_parent((Path)get_outerjoinpath
+ (hashnode))),
+ get_tuples(get_parent((Path)get_innerjoinpath
+ (hashnode))),
+ get_width(get_parent((Path)get_outerjoinpath
+ (hashnode))),
+ get_width(get_parent((Path)get_innerjoinpath
+ (hashnode))));
+ Assert (cost >= 0);
+ return(cost);
+ }
+ else /* Nested Loop Join */
+ {
+ cost += cost_nestloop(get_path_cost((Path)get_outerjoinpath(pathnode)),
+ get_path_cost((Path)get_innerjoinpath(pathnode)),
+ get_tuples(get_parent((Path)get_outerjoinpath
+ (pathnode))),
+ get_tuples(get_parent((Path)get_innerjoinpath
+ (pathnode))),
+ get_pages(get_parent((Path)get_outerjoinpath
+ (pathnode))),
+ IsA(get_innerjoinpath(pathnode),IndexPath));
+ Assert(cost >= 0);
+ return(cost);
+ }
+}
+
+
+/*
+ ** xfunc_expense_per_tuple --
+ ** return the expense of the join *per-tuple* of the input relation.
+ ** The cost model here is that a join costs
+ ** k*card(outer)*card(inner) + l*card(outer) + m*card(inner) + n
+ **
+ ** We treat the l and m terms by considering them to be like restrictions
+ ** constrained to be right under the join. Thus the cost per inner and
+ ** cost per outer of the join is different, reflecting these virtual nodes.
+ **
+ ** The cost per tuple of outer is k + l/referenced(inner). Cost per tuple
+ ** of inner is k + m/referenced(outer).
+ ** The constants k, l, m and n depend on the join method. Measures here are
+ ** based on the costs in costsize.c, with fudging for HashJoin and Sorts to
+ ** make it fit our model (the 'q' in HashJoin results in a
+ ** card(outer)/card(inner) term, and sorting results in a log term.
+
+ */
+Cost xfunc_expense_per_tuple(JoinPath joinnode, int whichchild)
+{
+ Rel outerrel = get_parent((Path)get_outerjoinpath(joinnode));
+ Rel innerrel = get_parent((Path)get_innerjoinpath(joinnode));
+ Count outerwidth = get_width(outerrel);
+ Count outers_per_page = ceil(BLCKSZ/(outerwidth + sizeof(HeapTupleData)));
+
+ if (IsA(joinnode,HashPath))
+ {
+ if (whichchild == INNER)
+ return((1 + _CPU_PAGE_WEIGHT_)*outers_per_page/NBuffers);
+ else
+ return(((1 + _CPU_PAGE_WEIGHT_)*outers_per_page/NBuffers)
+ + _CPU_PAGE_WEIGHT_
+ / xfunc_card_product(get_relids(innerrel)));
+ }
+ else if (IsA(joinnode,MergePath))
+ {
+ /* assumes sort exists, and costs one (I/O + CPU) per tuple */
+ if (whichchild == INNER)
+ return((2*_CPU_PAGE_WEIGHT_ + 1)
+ / xfunc_card_product(get_relids(outerrel)));
+ else
+ return((2*_CPU_PAGE_WEIGHT_ + 1)
+ / xfunc_card_product(get_relids(innerrel)));
+ }
+ else /* nestloop */
+ {
+ Assert(IsA(joinnode,JoinPath));
+ return(_CPU_PAGE_WEIGHT_);
+ }
+}
+
+/*
+ ** xfunc_fixvars --
+ ** After pulling up a clause, we must walk its expression tree, fixing Var
+ ** nodes to point to the correct varno (either INNER or OUTER, depending
+ ** on which child the clause was pulled from), and the right varattno in the
+ ** target list of the child's former relation. If the target list of the
+ ** child Rel does not contain the attribute we need, we add it.
+ */
+void xfunc_fixvars(LispValue clause, /* clause being pulled up */
+ Rel rel, /* rel it's being pulled from */
+ int varno) /* whether rel is INNER or OUTER of join */
+{
+ LispValue tmpclause; /* temporary variable */
+ TargetEntry *tle; /* tlist member corresponding to var */
+
+
+ if (IsA(clause,Const) || IsA(clause,Param)) return;
+ else if (IsA(clause,Var))
+ {
+ /* here's the meat */
+ tle = tlistentry_member((Var)clause, get_targetlist(rel));
+ if (tle == LispNil)
+ {
+ /*
+ ** The attribute we need is not in the target list,
+ ** so we have to add it.
+ **
+ */
+ add_tl_element(rel, (Var)clause);
+ tle = tlistentry_member((Var)clause, get_targetlist(rel));
+ }
+ set_varno(((Var)clause), varno);
+ set_varattno(((Var)clause), get_resno(get_resdom(get_entry(tle))));
+ }
+ else if (IsA(clause,Iter))
+ xfunc_fixvars(get_iterexpr((Iter)clause), rel, varno);
+ else if (fast_is_clause(clause))
+ {
+ xfunc_fixvars(lfirst(lnext(clause)), rel, varno);
+ xfunc_fixvars(lfirst(lnext(lnext(clause))), rel, varno);
+ }
+ else if (fast_is_funcclause(clause))
+ for (tmpclause = lnext(clause); tmpclause != LispNil;
+ tmpclause = lnext(tmpclause))
+ xfunc_fixvars(lfirst(tmpclause), rel, varno);
+ else if (fast_not_clause(clause))
+ xfunc_fixvars(lsecond(clause), rel, varno);
+ else if (fast_or_clause(clause))
+ for (tmpclause = lnext(clause); tmpclause != LispNil;
+ tmpclause = lnext(tmpclause))
+ xfunc_fixvars(lfirst(tmpclause), rel, varno);
+ else
+ {
+ elog(WARN, "Clause node of undetermined type");
+ }
+}
+
+
+/*
+ ** Comparison function for lisp_qsort() on a list of CInfo's.
+ ** arg1 and arg2 should really be of type (CInfo *).
+ */
+int xfunc_cinfo_compare(void *arg1, void *arg2)
+{
+ CInfo info1 = *(CInfo *) arg1;
+ CInfo info2 = *(CInfo *) arg2;
+
+ LispValue clause1 = (LispValue) get_clause(info1),
+ clause2 = (LispValue) get_clause(info2);
+
+ return(xfunc_clause_compare((void *) &clause1, (void *) &clause2));
+}
+
+/*
+ ** xfunc_clause_compare: comparison function for lisp_qsort() that compares two
+ ** clauses based on expense/(1 - selectivity)
+ ** arg1 and arg2 are really pointers to clauses.
+ */
+int xfunc_clause_compare(void *arg1, void *arg2)
+{
+ LispValue clause1 = *(LispValue *) arg1;
+ LispValue clause2 = *(LispValue *) arg2;
+ Cost rank1, /* total xfunc rank of clause1 */
+ rank2; /* total xfunc rank of clause2 */
+
+ rank1 = xfunc_rank(clause1);
+ rank2 = xfunc_rank(clause2);
+
+ if ( rank1 < rank2)
+ return(-1);
+ else if (rank1 == rank2)
+ return(0);
+ else return(1);
+}
+
+/*
+ ** xfunc_disjunct_sort --
+ ** given a list of clauses, for each clause sort the disjuncts by cost
+ ** (this assumes the predicates have been converted to Conjunctive NF)
+ ** Modifies the clause list!
+ */
+void xfunc_disjunct_sort(LispValue clause_list)
+{
+ LispValue temp;
+
+ foreach(temp, clause_list)
+ if(or_clause(lfirst(temp)))
+ lnext(lfirst(temp)) =
+ lisp_qsort(lnext(lfirst(temp)), xfunc_disjunct_compare);
+}
+
+
+/*
+ ** xfunc_disjunct_compare: comparison function for qsort() that compares two
+ ** disjuncts based on cost/selec.
+ ** arg1 and arg2 are really pointers to disjuncts
+ */
+int xfunc_disjunct_compare(Query* queryInfo, void *arg1, void *arg2)
+{
+ LispValue disjunct1 = *(LispValue *) arg1;
+ LispValue disjunct2 = *(LispValue *) arg2;
+ Cost cost1, /* total cost of disjunct1 */
+ cost2, /* total cost of disjunct2 */
+ selec1,
+ selec2;
+ Cost rank1, rank2;
+
+ cost1 = xfunc_expense(queryInfo, disjunct1);
+ cost2 = xfunc_expense(queryInfo, disjunct2);
+ selec1 = compute_clause_selec(queryInfo,
+ disjunct1, LispNil);
+ selec2 = compute_clause_selec(queryInfo,
+ disjunct2, LispNil);
+
+ if (selec1 == 0)
+ rank1 = MAXFLOAT;
+ else if (cost1 == 0)
+ rank1 = 0;
+ else
+ rank1 = cost1/selec1;
+
+ if (selec2 == 0)
+ rank2 = MAXFLOAT;
+ else if (cost2 == 0)
+ rank2 = 0;
+ else
+ rank2 = cost2/selec2;
+
+ if ( rank1 < rank2)
+ return(-1);
+ else if (rank1 == rank2)
+ return(0);
+ else return(1);
+}
+
+/* ------------------------ UTILITY FUNCTIONS ------------------------------- */
+/*
+ ** xfunc_func_width --
+ ** Given a function OID and operands, find the width of the return value.
+ */
+int xfunc_func_width(RegProcedure funcid, LispValue args)
+{
+ Relation rd; /* Relation Descriptor */
+ HeapTuple tupl; /* structure to hold a cached tuple */
+ Form_pg_proc proc; /* structure to hold the pg_proc tuple */
+ TypeTupleForm type; /* structure to hold the pg_type tuple */
+ LispValue tmpclause;
+ int retval;
+
+ /* lookup function and find its return type */
+ Assert(RegProcedureIsValid(funcid));
+ tupl = SearchSysCacheTuple(PROOID, ObjectIdGetDatum(funcid), 0,0,0);
+ if (!HeapTupleIsValid(tupl))
+ elog(WARN, "Cache lookup failed for procedure %d", funcid);
+ proc = (Form_pg_proc) GETSTRUCT(tupl);
+
+ /* if function returns a tuple, get the width of that */
+ if (typeid_get_relid(proc->prorettype))
+ {
+ rd = heap_open(typeid_get_relid(proc->prorettype));
+ retval = xfunc_tuple_width(rd);
+ heap_close(rd);
+ goto exit;
+ }
+ else /* function returns a base type */
+ {
+ tupl = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(proc->prorettype),
+ 0,0,0);
+ if (!HeapTupleIsValid(tupl))
+ elog(WARN, "Cache lookup failed for type %d", proc->prorettype);
+ type = (TypeTupleForm) GETSTRUCT(tupl);
+ /* if the type length is known, return that */
+ if (type->typlen != -1)
+ {
+ retval = type->typlen;
+ goto exit;
+ }
+ else /* estimate the return size */
+ {
+ /* find width of the function's arguments */
+ for (tmpclause = args; tmpclause != LispNil;
+ tmpclause = lnext(tmpclause))
+ retval += xfunc_width(lfirst(tmpclause));
+ /* multiply by outin_ratio */
+ retval = (int)(proc->prooutin_ratio/100.0 * retval);
+ goto exit;
+ }
+ }
+ exit:
+ return(retval);
+}
+
+/*
+ ** xfunc_tuple_width --
+ ** Return the sum of the lengths of all the attributes of a given relation
+ */
+int xfunc_tuple_width(Relation rd)
+{
+ int i;
+ int retval = 0;
+ TupleDesc tdesc = RelationGetTupleDescriptor(rd);
+
+ for (i = 0; i < tdesc->natts; i++)
+ {
+ if (tdesc->attrs[i]->attlen != -1)
+ retval += tdesc->attrs[i]->attlen;
+ else retval += VARLEN_DEFAULT;
+ }
+
+ return(retval);
+}
+
+/*
+ ** xfunc_num_join_clauses --
+ ** Find the number of join clauses associated with this join path
+ */
+int xfunc_num_join_clauses(JoinPath path)
+{
+ int num = length(get_pathclauseinfo(path));
+ if (IsA(path,MergePath))
+ return(num + length(get_path_mergeclauses((MergePath)path)));
+ else if (IsA(path,HashPath))
+ return(num + length(get_path_hashclauses((HashPath)path)));
+ else return(num);
+}
+
+/*
+ ** xfunc_LispRemove --
+ ** Just like LispRemove, but it whines if the item to be removed ain't there
+ */
+LispValue xfunc_LispRemove(LispValue foo, List bar)
+{
+ LispValue temp = LispNil;
+ LispValue result = LispNil;
+ int sanity = false;
+
+ for (temp = bar; !null(temp); temp = lnext(temp))
+ if (! equal((Node)(foo),(Node)(lfirst(temp))) )
+ {
+ result = lappend(result,lfirst(temp));
+ }
+ else sanity = true; /* found a matching item to remove! */
+
+ if (!sanity)
+ elog(WARN, "xfunc_LispRemove: didn't find a match!");
+
+ return(result);
+}
+
+#define Node_Copy(a, b, c, d) \
+ if (NodeCopy((Node)((a)->d), (Node*)&((b)->d), c) != true) { \
+ return false; \
+ }
+
+/*
+ ** xfunc_copyrel --
+ ** Just like _copyRel, but doesn't copy the paths
+ */
+bool xfunc_copyrel(Rel from, Rel *to)
+{
+ Rel newnode;
+ Pointer (*alloc)() = palloc;
+
+ /* COPY_CHECKARGS() */
+ if (to == NULL)
+ {
+ return false;
+ }
+
+ /* COPY_CHECKNULL() */
+ if (from == NULL)
+ {
+ (*to) = NULL;
+ return true;
+ }
+
+ /* COPY_NEW(c) */
+ newnode = (Rel)(*alloc)(classSize(Rel));
+ if (newnode == NULL)
+ {
+ return false;
+ }
+
+ /* ----------------
+ * copy node superclass fields
+ * ----------------
+ */
+ CopyNodeFields((Node)from, (Node)newnode, alloc);
+
+ /* ----------------
+ * copy remainder of node
+ * ----------------
+ */
+ Node_Copy(from, newnode, alloc, relids);
+
+ newnode->indexed = from->indexed;
+ newnode->pages = from->pages;
+ newnode->tuples = from->tuples;
+ newnode->size = from->size;
+ newnode->width = from->width;
+
+ Node_Copy(from, newnode, alloc, targetlist);
+ /* No!!!! Node_Copy(from, newnode, alloc, pathlist);
+ Node_Copy(from, newnode, alloc, unorderedpath);
+ Node_Copy(from, newnode, alloc, cheapestpath); */
+#if 0 /* can't use Node_copy now. 2/95 -ay */
+ Node_Copy(from, newnode, alloc, classlist);
+ Node_Copy(from, newnode, alloc, indexkeys);
+ Node_Copy(from, newnode, alloc, ordering);
+#endif
+ Node_Copy(from, newnode, alloc, clauseinfo);
+ Node_Copy(from, newnode, alloc, joininfo);
+ Node_Copy(from, newnode, alloc, innerjoin);
+ Node_Copy(from, newnode, alloc, superrels);
+
+ (*to) = newnode;
+ return true;
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * pathnode.h--
+ * prototypes for pathnode.c, indexnode.c, relnode.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: pathnode.h,v 1.1.1.1 1996/07/09 06:21:34 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PATHNODE_H
+#define PATHNODE_H
+
+/*
+ * prototypes for pathnode.c
+ */
+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,
+ List *new_paths);
+extern Path *create_seqscan_path(Rel *rel);
+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,
+ Path *outer_path, Path *inner_path, List *keys);
+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,
+ int innersize, int outerwidth, int innerwidth, Path *outer_path,
+ Path *inner_path, List *keys, Oid operator, List *hashclauses,
+ List *outerkeys, List *innerkeys);
+
+/*
+ * prototypes for rel.c
+ */
+extern Rel *rel_member(List *relid, List *rels);
+extern Rel *get_base_rel(Query* root, int relid);
+extern Rel *get_join_rel(Query* root, List *relid);
+
+/*
+ * prototypes for indexnode.h
+ */
+extern List *find_relation_indices(Query *root,Rel *rel);
+
+#endif /* PATHNODE_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * paths.h--
+ * prototypes for various files in optimizer/paths (were separate
+ * header files
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: paths.h,v 1.1.1.1 1996/07/09 06:21:34 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PATHS_H
+#define PATHS_H
+
+/*
+ * allpaths.h
+ */
+extern List *find_paths(Query *root, List *rels);
+
+/*
+ * indxpath.h
+ * routines to generate index paths
+ */
+extern List *find_index_paths(Query *root, Rel *rel, List *indices,
+ List *clauseinfo_list,
+ List *joininfo_list);
+
+/*
+ * joinpath.h
+ * routines to create join paths
+ */
+extern void find_all_join_paths(Query *root, List *joinrels);
+
+
+/*
+ * orindxpath.h
+ */
+extern List *create_or_index_paths(Query *root, Rel *rel, List *clauses);
+
+/*
+ * hashutils.h
+ * routines to deal with hash keys and clauses
+ */
+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,
+ List *joinkeys, List *joinclauses, int which_subkey,
+ List **matchedJoinClausesPtr);
+extern List *extract_path_keys(List *joinkeys, List *tlist,
+ int which_subkey);
+extern Path *match_paths_joinkeys(List *joinkeys, PathOrder *ordering,
+ List *paths, int which_subkey);
+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,
+ int inner_relid);
+extern MInfo *match_order_mergeinfo(PathOrder *ordering,
+ List *mergeinfo_list);
+
+/*
+ * joinrels.h
+ * routines to determine which relations to join
+ */
+extern List *find_join_rels(Query *root, List *outer_rels);
+extern void add_new_joininfos(Query *root, List *joinrels, List *outerrels);
+extern List *final_join_rels(List *join_rel_list);
+
+/*
+ * prototypes for path/prune.c
+ */
+extern List *prune_joinrels(List *rel_list);
+extern void prune_rel_paths(List *rel_list);
+extern Path *prune_rel_path(Rel *rel, Path *unorderedpath);
+extern List *merge_joinrels(List *rel_list1, List *rel_list2);
+extern List *prune_oldrels(List *old_rels);
+
+#endif /* PATHS_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for optimizer/plan
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/optimizer/plan/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:37 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= createplan.c initsplan.c planmain.c planner.c \
+ setrefs.c
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * createplan.c--
+ * Routines to create the desired plan for processing a query
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.1.1.1 1996/07/09 06:21:37 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "c.h"
+
+#include "nodes/execnodes.h"
+#include "nodes/plannodes.h"
+#include "nodes/relation.h"
+#include "nodes/primnodes.h"
+#include "nodes/nodeFuncs.h"
+
+#include "nodes/makefuncs.h"
+
+#include "utils/elog.h"
+#include "utils/lsyscache.h"
+#include "utils/palloc.h"
+#include "utils/builtins.h"
+
+#include "parser/parse_query.h"
+#include "optimizer/clauseinfo.h"
+#include "optimizer/clauses.h"
+#include "optimizer/planmain.h"
+#include "optimizer/tlist.h"
+#include "optimizer/planner.h"
+#include "optimizer/xfunc.h"
+#include "optimizer/internal.h"
+
+
+#define TEMP_SORT 1
+#define TEMP_MATERIAL 2
+
+static List *switch_outer(List *clauses);
+static Scan *create_scan_node(Path *best_path, List *tlist);
+static Join *create_join_node(JoinPath *best_path, List *tlist);
+static SeqScan *create_seqscan_node(Path *best_path, List *tlist,
+ List *scan_clauses);
+static IndexScan *create_indexscan_node(IndexPath *best_path, List *tlist,
+ List *scan_clauses);
+static NestLoop *create_nestloop_node(JoinPath *best_path, List *tlist,
+ List *clauses, Plan *outer_node, List *outer_tlist,
+ Plan *inner_node, List *inner_tlist);
+static MergeJoin *create_mergejoin_node(MergePath *best_path, List *tlist,
+ List *clauses, Plan *outer_node, List *outer_tlist,
+ Plan *inner_node, List *inner_tlist);
+static HashJoin *create_hashjoin_node(HashPath *best_path, List *tlist,
+ List *clauses, Plan *outer_node, List *outer_tlist,
+ Plan *inner_node, List *inner_tlist);
+static Node *fix_indxqual_references(Node *clause, Path *index_path);
+static Temp *make_temp(List *tlist, List *keys, Oid *operators,
+ Plan *plan_node, int temptype);
+static IndexScan *make_indexscan(List *qptlist, List *qpqual, Index scanrelid,
+ List *indxid, List *indxqual);
+static NestLoop *make_nestloop(List *qptlist, List *qpqual, Plan *lefttree,
+ Plan *righttree);
+static HashJoin *make_hashjoin(List *tlist, List *qpqual,
+ List *hashclauses, Plan *lefttree, Plan *righttree);
+static Hash *make_hash(List *tlist, Var *hashkey, Plan *lefttree);
+static MergeJoin *make_mergesort(List * tlist, List *qpqual,
+ List *mergeclauses, Oid opcode, Oid *rightorder,
+ Oid *leftorder, Plan *righttree, Plan *lefttree);
+static Material *make_material(List *tlist, Oid tempid, Plan *lefttree,
+ int keycount);
+
+/*
+ * create_plan--
+ * Creates the access plan for a query by tracing backwards through the
+ * desired chain of pathnodes, starting at the node 'best-path'. For
+ * every pathnode found:
+ * (1) Create a corresponding plan node containing appropriate id,
+ * target list, and qualification information.
+ * (2) Modify ALL clauses so that attributes are referenced using
+ * relative values.
+ * (3) Target lists are not modified, but will be in another routine.
+ *
+ * best-path is the best access path
+ *
+ * Returns the optimal(?) access plan.
+ */
+Plan *
+create_plan(Path *best_path)
+{
+ List *tlist;
+ Plan *plan_node = (Plan*)NULL;
+ Rel *parent_rel;
+ int size;
+ int width;
+ int pages;
+ int tuples;
+
+ parent_rel = best_path->parent;
+ tlist = get_actual_tlist(parent_rel->targetlist);
+ size = parent_rel->size;
+ width = parent_rel->width;
+ pages = parent_rel->pages;
+ tuples = parent_rel->tuples;
+
+ switch(best_path->pathtype) {
+ case T_IndexScan :
+ case T_SeqScan :
+ plan_node = (Plan*)create_scan_node(best_path, tlist);
+ break;
+ case T_HashJoin :
+ case T_MergeJoin :
+ case T_NestLoop:
+ plan_node = (Plan*)create_join_node((JoinPath*)best_path, tlist);
+ break;
+ default:
+ /* do nothing */
+ break;
+ }
+
+ plan_node->plan_size = size;
+ plan_node->plan_width = width;
+ if (pages == 0) pages = 1;
+ plan_node->plan_tupperpage = tuples/pages;
+
+#if 0 /* fix xfunc */
+ /* sort clauses by cost/(1-selectivity) -- JMH 2/26/92 */
+ if (XfuncMode != XFUNC_OFF)
+ {
+ set_qpqual((Plan) plan_node,
+ lisp_qsort( get_qpqual((Plan) plan_node),
+ xfunc_clause_compare));
+ if (XfuncMode != XFUNC_NOR)
+ /* sort the disjuncts within each clause by cost -- JMH 3/4/92 */
+ xfunc_disjunct_sort(plan_node->qpqual);
+ }
+#endif
+
+ return(plan_node);
+}
+
+/*
+ * create_scan_node--
+ * Create a scan path for the parent relation of 'best-path'.
+ *
+ * tlist is the targetlist for the base relation scanned by 'best-path'
+ *
+ * Returns the scan node.
+ */
+static Scan *
+create_scan_node(Path *best_path, List *tlist)
+{
+
+ Scan *node;
+ List *scan_clauses;
+
+ /*
+ * Extract the relevant clauses from the parent relation and replace the
+ * operator OIDs with the corresponding regproc ids.
+ *
+ * now that local predicate clauses are copied into paths in
+ * find_rel_paths() and then (possibly) pulled up in xfunc_trypullup(),
+ * we get the relevant clauses from the path itself, not its parent
+ * relation. --- JMH, 6/15/92
+ */
+ scan_clauses = fix_opids(get_actual_clauses(best_path->locclauseinfo));
+
+ switch(best_path->pathtype) {
+ case T_SeqScan :
+ node = (Scan*)create_seqscan_node(best_path, tlist, scan_clauses);
+ break;
+
+ case T_IndexScan:
+ node = (Scan*)create_indexscan_node((IndexPath*)best_path,
+ tlist,
+ scan_clauses);
+ break;
+
+ default :
+ elog(WARN, "create_scan_node: unknown node type",
+ best_path->pathtype);
+ break;
+ }
+
+ return node;
+}
+
+/*
+ * create_join_node --
+ * Create a join path for 'best-path' and(recursively) paths for its
+ * inner and outer paths.
+ *
+ * 'tlist' is the targetlist for the join relation corresponding to
+ * 'best-path'
+ *
+ * Returns the join node.
+ */
+static Join *
+create_join_node(JoinPath *best_path, List *tlist)
+{
+ Plan *outer_node;
+ List *outer_tlist;
+ Plan *inner_node;
+ List *inner_tlist;
+ List *clauses;
+ Join *retval;
+
+ outer_node = create_plan((Path*)best_path->outerjoinpath);
+ outer_tlist = outer_node->targetlist;
+
+ inner_node = create_plan((Path*)best_path->innerjoinpath);
+ inner_tlist = inner_node->targetlist;
+
+ clauses = get_actual_clauses(best_path->pathclauseinfo);
+
+ switch(best_path->path.pathtype) {
+ case T_MergeJoin:
+ retval = (Join*)create_mergejoin_node((MergePath*)best_path,
+ tlist,
+ clauses,
+ outer_node,
+ outer_tlist,
+ inner_node,
+ inner_tlist);
+ break;
+ case T_HashJoin:
+ retval = (Join*)create_hashjoin_node((HashPath*)best_path,
+ tlist,
+ clauses,
+ outer_node,
+ outer_tlist,
+ inner_node,
+ inner_tlist);
+ break;
+ case T_NestLoop:
+ retval = (Join*)create_nestloop_node((JoinPath*)best_path,
+ tlist,
+ clauses,
+ outer_node,
+ outer_tlist,
+ inner_node,
+ inner_tlist);
+ break;
+ default:
+ /* do nothing */
+ elog(WARN, "create_join_node: unknown node type",
+ best_path->path.pathtype);
+ }
+
+#if 0
+ /*
+ ** Expensive function pullups may have pulled local predicates
+ ** into this path node. Put them in the qpqual of the plan node.
+ ** -- JMH, 6/15/92
+ */
+ if (get_locclauseinfo(best_path) != NIL)
+ set_qpqual((Plan)retval,
+ nconc(get_qpqual((Plan) retval),
+ fix_opids(get_actual_clauses
+ (get_locclauseinfo(best_path)))));
+#endif
+
+ return(retval);
+}
+
+/*****************************************************************************
+ *
+ * BASE-RELATION SCAN METHODS
+ *
+ *****************************************************************************/
+
+
+/*
+ * create_seqscan_node--
+ * Returns a seqscan node for the base relation scanned by 'best-path'
+ * with restriction clauses 'scan-clauses' and targetlist 'tlist'.
+ */
+static SeqScan *
+create_seqscan_node(Path *best_path, List *tlist, List *scan_clauses)
+{
+ SeqScan *scan_node = (SeqScan*)NULL;
+ Index scan_relid = -1;
+ List *temp;
+
+ temp = best_path->parent->relids;
+ if(temp == NULL)
+ elog(WARN,"scanrelid is empty");
+ else
+ scan_relid = (Index)lfirst(temp); /* ??? who takes care of lnext? - ay */
+ scan_node = make_seqscan(tlist,
+ scan_clauses,
+ scan_relid,
+ (Plan*)NULL);
+
+ scan_node->plan.cost = best_path->path_cost;
+
+ return(scan_node);
+}
+
+/*
+ * create_indexscan_node--
+ * Returns a indexscan node for the base relation scanned by 'best-path'
+ * with restriction clauses 'scan-clauses' and targetlist 'tlist'.
+ */
+static IndexScan *
+create_indexscan_node(IndexPath *best_path,
+ List *tlist,
+ List *scan_clauses)
+{
+ /*
+ * Extract the(first if conjunct, only if disjunct) clause from the
+ * clauseinfo list.
+ */
+ Expr *index_clause = (Expr*)NULL;
+ List *indxqual = NIL;
+ List *qpqual = NIL;
+ List *fixed_indxqual = NIL;
+ IndexScan *scan_node = (IndexScan*)NULL;
+
+
+ /*
+ * If an 'or' clause is to be used with this index, the indxqual
+ * field will contain a list of the 'or' clause arguments, e.g., the
+ * clause(OR a b c) will generate: ((a) (b) (c)). Otherwise, the
+ * indxqual will simply contain one conjunctive qualification: ((a)).
+ */
+ if (best_path->indexqual != NULL)
+ /* added call to fix_opids, JMH 6/23/92 */
+ index_clause = (Expr*)
+ lfirst(fix_opids(get_actual_clauses(best_path->indexqual)));
+
+ if (or_clause((Node*)index_clause)) {
+ List *temp = NIL;
+
+ foreach(temp, index_clause->args)
+ indxqual = lappend(indxqual, lcons(lfirst(temp), NIL));
+ } else {
+ indxqual = lcons(get_actual_clauses(best_path->indexqual),
+ NIL);
+ }
+
+ /*
+ * The qpqual field contains all restrictions except the indxqual.
+ */
+ if(or_clause((Node*)index_clause))
+ qpqual = set_difference(scan_clauses,
+ lcons(index_clause,NIL));
+ else
+ qpqual = set_difference(scan_clauses, lfirst(indxqual));
+
+ fixed_indxqual =
+ (List*)fix_indxqual_references((Node*)indxqual,(Path*)best_path);
+
+ scan_node =
+ make_indexscan(tlist,
+ qpqual,
+ lfirsti(best_path->path.parent->relids),
+ best_path->indexid,
+ fixed_indxqual);
+
+ scan_node->scan.plan.cost = best_path->path.path_cost;
+
+ return(scan_node);
+}
+
+/*****************************************************************************
+ *
+ * JOIN METHODS
+ *
+ *****************************************************************************/
+
+static NestLoop *
+create_nestloop_node(JoinPath *best_path,
+ List *tlist,
+ List *clauses,
+ Plan *outer_node,
+ List *outer_tlist,
+ Plan *inner_node,
+ List *inner_tlist)
+{
+ NestLoop *join_node = (NestLoop*)NULL;
+
+ if (IsA(inner_node,IndexScan)) {
+ /* An index is being used to reduce the number of tuples scanned in
+ * the inner relation.
+ * There will never be more than one index used in the inner
+ * scan path, so we need only consider the first set of
+ * qualifications in indxqual.
+ */
+
+ List *inner_indxqual = lfirst(((IndexScan*)inner_node)->indxqual);
+ List *inner_qual = (inner_indxqual == NULL)? NULL:lfirst(inner_indxqual);
+
+ /* If we have in fact found a join index qualification, remove these
+ * index clauses from the nestloop's join clauses and reset the
+ * inner(index) scan's qualification so that the var nodes refer to
+ * the proper outer join relation attributes.
+ */
+ if (!(qual_clause_p((Node*)inner_qual))) {
+ List *new_inner_qual = NIL;
+
+ clauses = set_difference(clauses,inner_indxqual);
+ new_inner_qual =
+ index_outerjoin_references(inner_indxqual,
+ outer_node->targetlist,
+ ((Scan*)inner_node)->scanrelid);
+ ((IndexScan*)inner_node)->indxqual =
+ lcons(new_inner_qual,NIL);
+ }
+ }else if (IsA_Join(inner_node)) {
+ inner_node = (Plan*)make_temp(inner_tlist,
+ NIL,
+ NULL,
+ inner_node,
+ TEMP_MATERIAL);
+ }
+
+ join_node = make_nestloop(tlist,
+ join_references(clauses,
+ outer_tlist,
+ inner_tlist),
+ outer_node,
+ inner_node);
+
+ join_node->join.cost = best_path->path.path_cost;
+
+ return(join_node);
+}
+
+static MergeJoin *
+create_mergejoin_node(MergePath *best_path,
+ List *tlist,
+ List *clauses,
+ Plan *outer_node,
+ List *outer_tlist,
+ Plan *inner_node,
+ List *inner_tlist)
+{
+ List *qpqual, *mergeclauses;
+ RegProcedure opcode;
+ Oid *outer_order, *inner_order;
+ MergeJoin *join_node;
+
+
+ /* Separate the mergeclauses from the other join qualification
+ * clauses and set those clauses to contain references to lower
+ * attributes.
+ */
+ qpqual = join_references(set_difference(clauses,
+ best_path->path_mergeclauses),
+ outer_tlist,
+ inner_tlist);
+
+ /* Now set the references in the mergeclauses and rearrange them so
+ * that the outer variable is always on the left.
+ */
+ mergeclauses = switch_outer(join_references(best_path->path_mergeclauses,
+ outer_tlist,
+ inner_tlist));
+
+ opcode =
+ get_opcode((best_path->jpath.path.p_ordering.ord.merge)->join_operator);
+
+ outer_order = (Oid *)palloc(sizeof(Oid)*2);
+ outer_order[0] =
+ (best_path->jpath.path.p_ordering.ord.merge)->left_operator;
+ outer_order[1] = 0;
+
+ inner_order = (Oid *)palloc(sizeof(Oid)*2);
+ inner_order[0] =
+ (best_path->jpath.path.p_ordering.ord.merge)->right_operator;
+ inner_order[1] = 0;
+
+ /* Create explicit sort paths for the outer and inner join paths if
+ * necessary. The sort cost was already accounted for in the path.
+ */
+ if (best_path->outersortkeys) {
+ Temp *sorted_outer_node = make_temp(outer_tlist,
+ best_path->outersortkeys,
+ outer_order,
+ outer_node,
+ TEMP_SORT);
+ sorted_outer_node->plan.cost = outer_node->cost;
+ outer_node = (Plan*)sorted_outer_node;
+ }
+
+ if (best_path->innersortkeys) {
+ Temp *sorted_inner_node = make_temp(inner_tlist,
+ best_path->innersortkeys,
+ inner_order,
+ inner_node,
+ TEMP_SORT);
+ sorted_inner_node->plan.cost = outer_node->cost;
+ inner_node = (Plan*)sorted_inner_node;
+ }
+
+ join_node = make_mergesort(tlist,
+ qpqual,
+ mergeclauses,
+ opcode,
+ inner_order,
+ outer_order,
+ inner_node,
+ outer_node);
+
+ join_node->join.cost = best_path->jpath.path.path_cost;
+
+ return(join_node);
+}
+
+/*
+ * create_hashjoin_node-- XXX HASH
+ *
+ * Returns a new hashjoin node.
+ *
+ * XXX hash join ops are totally bogus -- how the hell do we choose
+ * these?? at runtime? what about a hash index?
+ */
+static HashJoin *
+create_hashjoin_node(HashPath *best_path,
+ List *tlist,
+ List *clauses,
+ Plan *outer_node,
+ List *outer_tlist,
+ Plan *inner_node,
+ List *inner_tlist)
+{
+ List *qpqual;
+ List *hashclauses;
+ HashJoin *join_node;
+ Hash *hash_node;
+ Var *innerhashkey;
+
+ /* Separate the hashclauses from the other join qualification clauses
+ * and set those clauses to contain references to lower attributes.
+ */
+ qpqual =
+ join_references(set_difference(clauses,
+ best_path->path_hashclauses),
+ outer_tlist,
+ inner_tlist);
+
+ /* Now set the references in the hashclauses and rearrange them so
+ * that the outer variable is always on the left.
+ */
+ hashclauses =
+ switch_outer(join_references(best_path->path_hashclauses,
+ outer_tlist,
+ inner_tlist));
+
+ innerhashkey = get_rightop(lfirst(hashclauses));
+
+ hash_node = make_hash(inner_tlist, innerhashkey, inner_node);
+ join_node = make_hashjoin(tlist,
+ qpqual,
+ hashclauses,
+ outer_node,
+ (Plan*)hash_node);
+ join_node->join.cost = best_path->jpath.path.path_cost;
+
+ return(join_node);
+}
+
+
+/*****************************************************************************
+ *
+ * SUPPORTING ROUTINES
+ *
+ *****************************************************************************/
+
+static Node *
+fix_indxqual_references(Node *clause, Path *index_path)
+{
+ Node *newclause;
+
+ if (IsA(clause,Var)) {
+ if (lfirsti(index_path->parent->relids) == ((Var*)clause)->varno) {
+ int pos = 0;
+ int varatt = ((Var*)clause)->varattno;
+ int *indexkeys = index_path->parent->indexkeys;
+
+ if (indexkeys) {
+ while (indexkeys[pos] != 0) {
+ if(varatt == indexkeys[pos]) {
+ break;
+ }
+ pos++;
+ }
+ }
+ newclause = copyObject((Node*)clause);
+ ((Var*)newclause)->varattno = pos + 1;
+ return (newclause);
+ } else {
+ return (clause);
+ }
+ } else if(IsA(clause,Const)) {
+ return(clause);
+ } else if(is_opclause(clause) &&
+ is_funcclause((Node*)get_leftop((Expr*)clause)) &&
+ ((Func*)((Expr*)get_leftop((Expr*)clause))->oper)->funcisindex){
+ Var *newvar =
+ makeVar((Index)lfirst(index_path->parent->relids),
+ 1, /* func indices have one key */
+ ((Func*)((Expr*)clause)->oper)->functype,
+ (Index)lfirst(index_path->parent->relids),
+ 0);
+
+ return
+ ((Node*)make_opclause((Oper*)((Expr*)clause)->oper,
+ newvar,
+ get_rightop((Expr*)clause)));
+
+ } else if (IsA(clause,Expr)) {
+ Expr *expr = (Expr*)clause;
+ List *new_subclauses = NIL;
+ Node *subclause = NULL;
+ List *i = NIL;
+
+ foreach(i, expr->args) {
+ subclause = lfirst(i);
+ if(subclause)
+ new_subclauses =
+ lappend(new_subclauses,
+ fix_indxqual_references(subclause,
+ index_path));
+
+ }
+
+ /* XXX new_subclauses should be a list of the form:
+ * ( (var var) (var const) ...) ?
+ */
+ if(new_subclauses) {
+ return (Node*)
+ make_clause(expr->opType, expr->oper, new_subclauses);
+ } else {
+ return(clause);
+ }
+ } else {
+ List *oldclauses = (List*)clause;
+ List *new_subclauses = NIL;
+ Node *subclause = NULL;
+ List *i = NIL;
+
+ foreach(i, oldclauses) {
+ subclause = lfirst(i);
+ if(subclause)
+ new_subclauses =
+ lappend(new_subclauses,
+ fix_indxqual_references(subclause,
+ index_path));
+
+ }
+
+ /* XXX new_subclauses should be a list of the form:
+ * ( (var var) (var const) ...) ?
+ */
+ if(new_subclauses) {
+ return (Node*)new_subclauses;
+ } else {
+ return (clause);
+ }
+ }
+}
+
+
+/*
+ * switch_outer--
+ * Given a list of merge clauses, rearranges the elements within the
+ * clauses so the outer join variable is on the left and the inner is on
+ * the right.
+ *
+ * Returns the rearranged list ?
+ *
+ * XXX Shouldn't the operator be commuted?!
+ */
+static List *
+switch_outer(List *clauses)
+{
+ List *t_list = NIL;
+ Expr *temp = NULL;
+ List *i = NIL;
+ Expr *clause;
+
+ foreach(i,clauses) {
+ clause = lfirst(i);
+ if(var_is_outer(get_rightop(clause))) {
+ temp = make_clause(clause->opType, clause->oper,
+ lcons(get_rightop(clause),
+ lcons(get_leftop(clause),
+ NIL)));
+ t_list = lappend(t_list,temp);
+ }
+ else
+ t_list = lappend(t_list,clause);
+ }
+ return(t_list);
+}
+
+/*
+ * set-temp-tlist-operators--
+ * Sets the key and keyop fields of resdom nodes in a target list.
+ *
+ * 'tlist' is the target list
+ * 'pathkeys' is a list of N keys in the form((key1) (key2)...(keyn)),
+ * corresponding to vars in the target list that are to
+ * be sorted or hashed
+ * 'operators' is the corresponding list of N sort or hash operators
+ * 'keyno' is the first key number
+ * XXX - keyno ? doesn't exist - jeff
+ *
+ * Returns the modified target list.
+ */
+static List *
+set_temp_tlist_operators(List *tlist, List *pathkeys, Oid *operators)
+{
+ Node *keys = NULL;
+ int keyno = 1;
+ Resdom *resdom = (Resdom*)NULL ;
+ List *i = NIL;
+
+ foreach(i, pathkeys) {
+ keys = lfirst((List*)lfirst(i));
+ resdom = tlist_member((Var*)keys, tlist);
+ if (resdom) {
+
+ /* Order the resdom keys and replace the operator OID for each
+ * key with the regproc OID.
+ *
+ * XXX Note that the optimizer only generates merge joins
+ * with 1 operator (see create_mergejoin_node) - ay 2/95
+ */
+ resdom->reskey = keyno;
+ resdom->reskeyop = get_opcode(operators[0]);
+ }
+ keyno += 1;
+ }
+ return(tlist);
+}
+
+/*****************************************************************************
+ *
+ *
+ *****************************************************************************/
+
+/*
+ * make_temp--
+ * Create plan nodes to sort or materialize relations into temporaries. The
+ * result returned for a sort will look like (SEQSCAN(SORT(plan-node)))
+ * or (SEQSCAN(MATERIAL(plan-node)))
+ *
+ * 'tlist' is the target list of the scan to be sorted or hashed
+ * 'keys' is the list of keys which the sort or hash will be done on
+ * 'operators' is the operators with which the sort or hash is to be done
+ * (a list of operator OIDs)
+ * 'plan-node' is the node which yields tuples for the sort
+ * 'temptype' indicates which operation(sort or hash) to perform
+ */
+static Temp *
+make_temp(List *tlist,
+ List *keys,
+ Oid *operators,
+ Plan *plan_node,
+ int temptype)
+{
+ List *temp_tlist;
+ Temp *retval;
+
+ /* Create a new target list for the temporary, with keys set. */
+ temp_tlist = set_temp_tlist_operators(new_unsorted_tlist(tlist),
+ keys,
+ operators);
+ switch(temptype) {
+ case TEMP_SORT :
+ retval = (Temp*)make_seqscan(tlist,
+ NIL,
+ _TEMP_RELATION_ID_,
+ (Plan*)make_sort(temp_tlist,
+ _TEMP_RELATION_ID_,
+ plan_node,
+ length(keys)));
+ break;
+
+ case TEMP_MATERIAL :
+ retval = (Temp*)make_seqscan(tlist,
+ NIL,
+ _TEMP_RELATION_ID_,
+ (Plan*)make_material(temp_tlist,
+ _TEMP_RELATION_ID_,
+ plan_node,
+ length(keys)));
+ break;
+
+ default:
+ elog(WARN,"make_temp: unknown temp type %d", temptype);
+
+ }
+ return(retval);
+}
+
+
+SeqScan *
+make_seqscan(List *qptlist,
+ List *qpqual,
+ Index scanrelid,
+ Plan *lefttree)
+{
+ SeqScan *node = makeNode(SeqScan);
+ Plan *plan = &node->plan;
+
+ plan->cost = 0.0;
+ plan->state = (EState *)NULL;
+ plan->targetlist = qptlist;
+ plan->qual = qpqual;
+ plan->lefttree = lefttree;
+ plan->righttree = NULL;
+ node->scanrelid = scanrelid;
+ node->scanstate = (CommonScanState *)NULL;
+
+ return(node);
+}
+
+static IndexScan *
+make_indexscan(List *qptlist,
+ List *qpqual,
+ Index scanrelid,
+ List *indxid,
+ List *indxqual)
+{
+ IndexScan *node = makeNode(IndexScan);
+ Plan *plan = &node->scan.plan;
+
+ plan->cost = 0.0;
+ plan->state = (EState *)NULL;
+ plan->targetlist = qptlist;
+ plan->qual = qpqual;
+ plan->lefttree = NULL;
+ plan->righttree = NULL;
+ node->scan.scanrelid = scanrelid;
+ node->indxid = indxid;
+ node->indxqual = indxqual;
+ node->scan.scanstate = (CommonScanState *)NULL;
+
+ return(node);
+}
+
+
+static NestLoop *
+make_nestloop(List *qptlist,
+ List *qpqual,
+ Plan *lefttree,
+ Plan *righttree)
+{
+ NestLoop *node = makeNode(NestLoop);
+ Plan *plan = &node->join;
+
+ plan->cost = 0.0;
+ plan->state = (EState *)NULL;
+ plan->targetlist = qptlist;
+ plan->qual = qpqual;
+ plan->lefttree = lefttree;
+ plan->righttree = righttree;
+ node->nlstate = (NestLoopState*)NULL;
+
+ return(node);
+}
+
+static HashJoin *
+make_hashjoin(List *tlist,
+ List *qpqual,
+ List *hashclauses,
+ Plan *lefttree,
+ Plan *righttree)
+{
+ HashJoin *node = makeNode(HashJoin);
+ Plan *plan = &node->join;
+
+ plan->cost = 0.0;
+ plan->state = (EState *)NULL;
+ plan->targetlist = tlist;
+ plan->qual = qpqual;
+ plan->lefttree = lefttree;
+ plan->righttree = righttree;
+ node->hashclauses = hashclauses;
+ node->hashjointable = NULL;
+ node->hashjointablekey = 0;
+ node->hashjointablesize = 0;
+ node->hashdone = false;
+
+ return(node);
+}
+
+static Hash *
+make_hash(List *tlist, Var *hashkey, Plan *lefttree)
+{
+ Hash *node = makeNode(Hash);
+ Plan *plan = &node->plan;
+
+ plan->cost = 0.0;
+ plan->state = (EState *)NULL;
+ plan->targetlist = tlist;
+ plan->qual = NULL;
+ plan->lefttree = lefttree;
+ plan->righttree = NULL;
+ node->hashkey = hashkey;
+ node->hashtable = NULL;
+ node->hashtablekey = 0;
+ node->hashtablesize = 0;
+
+ return(node);
+}
+
+static MergeJoin *
+make_mergesort(List *tlist,
+ List *qpqual,
+ List *mergeclauses,
+ Oid opcode,
+ Oid *rightorder,
+ Oid *leftorder,
+ Plan *righttree,
+ Plan *lefttree)
+{
+ MergeJoin *node = makeNode(MergeJoin);
+ Plan *plan = &node->join;
+
+ plan->cost = 0.0;
+ plan->state = (EState *)NULL;
+ plan->targetlist = tlist;
+ plan->qual = qpqual;
+ plan->lefttree = lefttree;
+ plan->righttree = righttree;
+ node->mergeclauses = mergeclauses;
+ node->mergesortop = opcode;
+ node->mergerightorder = rightorder;
+ node->mergeleftorder = leftorder;
+
+ return(node);
+}
+
+Sort *
+make_sort(List *tlist, Oid tempid, Plan *lefttree, int keycount)
+{
+ Sort *node = makeNode(Sort);
+ Plan *plan = &node->plan;
+
+ plan->cost = 0.0;
+ plan->state = (EState *)NULL;
+ plan->targetlist = tlist;
+ plan->qual = NIL;
+ plan->lefttree = lefttree;
+ plan->righttree = NULL;
+ node->tempid = tempid;
+ node->keycount = keycount;
+
+ return(node);
+}
+
+static Material *
+make_material(List *tlist,
+ Oid tempid,
+ Plan *lefttree,
+ int keycount)
+{
+ Material *node = makeNode(Material);
+ Plan *plan = &node->plan;
+
+ plan->cost = 0.0;
+ plan->state = (EState *)NULL;
+ plan->targetlist = tlist;
+ plan->qual = NIL;
+ plan->lefttree = lefttree;
+ plan->righttree = NULL;
+ node->tempid = tempid;
+ node->keycount = keycount;
+
+ return(node);
+}
+
+Agg *
+make_agg(List *tlist, int nagg, Aggreg **aggs)
+{
+ Agg *node = makeNode(Agg);
+
+ node->plan.cost = 0.0;
+ node->plan.state = (EState*)NULL;
+ node->plan.qual = NULL;
+ node->plan.targetlist = tlist;
+ node->plan.lefttree = (Plan*)NULL;
+ node->plan.righttree = (Plan*)NULL;
+ node->numAgg = nagg;
+ node->aggs = aggs;
+
+ return(node);
+}
+
+Group *
+make_group(List *tlist,
+ bool tuplePerGroup,
+ int ngrp,
+ AttrNumber *grpColIdx,
+ Sort *lefttree)
+{
+ Group *node = makeNode(Group);
+
+ node->plan.cost = 0.0;
+ node->plan.state = (EState*)NULL;
+ node->plan.qual = NULL;
+ node->plan.targetlist = tlist;
+ node->plan.lefttree = (Plan*)lefttree;
+ node->plan.righttree = (Plan*)NULL;
+ node->tuplePerGroup = tuplePerGroup;
+ node->numCols = ngrp;
+ node->grpColIdx = grpColIdx;
+
+ return(node);
+}
+
+/*
+ * A unique node always has a SORT node in the lefttree.
+ *
+ * the uniqueAttr argument must be a null-terminated string,
+ * either the name of the attribute to select unique on
+ * or "*"
+ */
+
+Unique *
+make_unique(List *tlist, Plan *lefttree, char* uniqueAttr)
+{
+ Unique *node = makeNode(Unique);
+ Plan *plan = &node->plan;
+
+ plan->cost = 0.0;
+ plan->state = (EState *)NULL;
+ plan->targetlist = tlist;
+ plan->qual = NIL;
+ plan->lefttree = lefttree;
+ plan->righttree = NULL;
+ node->tempid = _TEMP_RELATION_ID_;
+ node->keycount = 0;
+ if (strcmp(uniqueAttr,"*") == 0)
+ node->uniqueAttr = NULL;
+ else
+ {
+ node->uniqueAttr=pstrdup(uniqueAttr);
+ }
+ return(node);
+}
+
+List *generate_fjoin(List *tlist)
+{
+#if 0
+ List tlistP;
+ List newTlist = NIL;
+ List fjoinList = NIL;
+ int nIters = 0;
+
+ /*
+ * Break the target list into elements with Iter nodes,
+ * and those without them.
+ */
+ foreach(tlistP, tlist) {
+ List tlistElem;
+
+ tlistElem = lfirst(tlistP);
+ if (IsA(lsecond(tlistElem),Iter)) {
+ nIters++;
+ fjoinList = lappend(fjoinList, tlistElem);
+ } else {
+ newTlist = lappend(newTlist, tlistElem);
+ }
+ }
+
+ /*
+ * if we have an Iter node then we need to flatten.
+ */
+ if (nIters > 0) {
+ List *inner;
+ List *tempList;
+ Fjoin *fjoinNode;
+ DatumPtr results = (DatumPtr)palloc(nIters*sizeof(Datum));
+ BoolPtr alwaysDone = (BoolPtr)palloc(nIters*sizeof(bool));
+
+ inner = lfirst(fjoinList);
+ fjoinList = lnext(fjoinList);
+ fjoinNode = (Fjoin)MakeFjoin(false,
+ nIters,
+ inner,
+ results,
+ alwaysDone);
+ tempList = lcons(fjoinNode, NIL);
+ tempList = nconc(tempList, fjoinList);
+ newTlist = lappend(newTlist, tempList);
+ }
+ return newTlist;
+#endif
+ return tlist; /* do nothing for now - ay 10/94 */
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * initsplan.c--
+ * Target list, qualification, joininfo initialization routines
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/initsplan.c,v 1.1.1.1 1996/07/09 06:21:37 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/plannodes.h"
+#include "nodes/parsenodes.h"
+#include "nodes/relation.h"
+#include "nodes/makefuncs.h"
+
+#include "utils/lsyscache.h"
+#include "utils/palloc.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/planmain.h"
+#include "optimizer/joininfo.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/tlist.h"
+#include "optimizer/var.h"
+#include "optimizer/clauses.h"
+#include "optimizer/cost.h"
+
+extern int Quiet;
+
+static void add_clause_to_rels(Query *root, List *clause);
+static void add_join_clause_info_to_rels(Query *root, CInfo *clauseinfo,
+ List *join_relids);
+static void add_vars_to_rels(Query *root, List *vars, List *join_relids);
+
+static MergeOrder *mergesortop(Expr *clause);
+static Oid hashjoinop(Expr *clause);
+
+
+/*****************************************************************************
+ *
+ * TARGET LISTS
+ *
+ *****************************************************************************/
+
+/*
+ * initialize_rel_nodes--
+ * Creates rel nodes for every relation mentioned in the target list
+ * 'tlist' (if a node hasn't already been created) and adds them to
+ * *query-relation-list*. Creates targetlist entries for each member of
+ * 'tlist' and adds them to the tlist field of the appropriate rel node.
+ *
+ * Returns nothing.
+ */
+void
+initialize_base_rels_list(Query *root, List *tlist)
+{
+ List *tlist_vars = NIL;
+ List *l = NIL;
+ List *tvar = NIL;
+
+ foreach (l, tlist) {
+ TargetEntry *entry = (TargetEntry *) lfirst(l);
+
+ tlist_vars = append(tlist_vars, pull_var_clause(entry->expr));
+ }
+
+ /* now, the target list only contains Var nodes */
+ foreach (tvar, tlist_vars) {
+ Var *var;
+ Index varno;
+ Rel *result;
+
+ var = (Var*)lfirst(tvar);
+ varno = var->varno;
+ result = get_base_rel(root, varno);
+
+ add_tl_element(result, var);
+ }
+}
+
+/*
+ * add_missing_variables_to_base_rels -
+ * If we have range variable(s) in the FROM clause that does not appear
+ * in the target list nor qualifications, we add it to the base relation
+ * list. For instance, "select f.x from foo f, foo f2" is a join of f and
+ * f2. Note that if we have "select foo.x from foo f", it also gets turned
+ * into a join.
+ */
+void
+add_missing_vars_to_base_rels(Query *root, List *tlist)
+{
+ List *l;
+ int varno;
+
+ varno = 1;
+ foreach (l, root->rtable) {
+ RangeTblEntry *rte = (RangeTblEntry *)lfirst(l);
+ List *relids;
+ Rel *result;
+ Var *var;
+
+ relids = lconsi(varno, NIL);
+ if (rte->inFromCl &&
+ !rel_member(relids, root->base_relation_list_)) {
+
+ var = makeVar(varno, -2 , 26, varno, -2);
+ /* add it to base_relation_list_ */
+ result = get_base_rel(root, varno);
+ add_tl_element(result, var);
+ }
+ pfree(relids);
+ varno++;
+ }
+
+ return;
+}
+
+/*****************************************************************************
+ *
+ * QUALIFICATIONS
+ *
+ *****************************************************************************/
+
+
+
+/*
+ * initialize-qualification--
+ * Initializes ClauseInfo and JoinInfo fields of relation entries for all
+ * relations appearing within clauses. Creates new relation entries if
+ * necessary, adding them to *query-relation-list*.
+ *
+ * Returns nothing of interest.
+ */
+void
+initialize_base_rels_jinfo(Query *root, List *clauses)
+{
+ List *clause;
+
+ foreach (clause, clauses) {
+ add_clause_to_rels(root, lfirst(clause));
+ }
+ return;
+}
+
+/*
+ * add-clause-to-rels--
+ * Add clause information to either the 'ClauseInfo' or 'JoinInfo' field
+ * of a relation entry(depending on whether or not the clause is a join)
+ * by creating a new ClauseInfo node and setting appropriate fields
+ * within the nodes.
+ *
+ * Returns nothing of interest.
+ */
+static void
+add_clause_to_rels(Query *root, List *clause)
+{
+ List *relids;
+ List *vars;
+ CInfo *clauseinfo = makeNode(CInfo);
+
+ /*
+ * Retrieve all relids and vars contained within the clause.
+ */
+ clause_relids_vars((Node*)clause, &relids, &vars);
+
+
+ clauseinfo->clause = (Expr*)clause;
+ clauseinfo->notclause = contains_not((Node*)clause);
+ clauseinfo->selectivity = 0;
+ clauseinfo->indexids = NIL;
+ clauseinfo->mergesortorder = (MergeOrder*)NULL;
+ clauseinfo->hashjoinoperator = (Oid)0;
+
+
+
+ if(length(relids) == 1) {
+ Rel *rel = get_base_rel(root, lfirsti(relids));
+
+ /*
+ * There is only one relation participating in 'clause',
+ * so 'clause' must be a restriction clause.
+ */
+
+ /* the selectivity of the clause must be computed
+ regardless of whether it's a restriction or a join clause */
+ if (is_funcclause((Node*)clause))
+ {
+ /*
+ * XXX If we have a func clause set selectivity to 1/3,
+ * really need a true selectivity function.
+ */
+ clauseinfo->selectivity = (Cost)0.3333333;
+ }
+ else
+ {
+ clauseinfo->selectivity =
+ compute_clause_selec(root, (Node*)clause,
+ NIL);
+ }
+ rel->clauseinfo = lcons(clauseinfo,
+ rel->clauseinfo);
+ } else {
+ /*
+ * 'clause' is a join clause, since there is more than one
+ * atom in the relid list.
+ */
+
+ if (is_funcclause((Node*)clause))
+ {
+ /*
+ * XXX If we have a func clause set selectivity to 1/3,
+ * really need a true selectivity function.
+ */
+ clauseinfo->selectivity = (Cost)0.3333333;
+ }
+ else
+ {
+ clauseinfo->selectivity =
+ compute_clause_selec(root, (Node*)clause,
+ NIL);
+ }
+ add_join_clause_info_to_rels(root, clauseinfo, relids);
+ add_vars_to_rels(root,vars, relids);
+ }
+}
+
+/*
+ * add-join-clause-info-to-rels--
+ * For every relation participating in a join clause, add 'clauseinfo' to
+ * the appropriate joininfo node(creating a new one and adding it to the
+ * appropriate rel node if necessary).
+ *
+ * 'clauseinfo' describes the join clause
+ * 'join-relids' is the list of relations participating in the join clause
+ *
+ * Returns nothing.
+ *
+ */
+static void
+add_join_clause_info_to_rels(Query *root, CInfo *clauseinfo, List *join_relids)
+{
+ List *join_relid;
+
+ foreach (join_relid, join_relids) {
+ JInfo *joininfo =
+ find_joininfo_node(get_base_rel(root, lfirsti(join_relid)),
+ intLispRemove((int)lfirst(join_relid),
+ join_relids));
+ joininfo->jinfoclauseinfo =
+ lcons(clauseinfo, joininfo->jinfoclauseinfo);
+
+ }
+}
+
+/*
+ * add-vars-to-rels--
+ * For each variable appearing in a clause,
+ * (1) If a targetlist entry for the variable is not already present in
+ * the appropriate relation's target list, add one.
+ * (2) If a targetlist entry is already present, but the var is part of a
+ * join clause, add the relids of the join relations to the JoinList
+ * entry of the targetlist entry.
+ *
+ * 'vars' is the list of var nodes
+ * 'join-relids' is the list of relids appearing in the join clause
+ * (if this is a join clause)
+ *
+ * Returns nothing.
+ */
+static void
+add_vars_to_rels(Query *root, List *vars, List *join_relids)
+{
+ Var *var;
+ List *temp = NIL;
+ Rel *rel = (Rel*)NULL;
+ TargetEntry *tlistentry;
+
+ foreach (temp, vars) {
+ var = (Var*)lfirst(temp);
+ rel = get_base_rel(root, var->varno);
+ tlistentry = tlistentry_member(var, rel->targetlist);
+ if(tlistentry==NULL)
+ /* add a new entry */
+ add_tl_element(rel, var);
+ }
+}
+
+/*****************************************************************************
+ *
+ * JOININFO
+ *
+ *****************************************************************************/
+
+/*
+ * initialize-join-clause-info--
+ * Set the MergeSortable or HashJoinable field for every joininfo node
+ * (within a rel node) and the MergeSortOrder or HashJoinOp field for
+ * each clauseinfo node(within a joininfo node) for all relations in a
+ * query.
+ *
+ * Returns nothing.
+ */
+void
+initialize_join_clause_info(List *rel_list)
+{
+ List *x, *y, *z;
+ Rel *rel;
+ JInfo *joininfo;
+ CInfo *clauseinfo;
+ Expr *clause;
+
+ foreach (x, rel_list) {
+ rel = (Rel*)lfirst(x);
+ foreach (y, rel->joininfo) {
+ joininfo = (JInfo*)lfirst(y);
+ foreach (z, joininfo->jinfoclauseinfo) {
+ clauseinfo = (CInfo*)lfirst(z);
+ clause = clauseinfo->clause;
+ if(join_clause_p((Node*)clause)) {
+ MergeOrder *sortop = (MergeOrder*)NULL;
+ Oid hashop = (Oid)NULL;
+
+ if (_enable_mergesort_)
+ sortop = mergesortop(clause);
+ if (_enable_hashjoin_)
+ hashop = hashjoinop(clause);
+
+ if (sortop) {
+ clauseinfo->mergesortorder = sortop;
+ joininfo->mergesortable = true;
+ }
+ if (hashop) {
+ clauseinfo->hashjoinoperator = hashop;
+ joininfo->hashjoinable = true;
+ }
+ }
+ }
+ }
+ }
+}
+
+/*
+ * mergesortop--
+ * Returns the mergesort operator of an operator iff 'clause' is
+ * mergesortable, i.e., both operands are single vars and the operator is
+ * a mergesortable operator.
+ */
+static MergeOrder *
+mergesortop(Expr *clause)
+{
+ Oid leftOp, rightOp;
+ bool sortable;
+
+ sortable = op_mergesortable(((Oper*)clause->oper)->opno,
+ (get_leftop(clause))->vartype,
+ (get_rightop(clause))->vartype,
+ &leftOp,
+ &rightOp);
+
+ if (sortable) {
+ MergeOrder *morder = makeNode(MergeOrder);
+
+ morder->join_operator = ((Oper*)clause->oper)->opno;
+ morder->left_operator = leftOp;
+ morder->right_operator = rightOp;
+ morder->left_type = (get_leftop(clause))->vartype;
+ morder->right_type = (get_rightop(clause))->vartype;
+ return (morder);
+ } else
+ return(NULL);
+}
+
+/*
+ * hashjoinop--
+ * Returns the hashjoin operator of an operator iff 'clause' is
+ * hashjoinable, i.e., both operands are single vars and the operator is
+ * a hashjoinable operator.
+ */
+static Oid
+hashjoinop(Expr *clause)
+{
+ return(op_hashjoinable(((Oper*)clause->oper)->opno,
+ (get_leftop(clause))->vartype,
+ (get_rightop(clause))->vartype));
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * planmain.c--
+ * Routines to plan a single query
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.1.1.1 1996/07/09 06:21:37 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/plannodes.h"
+#include "nodes/parsenodes.h"
+#include "nodes/relation.h"
+
+#include "optimizer/planmain.h"
+#include "optimizer/internal.h"
+#include "optimizer/paths.h"
+#include "optimizer/clauses.h"
+#include "optimizer/keys.h"
+#include "optimizer/tlist.h"
+#include "optimizer/xfunc.h"
+#include "optimizer/cost.h"
+
+#include "tcop/dest.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "nodes/memnodes.h"
+#include "utils/mcxt.h"
+#include "utils/lsyscache.h"
+
+static Plan *subplanner(Query *root, List *flat_tlist, List *qual);
+static Result *make_result(List *tlist, Node *resconstantqual, Plan *subplan);
+
+static Plan *make_groupPlan(List *tlist, bool tuplePerGroup,
+ List *groupClause, Plan *subplan);
+
+/*
+ * query_planner--
+ * Routine to create a query plan. It does so by first creating a
+ * subplan for the topmost level of attributes in the query. Then,
+ * it modifies all target list and qualifications to consider the next
+ * level of nesting and creates a plan for this modified query by
+ * recursively calling itself. The two pieces are then merged together
+ * by creating a result node that indicates which attributes should
+ * be placed where and any relation level qualifications to be
+ * satisfied.
+ *
+ * command-type is the query command, e.g., retrieve, delete, etc.
+ * tlist is the target list of the query
+ * qual is the qualification of the query
+ *
+ * Returns a query plan.
+ */
+Plan *
+query_planner(Query *root,
+ int command_type,
+ List *tlist,
+ List *qual)
+{
+ List *constant_qual = NIL;
+ List *flattened_tlist = NIL;
+ List *level_tlist = NIL;
+ Plan *subplan = (Plan*)NULL;
+ Agg *aggplan = NULL;
+
+ /*
+ * A command without a target list or qualification is an error,
+ * except for "delete foo".
+ */
+ if (tlist==NIL && qual==NULL) {
+ if (command_type == CMD_DELETE ||
+ /* Total hack here. I don't know how to handle
+ statements like notify in action bodies.
+ Notify doesn't return anything but
+ scans a system table. */
+ command_type == CMD_NOTIFY) {
+ return ((Plan*)make_seqscan(NIL,
+ NIL,
+ root->resultRelation,
+ (Plan*)NULL));
+ } else
+ return((Plan*)NULL);
+ }
+
+ /*
+ * Pull out any non-variable qualifications so these can be put in
+ * the topmost result node. The opids for the remaining
+ * qualifications will be changed to regprocs later.
+ */
+ qual = pull_constant_clauses(qual, &constant_qual);
+ fix_opids(constant_qual);
+
+ /*
+ * Create a target list that consists solely of (resdom var) target
+ * list entries, i.e., contains no arbitrary expressions.
+ */
+ flattened_tlist = flatten_tlist(tlist);
+ if (flattened_tlist) {
+ level_tlist = flattened_tlist;
+ } else {
+ /* from old code. the logic is beyond me. - ay 2/95 */
+ level_tlist = tlist;
+ }
+
+ /*
+ * Needs to add the group attribute(s) to the target list so that they
+ * are available to either the Group node or the Agg node. (The target
+ * list may not contain the group attribute(s).)
+ */
+ if (root->groupClause) {
+ AddGroupAttrToTlist(level_tlist, root->groupClause);
+ }
+
+ if (root->qry_aggs) {
+ aggplan = make_agg(tlist, root->qry_numAgg, root->qry_aggs);
+ tlist = level_tlist;
+ }
+
+ /*
+ * A query may have a non-variable target list and a non-variable
+ * qualification only under certain conditions:
+ * - the query creates all-new tuples, or
+ * - the query is a replace (a scan must still be done in this case).
+ */
+ if (flattened_tlist==NULL && qual==NULL) {
+
+ switch (command_type) {
+ case CMD_SELECT:
+ case CMD_INSERT:
+ return ((Plan*)make_result(tlist,
+ (Node*)constant_qual,
+ (Plan*)NULL));
+ break;
+
+ case CMD_DELETE:
+ case CMD_UPDATE:
+ {
+ SeqScan *scan = make_seqscan(tlist,
+ (List *)NULL,
+ root->resultRelation,
+ (Plan*)NULL);
+ if (constant_qual!=NULL) {
+ return ((Plan*)make_result(tlist,
+ (Node*)constant_qual,
+ (Plan*)scan));
+ } else {
+ return ((Plan*)scan);
+ }
+ }
+ break;
+
+ default:
+ return ((Plan*)NULL);
+ }
+ }
+
+ /*
+ * Find the subplan (access path) and destructively modify the
+ * target list of the newly created subplan to contain the appropriate
+ * join references.
+ */
+ subplan = subplanner(root, level_tlist, qual);
+
+ set_tlist_references(subplan);
+
+ /*
+ * If we have a GROUP BY clause, insert a group node (with the appropriate
+ * sort node.)
+ */
+ if (root->groupClause != NULL) {
+ bool tuplePerGroup;
+
+ /*
+ * decide whether how many tuples per group the Group node needs
+ * to return. (Needs only one tuple per group if no aggregate is
+ * present. Otherwise, need every tuple from the group to do the
+ * aggregation.)
+ */
+ tuplePerGroup = (aggplan == NULL) ? FALSE : TRUE;
+
+ subplan =
+ make_groupPlan(tlist, tuplePerGroup, root->groupClause, subplan);
+
+ /* XXX fake it: this works for the Group node too! very very ugly,
+ please change me -ay 2/95 */
+ set_agg_tlist_references((Agg*)subplan);
+ }
+
+ /*
+ * If aggregate is present, insert the agg node
+ */
+ if (aggplan != NULL) {
+ aggplan->plan.lefttree = subplan;
+ subplan = (Plan*)aggplan;
+
+ /*
+ * set the varno/attno entries to the appropriate references to
+ * the result tuple of the subplans. (We need to set those in the
+ * array of aggreg's in the Agg node also. Even though they're
+ * pointers, after a few dozen's of copying, they're not the same as
+ * those in the target list.)
+ */
+ set_agg_tlist_references((Agg*)subplan);
+ set_agg_agglist_references((Agg*)subplan);
+
+ tlist = aggplan->plan.targetlist;
+ }
+
+ /*
+ * Build a result node linking the plan if we have constant quals
+ */
+ if (constant_qual) {
+ Plan *plan;
+
+ plan = (Plan*)make_result(tlist,
+ (Node*)constant_qual,
+ subplan);
+ /*
+ * Change all varno's of the Result's node target list.
+ */
+ set_result_tlist_references((Result*)plan);
+
+ return (plan);
+ }
+
+ /*
+ * fix up the flattened target list of the plan root node so that
+ * expressions are evaluated. this forces expression evaluations
+ * that may involve expensive function calls to be delayed to
+ * the very last stage of query execution. this could be bad.
+ * but it is joey's responsibility to optimally push these
+ * expressions down the plan tree. -- Wei
+ */
+ subplan->targetlist = flatten_tlist_vars(tlist,
+ subplan->targetlist);
+
+ /*
+ * Destructively modify the query plan's targetlist to add fjoin
+ * lists to flatten functions that return sets of base types
+ */
+ subplan->targetlist = generate_fjoin(subplan->targetlist);
+
+ return (subplan);
+}
+
+/*
+ * subplanner
+ *
+ * Subplanner creates an entire plan consisting of joins and scans
+ * for processing a single level of attributes.
+ *
+ * flat-tlist is the flattened target list
+ * qual is the qualification to be satisfied
+ *
+ * Returns a subplan.
+ *
+ */
+static Plan *
+subplanner(Query *root,
+ List *flat_tlist,
+ List *qual)
+{
+ Rel *final_relation;
+ List *final_relation_list;
+
+ /* Initialize the targetlist and qualification, adding entries to
+ * *query-relation-list* as relation references are found (e.g., in the
+ * qualification, the targetlist, etc.)
+ */
+ root->base_relation_list_ = NIL;
+ root->join_relation_list_ = NIL;
+ initialize_base_rels_list(root, flat_tlist);
+ initialize_base_rels_jinfo(root, qual);
+ add_missing_vars_to_base_rels(root, flat_tlist);
+
+ /* Find all possible scan and join paths.
+ * Mark all the clauses and relations that can be processed using special
+ * join methods, then do the exhaustive path search.
+ */
+ initialize_join_clause_info(root->base_relation_list_);
+ final_relation_list = find_paths(root,
+ root->base_relation_list_);
+
+ if (final_relation_list)
+ final_relation = (Rel*)lfirst (final_relation_list);
+ else
+ final_relation = (Rel*)NIL;
+
+#if 0 /* fix xfunc */
+ /*
+ * Perform Predicate Migration on each path, to optimize and correctly
+ * assess the cost of each before choosing the cheapest one.
+ * -- JMH, 11/16/92
+ *
+ * Needn't do so if the top rel is pruneable: that means there's no
+ * expensive functions left to pull up. -- JMH, 11/22/92
+ */
+ if (XfuncMode != XFUNC_OFF && XfuncMode != XFUNC_NOPM &&
+ XfuncMode != XFUNC_NOPULL && !final_relation->pruneable)
+ {
+ List *pathnode;
+ foreach(pathnode, final_relation->pathlist)
+ {
+ if (xfunc_do_predmig((Path*)lfirst(pathnode)))
+ set_cheapest(final_relation, final_relation->pathlist);
+ }
+ }
+#endif
+
+ /*
+ * Determine the cheapest path and create a subplan corresponding to it.
+ */
+ if (final_relation) {
+ return (create_plan ((Path*)final_relation->cheapestpath));
+ }else {
+ elog(NOTICE, "final relation is nil");
+ return(create_plan ((Path*)NULL));
+ }
+
+}
+
+/*****************************************************************************
+ *
+ *****************************************************************************/
+
+static Result *
+make_result(List *tlist,
+ Node *resconstantqual,
+ Plan *subplan)
+{
+ Result *node = makeNode(Result);
+ Plan *plan = &node->plan;
+
+ tlist = generate_fjoin(tlist);
+ plan->cost = 0.0;
+ plan->state = (EState *)NULL;
+ plan->targetlist = tlist;
+ plan->lefttree = subplan;
+ plan->righttree = NULL;
+ node->resconstantqual = resconstantqual;
+ node->resstate = NULL;
+
+ return(node);
+}
+
+/*****************************************************************************
+ *
+ *****************************************************************************/
+
+static Plan *
+make_groupPlan(List *tlist,
+ bool tuplePerGroup,
+ List *groupClause,
+ Plan *subplan)
+{
+ List *sort_tlist;
+ List *gl;
+ int keyno;
+ Sort *sortplan;
+ Group *grpplan;
+ int numCols;
+ AttrNumber *grpColIdx;
+
+ numCols = length(groupClause);
+ grpColIdx = (AttrNumber *)palloc(sizeof(AttrNumber)*numCols);
+
+ /*
+ * first, make a sort node. Group node expects the tuples it gets
+ * from the subplan is in the order as specified by the group columns.
+ */
+ keyno = 1;
+ sort_tlist = new_unsorted_tlist(subplan->targetlist);
+
+ {
+ /* if this is a mergejoin node, varno could be OUTER/INNER */
+ List *l;
+ foreach(l, sort_tlist) {
+ TargetEntry *tle;
+ tle = lfirst(l);
+ ((Var*)tle->expr)->varno = 1;
+ }
+ }
+
+ foreach (gl, groupClause) {
+ GroupClause *grpcl = (GroupClause*)lfirst(gl);
+ TargetEntry *tle;
+
+ tle = match_varid(grpcl->grpAttr, sort_tlist);
+ /*
+ * the parser should have checked to make sure the group attribute
+ * is valid but the optimizer might have screwed up and hence we
+ * check again.
+ */
+ if (tle==NULL) {
+ elog(WARN, "group attribute disappeared from target list");
+ }
+ tle->resdom->reskey = keyno;
+ tle->resdom->reskeyop = get_opcode(grpcl->grpOpoid);
+
+ grpColIdx[keyno-1] = tle->resdom->resno;
+ keyno++;
+ }
+ sortplan = make_sort(sort_tlist,
+ _TEMP_RELATION_ID_,
+ subplan,
+ numCols);
+ sortplan->plan.cost = subplan->cost; /* XXX assume no cost */
+
+ /*
+ * make the Group node
+ */
+ tlist = copyObject(tlist); /* make a copy */
+ grpplan = make_group(tlist, tuplePerGroup, numCols, grpColIdx, sortplan);
+
+ return (Plan*)grpplan;
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * planner.c--
+ * The query optimizer external interface.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.1.1.1 1996/07/09 06:21:37 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/plannodes.h"
+#include "nodes/parsenodes.h"
+#include "nodes/relation.h"
+
+#include "parser/catalog_utils.h"
+#include "parser/parse_query.h"
+#include "utils/elog.h"
+#include "utils/lsyscache.h"
+#include "access/heapam.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/planner.h"
+#include "optimizer/plancat.h"
+#include "optimizer/prep.h"
+#include "optimizer/planmain.h"
+#include "optimizer/paths.h"
+#include "optimizer/cost.h"
+
+/* DATA STRUCTURE CREATION/MANIPULATION ROUTINES */
+#include "nodes/relation.h"
+#include "optimizer/clauseinfo.h"
+#include "optimizer/joininfo.h"
+#include "optimizer/keys.h"
+#include "optimizer/ordering.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/clauses.h"
+#include "optimizer/tlist.h"
+#include "optimizer/var.h"
+
+#include "executor/executor.h"
+
+static Plan *make_sortplan(List *tlist, List *sortcls, Plan *plannode);
+static Plan *init_query_planner(Query *parse);
+static Existential *make_existential(Plan *left, Plan *right);
+
+/*****************************************************************************
+ *
+ * Query optimizer entry point
+ *
+ *****************************************************************************/
+
+
+/*
+ * planner--
+ * Main query optimizer routine.
+ *
+ * Invokes the planner on union queries if there are any left,
+ * recursing if necessary to get them all, then processes normal plans.
+ *
+ * Returns a query plan.
+ *
+ */
+Plan*
+planner(Query *parse)
+{
+ List *tlist = parse->targetList;
+ List *rangetable = parse->rtable;
+ char* uniqueflag = parse->uniqueFlag;
+ List *sortclause = parse->sortClause;
+ Plan *special_plans = (Plan*)NULL;
+
+ Plan *result_plan = (Plan*) NULL;
+
+ int rt_index;
+
+ /*
+ * plan inheritance
+ */
+ rt_index = first_matching_rt_entry(rangetable, INHERITS_FLAG);
+ if (rt_index != -1) {
+ special_plans = (Plan *)plan_union_queries((Index)rt_index,
+ parse,
+ INHERITS_FLAG);
+ }
+
+ /*
+ * plan archive queries
+ */
+ rt_index = first_matching_rt_entry(rangetable, ARCHIVE_FLAG);
+ if (rt_index != -1) {
+ special_plans = (Plan *)plan_union_queries((Index)rt_index,
+ parse,
+ ARCHIVE_FLAG);
+ }
+
+ if (special_plans)
+ result_plan = special_plans;
+ else
+ result_plan = init_query_planner(parse); /* regular plans */
+
+ /*
+ * For now, before we hand back the plan, check to see if there
+ * is a user-specified sort that needs to be done. Eventually, this
+ * will be moved into the guts of the planner s.t. user specified
+ * sorts will be considered as part of the planning process.
+ * Since we can only make use of user-specified sorts in
+ * special cases, we can do the optimization step later.
+ */
+
+ if (uniqueflag) {
+ Plan *sortplan = make_sortplan(tlist, sortclause, result_plan);
+
+ return((Plan*)make_unique(tlist,sortplan,uniqueflag));
+ } else {
+ if (sortclause)
+ return(make_sortplan(tlist,sortclause,result_plan));
+ else
+ return((Plan*)result_plan);
+ }
+
+}
+
+/*
+ * make_sortplan--
+ * Returns a sortplan which is basically a SORT node attached to the
+ * top of the plan returned from the planner. It also adds the
+ * cost of sorting into the plan.
+ *
+ * sortkeys: ( resdom1 resdom2 resdom3 ...)
+ * sortops: (sortop1 sortop2 sortop3 ...)
+ */
+static Plan *
+make_sortplan(List *tlist, List *sortcls, Plan *plannode)
+{
+ Plan *sortplan = (Plan*)NULL;
+ List *temp_tlist = NIL;
+ List *i = NIL;
+ Resdom *resnode = (Resdom*)NULL;
+ Resdom *resdom = (Resdom*)NULL;
+ int keyno =1;
+
+ /* First make a copy of the tlist so that we don't corrupt the
+ * the original .
+ */
+
+ temp_tlist = new_unsorted_tlist(tlist);
+
+ foreach (i, sortcls) {
+ SortClause *sortcl = (SortClause*)lfirst(i);
+
+ resnode = sortcl->resdom;
+ resdom = tlist_resdom(temp_tlist, resnode);
+
+ /* Order the resdom keys and replace the operator OID for each
+ * key with the regproc OID.
+ */
+ resdom->reskey = keyno;
+ resdom->reskeyop = get_opcode(sortcl->opoid);
+ keyno += 1;
+ }
+
+ sortplan = (Plan*)make_sort(temp_tlist,
+ _TEMP_RELATION_ID_,
+ (Plan*)plannode,
+ length(sortcls));
+
+ /*
+ * XXX Assuming that an internal sort has no. cost.
+ * This is wrong, but given that at this point, we don't
+ * know the no. of tuples returned, etc, we can't do
+ * better than to add a constant cost.
+ * This will be fixed once we move the sort further into the planner,
+ * but for now ... functionality....
+ */
+
+ sortplan->cost = plannode->cost;
+
+ return(sortplan);
+}
+
+
+/*
+ * init-query-planner--
+ * Deals with all non-union preprocessing, including existential
+ * qualifications and CNFifying the qualifications.
+ *
+ * Returns a query plan.
+ * MODIFIES: tlist,qual
+ *
+ */
+static Plan *
+init_query_planner(Query *root)
+{
+ List *primary_qual;
+ List *existential_qual;
+ Existential *exist_plan;
+ List *tlist = root->targetList;
+
+ tlist = preprocess_targetlist(tlist,
+ root->commandType,
+ root->resultRelation,
+ root->rtable);
+
+ primary_qual =
+ preprocess_qualification((Expr*)root->qual,
+ tlist,
+ &existential_qual);
+
+ if(existential_qual==NULL) {
+ return(query_planner(root,
+ root->commandType,
+ tlist,
+ primary_qual));
+ } else {
+ int temp = root->commandType;
+ Plan *existential_plan;
+
+ root->commandType = CMD_SELECT;
+ existential_plan = query_planner(root,
+ temp,
+ NIL,
+ existential_qual);
+
+ exist_plan = make_existential(existential_plan,
+ query_planner(root,
+ root->commandType,
+ tlist,
+ primary_qual));
+ return((Plan*)exist_plan);
+ }
+}
+
+/*
+ * make_existential--
+ * Instantiates an existential plan node and fills in
+ * the left and right subtree slots.
+ */
+static Existential *
+make_existential(Plan *left, Plan *right)
+{
+ Existential *node = makeNode(Existential);
+
+ node->lefttree = left;
+ node->righttree = left;
+ return(node);
+}
+
+/*
+ * pg_checkretval() -- check return value of a list of sql parse
+ * trees.
+ *
+ * The return value of a sql function is the value returned by
+ * the final query in the function. We do some ad-hoc define-time
+ * type checking here to be sure that the user is returning the
+ * type he claims.
+ */
+void
+pg_checkretval(Oid rettype, QueryTreeList *queryTreeList)
+{
+ Query *parse;
+ List *tlist;
+ List *rt;
+ int cmd;
+ Type typ;
+ Resdom *resnode;
+ Relation reln;
+ Oid relid;
+ Oid tletype;
+ int relnatts;
+ int i;
+
+ /* find the final query */
+ parse = queryTreeList->qtrees[queryTreeList->len - 1];
+
+ /*
+ * test 1: if the last query is a utility invocation, then there
+ * had better not be a return value declared.
+ */
+ if (parse->commandType == CMD_UTILITY) {
+ if (rettype == InvalidOid)
+ return;
+ else
+ elog(WARN, "return type mismatch in function decl: final query is a catalog utility");
+ }
+
+ /* okay, it's an ordinary query */
+ tlist = parse->targetList;
+ rt = parse->rtable;
+ cmd = parse->commandType;
+
+ /*
+ * test 2: if the function is declared to return no value, then the
+ * final query had better not be a retrieve.
+ */
+ if (rettype == InvalidOid) {
+ if (cmd == CMD_SELECT)
+ elog(WARN,
+ "function declared with no return type, but final query is a retrieve");
+ else
+ return;
+ }
+
+ /* by here, the function is declared to return some type */
+ if ((typ = (Type)get_id_type(rettype)) == NULL)
+ elog(WARN, "can't find return type %d for function\n", rettype);
+
+ /*
+ * test 3: if the function is declared to return a value, then the
+ * final query had better be a retrieve.
+ */
+ if (cmd != CMD_SELECT)
+ elog(WARN, "function declared to return type %s, but final query is not a retrieve", tname(typ));
+
+ /*
+ * test 4: for base type returns, the target list should have exactly
+ * one entry, and its type should agree with what the user declared.
+ */
+
+ if (get_typrelid(typ) == InvalidOid) {
+ if (exec_tlist_length(tlist) > 1)
+ elog(WARN, "function declared to return %s returns multiple values in final retrieve", tname(typ));
+
+ resnode = (Resdom*) ((TargetEntry*)lfirst(tlist))->resdom;
+ if (resnode->restype != rettype)
+ elog(WARN, "return type mismatch in function: declared to return %s, returns %s", tname(typ), tname(get_id_type(resnode->restype)));
+
+ /* by here, base return types match */
+ return;
+ }
+
+ /*
+ * If the target list is of length 1, and the type of the varnode
+ * in the target list is the same as the declared return type, this
+ * is okay. This can happen, for example, where the body of the
+ * function is 'retrieve (x = func2())', where func2 has the same
+ * return type as the function that's calling it.
+ */
+ if (exec_tlist_length(tlist) == 1) {
+ resnode = (Resdom*) ((TargetEntry*)lfirst(tlist))->resdom;
+ if (resnode->restype == rettype)
+ return;
+ }
+
+ /*
+ * By here, the procedure returns a (set of) tuples. This part of
+ * the typechecking is a hack. We look up the relation that is
+ * the declared return type, and be sure that attributes 1 .. n
+ * in the target list match the declared types.
+ */
+ reln = heap_open(get_typrelid(typ));
+
+ if (!RelationIsValid(reln))
+ elog(WARN, "cannot open relation relid %d", get_typrelid(typ));
+
+ relid = reln->rd_id;
+ relnatts = reln->rd_rel->relnatts;
+
+ if (exec_tlist_length(tlist) != relnatts)
+ elog(WARN, "function declared to return type %s does not retrieve (%s.*)", tname(typ), tname(typ));
+
+ /* expect attributes 1 .. n in order */
+ for (i = 1; i <= relnatts; i++) {
+ TargetEntry *tle = lfirst(tlist);
+ Node *thenode = tle->expr;
+
+ tlist = lnext(tlist);
+ tletype = exprType(thenode);
+
+#if 0 /* fix me */
+ /* this is tedious */
+ if (IsA(thenode,Var))
+ tletype = (Oid) ((Var*)thenode)->vartype;
+ else if (IsA(thenode,Const))
+ tletype = (Oid) ((Const*)thenode)->consttype;
+ else if (IsA(thenode,Param)) {
+ tletype = (Oid) ((Param*)thenode)->paramtype;
+ else if (IsA(thenode,Expr)) {
+ tletype = Expr
+ }
+ } else if (IsA(thenode,LispList)) {
+ thenode = lfirst(thenode);
+ if (IsA(thenode,Oper))
+ tletype = (Oid) get_opresulttype((Oper*)thenode);
+ else if (IsA(thenode,Func))
+ tletype = (Oid) get_functype((Func*)thenode);
+ else
+ elog(WARN, "function declared to return type %s does not retrieve (%s.all)", tname(typ), tname(typ));
+#endif
+/*
+ } else
+ elog(WARN, "function declared to return type %s does not retrieve (%s.all)", tname(typ), tname(typ));
+*/
+ /* reach right in there, why don't you? */
+ if (tletype != reln->rd_att->attrs[i-1]->atttypid)
+ elog(WARN, "function declared to return type %s does not retrieve (%s.all)", tname(typ), tname(typ));
+ }
+
+ heap_close(reln);
+
+ /* success */
+ return;
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * setrefs.c--
+ * Routines to change varno/attno entries to contain references
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.1.1.1 1996/07/09 06:21:37 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/plannodes.h"
+#include "nodes/primnodes.h"
+#include "nodes/relation.h"
+
+#include "utils/elog.h"
+#include "nodes/nodeFuncs.h"
+#include "nodes/makefuncs.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/clauses.h"
+#include "optimizer/clauseinfo.h"
+#include "optimizer/keys.h"
+#include "optimizer/planmain.h"
+#include "optimizer/tlist.h"
+#include "optimizer/var.h"
+#include "optimizer/tlist.h"
+
+static void set_join_tlist_references(Join *join);
+static void set_tempscan_tlist_references(SeqScan *tempscan);
+static void set_temp_tlist_references(Temp *temp);
+static List *replace_clause_joinvar_refs(Expr *clause,
+ List *outer_tlist, List *inner_tlist);
+static List *replace_subclause_joinvar_refs(List *clauses,
+ List *outer_tlist, List *inner_tlist);
+static Var *replace_joinvar_refs(Var *var, List *outer_tlist, List *inner_tlist);
+static List *tlist_temp_references(Oid tempid, List *tlist);
+static void replace_result_clause(List *clause, List *subplanTargetList);
+static bool OperandIsInner(Node *opnd, int inner_relid);
+static void replace_agg_clause(Node *expr, List *targetlist);
+
+/*****************************************************************************
+ *
+ * SUBPLAN REFERENCES
+ *
+ *****************************************************************************/
+
+/*
+ * set-tlist-references--
+ * Modifies the target list of nodes in a plan to reference target lists
+ * at lower levels.
+ *
+ * 'plan' is the plan whose target list and children's target lists will
+ * be modified
+ *
+ * Returns nothing of interest, but modifies internal fields of nodes.
+ *
+ */
+void
+set_tlist_references(Plan *plan)
+{
+ if(plan==NULL)
+ return;
+
+ if (IsA_Join(plan)) {
+ set_join_tlist_references((Join*)plan);
+ } else if (IsA(plan,SeqScan) && plan->lefttree &&
+ IsA_Temp(plan->lefttree)) {
+ set_tempscan_tlist_references((SeqScan*)plan);
+ } else if (IsA(plan,Sort)) {
+ set_temp_tlist_references ((Temp*)plan);
+ } else if (IsA(plan,Result)) {
+ set_result_tlist_references((Result*)plan);
+ } else if (IsA(plan,Hash)) {
+ set_tlist_references(plan->lefttree);
+ } else if (IsA(plan,Choose)) {
+ List *x;
+ foreach (x, ((Choose*)plan)->chooseplanlist) {
+ set_tlist_references((Plan*)lfirst(x));
+ }
+ }
+}
+
+/*
+ * set-join-tlist-references--
+ * Modifies the target list of a join node by setting the varnos and
+ * varattnos to reference the target list of the outer and inner join
+ * relations.
+ *
+ * Creates a target list for a join node to contain references by setting
+ * varno values to OUTER or INNER and setting attno values to the
+ * result domain number of either the corresponding outer or inner join
+ * tuple.
+ *
+ * 'join' is a join plan node
+ *
+ * Returns nothing of interest, but modifies internal fields of nodes.
+ *
+ */
+static void
+set_join_tlist_references(Join *join)
+{
+ Plan *outer = ((Plan*)join)->lefttree;
+ Plan *inner = ((Plan*)join)->righttree;
+ List *new_join_targetlist = NIL;
+ TargetEntry *temp = (TargetEntry *)NULL;
+ List *entry = NIL;
+ List *inner_tlist = NULL;
+ List *outer_tlist = NULL;
+ TargetEntry *xtl = (TargetEntry *)NULL;
+ List *qptlist = ((Plan*)join)->targetlist;
+
+ foreach(entry, qptlist) {
+ List *joinvar;
+
+ xtl = (TargetEntry *)lfirst(entry);
+ inner_tlist = ((inner==NULL) ? NIL : inner->targetlist);
+ outer_tlist = ((outer==NULL) ? NIL : outer->targetlist);
+ joinvar = replace_clause_joinvar_refs((Expr*)get_expr(xtl),
+ outer_tlist,
+ inner_tlist);
+
+ temp = MakeTLE(xtl->resdom, (Node*)joinvar);
+ new_join_targetlist = lappend(new_join_targetlist,temp);
+ }
+
+ ((Plan*)join)->targetlist = new_join_targetlist;
+ if (outer!=NULL)
+ set_tlist_references(outer);
+ if (inner!=NULL)
+ set_tlist_references(inner);
+}
+
+/*
+ * set-tempscan-tlist-references--
+ * Modifies the target list of a node that scans a temp relation (i.e., a
+ * sort or hash node) so that the varnos refer to the child temporary.
+ *
+ * 'tempscan' is a seqscan node
+ *
+ * Returns nothing of interest, but modifies internal fields of nodes.
+ *
+ */
+static void
+set_tempscan_tlist_references(SeqScan *tempscan)
+{
+ Temp *temp = (Temp*)((Plan*)tempscan)->lefttree;
+
+ ((Plan*)tempscan)->targetlist =
+ tlist_temp_references(temp->tempid,
+ ((Plan*)tempscan)->targetlist);
+ set_temp_tlist_references(temp);
+}
+
+/*
+ * set-temp-tlist-references--
+ * The temp's vars are made consistent with (actually, identical to) the
+ * modified version of the target list of the node from which temp node
+ * receives its tuples.
+ *
+ * 'temp' is a temp (e.g., sort, hash) plan node
+ *
+ * Returns nothing of interest, but modifies internal fields of nodes.
+ *
+ */
+static void
+set_temp_tlist_references(Temp *temp)
+{
+ Plan *source = ((Plan*)temp)->lefttree;
+
+ if (source!=NULL) {
+ set_tlist_references(source);
+ ((Plan*)temp)->targetlist =
+ copy_vars(((Plan*)temp)->targetlist ,
+ (source)->targetlist);
+ } else {
+ elog(WARN, "calling set_temp_tlist_references with empty lefttree");
+ }
+}
+
+/*
+ * join-references--
+ * Creates a new set of join clauses by replacing the varno/varattno
+ * values of variables in the clauses to reference target list values
+ * from the outer and inner join relation target lists.
+ *
+ * 'clauses' is the list of join clauses
+ * 'outer-tlist' is the target list of the outer join relation
+ * 'inner-tlist' is the target list of the inner join relation
+ *
+ * Returns the new join clauses.
+ *
+ */
+List *
+join_references(List *clauses,
+ List *outer_tlist,
+ List *inner_tlist)
+{
+ return (replace_subclause_joinvar_refs(clauses,
+ outer_tlist,
+ inner_tlist));
+}
+
+/*
+ * index-outerjoin-references--
+ * Given a list of join clauses, replace the operand corresponding to the
+ * outer relation in the join with references to the corresponding target
+ * list element in 'outer-tlist' (the outer is rather obscurely
+ * identified as the side that doesn't contain a var whose varno equals
+ * 'inner-relid').
+ *
+ * As a side effect, the operator is replaced by the regproc id.
+ *
+ * 'inner-indxqual' is the list of join clauses (so-called because they
+ * are used as qualifications for the inner (inbex) scan of a nestloop)
+ *
+ * Returns the new list of clauses.
+ *
+ */
+List *
+index_outerjoin_references(List *inner_indxqual,
+ List *outer_tlist,
+ Index inner_relid)
+{
+ List *t_list = NIL;
+ Expr *temp = NULL;
+ List *t_clause = NIL;
+ Expr *clause = NULL;
+
+ foreach (t_clause,inner_indxqual) {
+ clause = lfirst(t_clause);
+ /*
+ * if inner scan on the right.
+ */
+ if (OperandIsInner((Node*)get_rightop(clause), inner_relid)) {
+ Var *joinvar = (Var*)
+ replace_clause_joinvar_refs((Expr*)get_leftop(clause),
+ outer_tlist,
+ NIL);
+ temp = make_opclause(replace_opid((Oper*)((Expr*)clause)->oper),
+ joinvar,
+ get_rightop(clause));
+ t_list = lappend(t_list,temp);
+ } else {
+ /* inner scan on left */
+ Var *joinvar = (Var*)
+ replace_clause_joinvar_refs((Expr*)get_rightop(clause),
+ outer_tlist,
+ NIL);
+ temp = make_opclause(replace_opid((Oper*)((Expr*)clause)->oper),
+ joinvar,
+ get_leftop(clause));
+ t_list = lappend(t_list,temp);
+ }
+
+ }
+ return(t_list);
+}
+
+/*
+ * replace-clause-joinvar-refs
+ * replace-subclause-joinvar-refs
+ * replace-joinvar-refs
+ *
+ * Replaces all variables within a join clause with a new var node
+ * whose varno/varattno fields contain a reference to a target list
+ * element from either the outer or inner join relation.
+ *
+ * 'clause' is the join clause
+ * 'outer-tlist' is the target list of the outer join relation
+ * 'inner-tlist' is the target list of the inner join relation
+ *
+ * Returns the new join clause.
+ *
+ */
+static List *
+replace_clause_joinvar_refs(Expr *clause,
+ List *outer_tlist,
+ List *inner_tlist)
+{
+ List *temp = NULL;
+
+ if(IsA (clause,Var)) {
+ temp = (List*)replace_joinvar_refs((Var*)clause,
+ outer_tlist,inner_tlist);
+ if(temp)
+ return(temp);
+ else
+ if (clause != NULL)
+ return((List*)clause);
+ else
+ return(NIL);
+ } else if (single_node((Node*)clause)) {
+ return ((List*)clause);
+ } else if (or_clause((Node*)clause)) {
+ List *orclause =
+ replace_subclause_joinvar_refs(((Expr*)clause)->args,
+ outer_tlist,
+ inner_tlist);
+ return ((List*)make_orclause(orclause));
+ } else if (IsA(clause,ArrayRef)) {
+ ArrayRef *aref = (ArrayRef *)clause;
+
+ temp = replace_subclause_joinvar_refs(aref->refupperindexpr,
+ outer_tlist,
+ inner_tlist);
+ aref->refupperindexpr = (List*)temp;
+ temp = replace_subclause_joinvar_refs(aref->reflowerindexpr,
+ outer_tlist,
+ inner_tlist);
+ aref->reflowerindexpr = (List*)temp;
+ temp = replace_clause_joinvar_refs((Expr*)aref->refexpr,
+ outer_tlist,
+ inner_tlist);
+ aref->refexpr = (Node*)temp;
+
+ /*
+ * no need to set refassgnexpr. we only set that in the
+ * target list on replaces, and this is an array reference
+ * in the qualification. if we got this far, it's 0x0 in
+ * the ArrayRef structure 'clause'.
+ */
+
+ return((List*)clause);
+ } else if (is_funcclause((Node*)clause)) {
+ List *funcclause =
+ replace_subclause_joinvar_refs(((Expr*)clause)->args,
+ outer_tlist,
+ inner_tlist);
+ return ((List*)make_funcclause((Func*)((Expr*)clause)->oper,
+ funcclause));
+ } else if (not_clause((Node*)clause)) {
+ List *notclause =
+ replace_clause_joinvar_refs(get_notclausearg(clause),
+ outer_tlist,
+ inner_tlist);
+ return ((List*)make_notclause((Expr*)notclause));
+ } else if (is_opclause((Node*)clause)) {
+ Var *leftvar =
+ (Var*)replace_clause_joinvar_refs((Expr*)get_leftop(clause),
+ outer_tlist,
+ inner_tlist);
+ Var *rightvar =
+ (Var*)replace_clause_joinvar_refs((Expr*)get_rightop(clause),
+ outer_tlist,
+ inner_tlist);
+ return ((List*)make_opclause(replace_opid((Oper*)((Expr*)clause)->oper),
+ leftvar,
+ rightvar));
+ }
+ /* shouldn't reach here */
+ return NULL;
+}
+
+static List *
+replace_subclause_joinvar_refs(List *clauses,
+ List *outer_tlist,
+ List *inner_tlist)
+{
+ List *t_list = NIL;
+ List *temp = NIL;
+ List *clause = NIL;
+
+ foreach (clause,clauses) {
+ temp = replace_clause_joinvar_refs(lfirst(clause),
+ outer_tlist,
+ inner_tlist);
+ t_list = lappend(t_list,temp);
+ }
+ return(t_list);
+}
+
+static Var *
+replace_joinvar_refs(Var *var, List *outer_tlist, List *inner_tlist)
+{
+ Resdom *outer_resdom =(Resdom*)NULL;
+
+ outer_resdom= tlist_member(var,outer_tlist);
+
+ if (outer_resdom!=NULL && IsA (outer_resdom,Resdom) ) {
+ return (makeVar (OUTER,
+ outer_resdom->resno,
+ var->vartype,
+ var->varnoold,
+ var->varoattno));
+ } else {
+ Resdom *inner_resdom;
+ inner_resdom = tlist_member(var,inner_tlist);
+ if ( inner_resdom!=NULL && IsA (inner_resdom,Resdom) ) {
+ return (makeVar (INNER,
+ inner_resdom->resno,
+ var->vartype,
+ var->varnoold,
+ var->varoattno));
+ }
+ }
+ return (Var*)NULL;
+}
+
+/*
+ * tlist-temp-references--
+ * Creates a new target list for a node that scans a temp relation,
+ * setting the varnos to the id of the temp relation and setting varids
+ * if necessary (varids are only needed if this is a targetlist internal
+ * to the tree, in which case the targetlist entry always contains a var
+ * node, so we can just copy it from the temp).
+ *
+ * 'tempid' is the id of the temp relation
+ * 'tlist' is the target list to be modified
+ *
+ * Returns new target list
+ *
+ */
+static List *
+tlist_temp_references(Oid tempid,
+ List *tlist)
+{
+ List *t_list = NIL;
+ TargetEntry *temp = (TargetEntry *)NULL;
+ TargetEntry *xtl = NULL;
+ List *entry;
+
+ foreach (entry, tlist) {
+ AttrNumber oattno;
+
+ xtl = lfirst(entry);
+ if (IsA(get_expr(xtl), Var))
+ oattno = ((Var*)xtl->expr)->varoattno;
+ else
+ oattno = 0;
+
+ temp = MakeTLE(xtl->resdom,
+ (Node*)makeVar(tempid,
+ xtl->resdom->resno,
+ xtl->resdom->restype,
+ tempid,
+ oattno));
+
+ t_list = lappend(t_list,temp);
+ }
+ return(t_list);
+}
+
+/*---------------------------------------------------------
+ *
+ * set_result_tlist_references
+ *
+ * Change the target list of a Result node, so that it correctly
+ * addresses the tuples returned by its left tree subplan.
+ *
+ * NOTE:
+ * 1) we ignore the right tree! (in the current implementation
+ * it is always nil
+ * 2) this routine will probably *NOT* work with nested dot
+ * fields....
+ */
+void
+set_result_tlist_references(Result *resultNode)
+{
+ Plan *subplan;
+ List *resultTargetList;
+ List *subplanTargetList;
+ List *t;
+ TargetEntry *entry;
+ Expr *expr;
+
+ resultTargetList= ((Plan*)resultNode)->targetlist;
+
+ /*
+ * NOTE: we only consider the left tree subplan.
+ * This is usually a seq scan.
+ */
+ subplan = ((Plan*)resultNode)->lefttree;
+ if (subplan != NULL) {
+ subplanTargetList = subplan->targetlist;
+ } else {
+ subplanTargetList = NIL;
+ }
+
+ /*
+ * now for traverse all the entris of the target list.
+ * These should be of the form (Resdom_Node Expression).
+ * For every expression clause, call "replace_result_clause()"
+ * to appropriatelly change all the Var nodes.
+ */
+ foreach (t, resultTargetList) {
+ entry = (TargetEntry *)lfirst(t);
+ expr = (Expr*) get_expr(entry);
+ replace_result_clause((List*)expr, subplanTargetList);
+ }
+}
+
+/*---------------------------------------------------------
+ *
+ * replace_result_clause
+ *
+ * This routine is called from set_result_tlist_references().
+ * and modifies the expressions of the target list of a Result
+ * node so that all Var nodes reference the target list of its subplan.
+ *
+ */
+static void
+replace_result_clause(List *clause,
+ List *subplanTargetList) /* target list of the
+ subplan */
+{
+ List *t;
+ List *subClause;
+ TargetEntry *subplanVar;
+
+ if (IsA(clause,Var)) {
+ /*
+ * Ha! A Var node!
+ */
+ subplanVar = match_varid((Var*)clause, subplanTargetList);
+ /*
+ * Change the varno & varattno fields of the
+ * var node.
+ *
+ */
+ ((Var*)clause)->varno = (Index)OUTER;
+ ((Var*)clause)->varattno = subplanVar->resdom->resno;
+ } else if (is_funcclause((Node*)clause)) {
+ /*
+ * This is a function. Recursively call this routine
+ * for its arguments...
+ */
+ subClause = ((Expr*)clause)->args;
+ foreach (t, subClause) {
+ replace_result_clause(lfirst(t),subplanTargetList);
+ }
+ } else if (IsA(clause,ArrayRef)) {
+ ArrayRef *aref = (ArrayRef *)clause;
+ /*
+ * This is an arrayref. Recursively call this routine
+ * for its expression and its index expression...
+ */
+ subClause = aref->refupperindexpr;
+ foreach (t, subClause) {
+ replace_result_clause(lfirst(t),subplanTargetList);
+ }
+ subClause = aref->reflowerindexpr;
+ foreach (t, subClause) {
+ replace_result_clause(lfirst(t),subplanTargetList);
+ }
+ replace_result_clause((List*)aref->refexpr,
+ subplanTargetList);
+ replace_result_clause((List*)aref->refassgnexpr,
+ subplanTargetList);
+ } else if (is_opclause((Node*)clause)) {
+ /*
+ * This is an operator. Recursively call this routine
+ * for both its left and right operands
+ */
+ subClause = (List*)get_leftop((Expr*)clause);
+ replace_result_clause(subClause,subplanTargetList);
+ subClause = (List*)get_rightop((Expr*)clause);
+ replace_result_clause(subClause,subplanTargetList);
+ } else if (IsA(clause,Param) || IsA(clause,Const)) {
+ /* do nothing! */
+ } else {
+ /*
+ * Ooops! we can not handle that!
+ */
+ elog(WARN,"replace_result_clause: Can not handle this tlist!\n");
+ }
+}
+
+static
+bool OperandIsInner(Node *opnd, int inner_relid)
+{
+ /*
+ * Can be the inner scan if its a varnode or a function and the
+ * inner_relid is equal to the varnode's var number or in the
+ * case of a function the first argument's var number (all args
+ * in a functional index are from the same relation).
+ */
+ if ( IsA (opnd,Var) &&
+ (inner_relid == ((Var*)opnd)->varno) )
+ {
+ return true;
+ }
+ if (is_funcclause(opnd))
+ {
+ List *firstArg = lfirst(((Expr*)opnd)->args);
+
+ if ( IsA (firstArg,Var) &&
+ (inner_relid == ((Var*)firstArg)->varno) )
+ {
+ return true;
+ }
+ }
+ return false;
+}
+
+/*****************************************************************************
+ *
+ *****************************************************************************/
+
+/*---------------------------------------------------------
+ *
+ * set_agg_tlist_references -
+ * changes the target list of an Agg node so that it points to
+ * the tuples returned by its left tree subplan.
+ *
+ */
+void
+set_agg_tlist_references(Agg *aggNode)
+{
+ List *aggTargetList;
+ List *subplanTargetList;
+ List *tl;
+
+ aggTargetList = aggNode->plan.targetlist;
+ subplanTargetList = aggNode->plan.lefttree->targetlist;
+
+ foreach (tl, aggTargetList) {
+ TargetEntry *tle = lfirst(tl);
+
+ replace_agg_clause(tle->expr, subplanTargetList);
+ }
+}
+
+void
+set_agg_agglist_references(Agg *aggNode)
+{
+ List *subplanTargetList;
+ Aggreg **aggs;
+ int i;
+
+ aggs = aggNode->aggs;
+ subplanTargetList = aggNode->plan.lefttree->targetlist;
+
+ for (i = 0; i < aggNode->numAgg; i++) {
+ replace_agg_clause(aggs[i]->target, subplanTargetList);
+ }
+}
+
+static void
+replace_agg_clause(Node *clause, List *subplanTargetList)
+{
+ List *t;
+ TargetEntry *subplanVar;
+
+ if (IsA(clause,Var)) {
+ /*
+ * Ha! A Var node!
+ */
+ subplanVar = match_varid((Var*)clause, subplanTargetList);
+ /*
+ * Change the varno & varattno fields of the
+ * var node.
+ *
+ */
+ ((Var*)clause)->varattno = subplanVar->resdom->resno;
+ } else if (is_funcclause(clause)) {
+ /*
+ * This is a function. Recursively call this routine
+ * for its arguments...
+ */
+ foreach (t, ((Expr*)clause)->args) {
+ replace_agg_clause(lfirst(t), subplanTargetList);
+ }
+ } else if (IsA(clause,Aggreg)) {
+ replace_agg_clause(((Aggreg*)clause)->target, subplanTargetList);
+ } else if (IsA(clause,ArrayRef)) {
+ ArrayRef *aref = (ArrayRef *)clause;
+
+ /*
+ * This is an arrayref. Recursively call this routine
+ * for its expression and its index expression...
+ */
+ foreach (t, aref->refupperindexpr) {
+ replace_agg_clause(lfirst(t),subplanTargetList);
+ }
+ foreach (t, aref->reflowerindexpr) {
+ replace_agg_clause(lfirst(t),subplanTargetList);
+ }
+ replace_agg_clause(aref->refexpr, subplanTargetList);
+ replace_agg_clause(aref->refassgnexpr, subplanTargetList);
+ } else if (is_opclause(clause)) {
+ /*
+ * This is an operator. Recursively call this routine
+ * for both its left and right operands
+ */
+ replace_agg_clause((Node*)get_leftop((Expr*)clause),
+ subplanTargetList);
+ replace_agg_clause((Node*)get_rightop((Expr*)clause),
+ subplanTargetList);
+ } else if (IsA(clause,Param) || IsA(clause,Const)) {
+ /* do nothing! */
+ } else {
+ /*
+ * Ooops! we can not handle that!
+ */
+ elog(WARN,"replace_agg_clause: Can not handle this tlist!\n");
+ }
+
+}
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * plancat.h--
+ * prototypes for plancat.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: plancat.h,v 1.1.1.1 1996/07/09 06:21:34 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PLANCAT_H
+#define PLANCAT_H
+
+#include "c.h"
+
+/*
+ * transient data structure to hold return value of index_info. Note that
+ * indexkeys, orderOprs and classlist is "null-terminated".
+ */
+typedef struct IdxInfoRetval {
+ Oid relid; /* OID of the index relation (not the OID
+ * of the relation being indexed)
+ */
+ Oid relam; /* OID of the pg_am of this index */
+ int pages; /* number of pages in the index relation */
+ int tuples; /* number of tuples in the index relation */
+ int *indexkeys; /* keys over which we're indexing */
+ Oid *orderOprs; /* operators used for ordering purposes */
+ Oid *classlist; /* classes of AM operators */
+ Oid indproc;
+ Node *indpred;
+} IdxInfoRetval;
+
+
+extern void relation_info(Query *root,
+ Oid relid,
+ bool *hashindex, int *pages,
+ int *tuples);
+
+extern bool index_info(Query *root,
+ bool first, int relid, IdxInfoRetval *info);
+
+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,
+ Oid relid, List *attnos, List *values, List *flags,
+ int32 nkeys, float *idxPages, float *idxSelec);
+
+extern Cost join_selectivity(Oid functionObjectId, Oid operatorObjectId,
+ Oid relationObjectId1, AttrNumber attributeNumber1,
+ Oid relationObjectId2, AttrNumber attributeNumber2);
+
+extern List *find_inheritance_children(Oid inhparent);
+extern List *VersionGetParents(Oid verrelid);
+
+#endif /* PLANCAT_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * planmain.h--
+ * prototypes for various files in optimizer/plan
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: planmain.h,v 1.1.1.1 1996/07/09 06:21:34 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PLANMAIN_H
+#define PLANMAIN_H
+
+
+/*
+ * prototypes for plan/planmain.c
+ */
+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,
+ Plan *lefttree);
+extern Sort *make_sort(List *tlist, Oid tempid, Plan *lefttree,
+ int keycount);
+extern Agg *make_agg(List *tlist, int nagg, Aggreg **aggs);
+extern Group *make_group(List *tlist, bool tuplePerGroup, int ngrp,
+ AttrNumber *grpColIdx, Sort *lefttree);
+extern Unique *make_unique(List *tlist, Plan *lefttree, char *uniqueAttr);
+extern List *generate_fjoin(List *tlist);
+
+
+/*
+ * prototypes for plan/initsplan.c
+ */
+extern void initialize_base_rels_list(Query *root, List *tlist);
+extern void initialize_base_rels_jinfo(Query *root, List *clauses);
+extern void initialize_join_clause_info(List *rel_list);
+extern void add_missing_vars_to_base_rels(Query *root, List *tlist);
+
+/*
+ * prototypes for plan/setrefs.c
+ */
+extern void set_tlist_references(Plan *plan);
+extern List *join_references(List *clauses, List *outer_tlist,
+ List *inner_tlist);
+extern List *index_outerjoin_references(List *inner_indxqual,
+ List *outer_tlist, Index inner_relid);
+extern void set_result_tlist_references(Result *resultNode);
+extern void set_agg_tlist_references(Agg *aggNode);
+extern void set_agg_agglist_references(Agg *aggNode);
+
+
+#endif /* PLANMAIN_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * planner.h--
+ * prototypes for planner.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: planner.h,v 1.1.1.1 1996/07/09 06:21:34 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PLANNER_H
+#define PLANNER_H
+
+/*
+#include "optimizer/internal.h"
+#include "parser/parse_query.h"
+*/
+
+extern Plan *planner(Query *parse);
+extern void pg_checkretval(Oid rettype, QueryTreeList *querytree_list);
+
+#endif /* PLANNER_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * prep.h--
+ * prototypes for files in prep.c
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: prep.h,v 1.1.1.1 1996/07/09 06:21:34 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PREP_H
+#define PREP_H
+
+#include "nodes/primnodes.h"
+#include "nodes/plannodes.h"
+
+/*
+ * prototypes for archive.h
+ */
+extern void plan_archive(List *rt);
+extern List *find_archive_rels(Oid relid);
+
+/*
+ * prototypes for prepqual.h
+ */
+extern List *preprocess_qualification(Expr *qual, List *tlist,
+ List **existentialQualPtr);
+extern List *cnfify(Expr *qual, bool removeAndFlag);
+
+/*
+ * prototypes for preptlist.h
+ */
+extern List *preprocess_targetlist(List *tlist, int command_type,
+ Index result_relation, List *range_table);
+
+/*
+ * prototypes for prepunion.h
+ */
+typedef enum UnionFlag {
+ INHERITS_FLAG, ARCHIVE_FLAG, VERSION_FLAG
+} UnionFlag;
+
+extern List *find_all_inheritors(List *unexamined_relids,
+ List *examined_relids);
+extern int first_matching_rt_entry(List *rangetable, UnionFlag flag);
+extern Append *plan_union_queries(Index rt_index, Query *parse,
+ UnionFlag flag);
+
+#endif /* PREP_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for optimizer/prep
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/optimizer/prep/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:37 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= archive.c prepqual.c preptlist.c prepunion.c
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * archive.c--
+ * Support for planning scans on archived relations
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/Attic/archive.c,v 1.1.1.1 1996/07/09 06:21:38 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* for sprintf() */
+#include /* for u_int in relcache.h */
+#include "postgres.h"
+
+#include "utils/rel.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/relcache.h"
+#include "catalog/pg_class.h"
+#include "nodes/pg_list.h"
+#include "nodes/parsenodes.h"
+#include "optimizer/prep.h"
+#include "commands/creatinh.h"
+
+void
+plan_archive(List *rt)
+{
+ List *rtitem;
+ RangeTblEntry *rte;
+ TimeRange *trange;
+ Relation r;
+ Oid reloid;
+
+ foreach(rtitem, rt) {
+ rte = lfirst(rtitem);
+ trange = rte->timeRange;
+ if (trange) {
+ reloid = rte->relid;
+ r = RelationIdGetRelation(reloid);
+ if (r->rd_rel->relarch != 'n') {
+ rte->archive = true;
+ }
+ }
+ }
+}
+
+
+/*
+ * find_archive_rels -- Given a particular relid, find the archive
+ * relation's relid.
+ */
+List *
+find_archive_rels(Oid relid)
+{
+ Relation arel;
+ char *arelName;
+
+ arelName = MakeArchiveName(relid);
+ arel = RelationNameGetRelation(arelName);
+ pfree(arelName);
+
+ return lconsi(arel->rd_id, lconsi(relid, NIL));
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * prepqual.c--
+ * Routines for preprocessing the parse tree qualification
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepqual.c,v 1.1.1.1 1996/07/09 06:21:38 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/makefuncs.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/clauses.h"
+#include "optimizer/prep.h"
+
+#include "utils/lsyscache.h"
+
+static Expr *pull_args(Expr *qual);
+static List *pull_ors(List *orlist);
+static List *pull_ands(List *andlist);
+static Expr *find_nots(Expr *qual);
+static Expr *push_nots(Expr *qual);
+static Expr *normalize(Expr *qual);
+static List *or_normalize(List *orlist);
+static List *distribute_args(List *item, List *args);
+static List *qualcleanup(Expr *qual);
+static List *remove_ands(Expr *qual);
+static List *remove_duplicates(List *list);
+
+/*
+ * preprocess-qualification--
+ * Driver routine for modifying the parse tree qualification.
+ *
+ * Returns the new base qualification and the existential qualification
+ * in existentialQualPtr.
+ *
+ * XXX right now, update_clauses() does nothing so
+ * preprocess-qualification simply converts the qual in conjunctive
+ * normal form (see cnfify() below )
+ */
+List *
+preprocess_qualification(Expr *qual, List *tlist, List **existentialQualPtr)
+{
+ List *cnf_qual = cnfify(qual, true);
+/*
+ List *existential_qual =
+ update_clauses(intCons(_query_result_relation_,
+ update_relations(tlist)),
+ cnf_qual,
+ _query_command_type_);
+ if (existential_qual) {
+ *existentialQualPtr = existential_qual;
+ return set_difference(cnf_qual, existential_qual);
+ } else {
+ *existentialQualPtr = NIL;
+ return cnf_qual;
+ }
+*/
+ /* update_clauses() is not working right now */
+ *existentialQualPtr = NIL;
+ return cnf_qual;
+
+}
+
+/*****************************************************************************
+ *
+ * CNF CONVERSION ROUTINES
+ *
+ * NOTES:
+ * The basic algorithms for normalizing the qualification are taken
+ * from ingres/source/qrymod/norml.c
+ *
+ * Remember that the initial qualification may consist of ARBITRARY
+ * combinations of clauses. In addition, before this routine is called,
+ * the qualification will contain explicit "AND"s.
+ *
+ *****************************************************************************/
+
+
+/*
+ * cnfify--
+ * Convert a qualification to conjunctive normal form by applying
+ * successive normalizations.
+ *
+ * Returns the modified qualification with an extra level of nesting.
+ *
+ * If 'removeAndFlag' is true then it removes the explicit ANDs.
+ *
+ * NOTE: this routine is called by the planner (removeAndFlag = true)
+ * and from the rule manager (removeAndFlag = false).
+ *
+ */
+List *
+cnfify(Expr *qual, bool removeAndFlag)
+{
+ Expr *newqual = NULL;
+
+ if (qual != NULL) {
+ newqual = find_nots(pull_args(qual));
+ newqual = normalize(pull_args(newqual));
+ newqual = (Expr*)qualcleanup(pull_args(newqual));
+ newqual = pull_args(newqual);;
+
+ if (removeAndFlag) {
+ if(and_clause((Node*)newqual))
+ newqual=(Expr*)remove_ands(newqual);
+ else
+ newqual=(Expr*)remove_ands(make_andclause(lcons(newqual,NIL)));
+ }
+ }
+ else if (qual!=NULL)
+ newqual = (Expr*)lcons(qual, NIL);
+
+ return (List*)(newqual);
+}
+
+/*
+ * pull-args--
+ * Given a qualification, eliminate nested 'and' and 'or' clauses.
+ *
+ * Returns the modified qualification.
+ *
+ */
+static Expr *
+pull_args(Expr *qual)
+{
+ if (qual==NULL)
+ return (NULL);
+
+ if (is_opclause((Node*)qual)) {
+ return(make_clause(qual->opType, qual->oper,
+ lcons(pull_args((Expr*)get_leftop(qual)),
+ lcons(pull_args((Expr*)get_rightop(qual)),
+ NIL))));
+ } else if (and_clause((Node*)qual)) {
+ List *temp = NIL;
+ List *t_list = NIL;
+
+ foreach (temp, qual->args)
+ t_list = lappend (t_list, pull_args(lfirst(temp)));
+ return (make_andclause (pull_ands (t_list)));
+ }else if (or_clause((Node*)qual)) {
+ List *temp = NIL;
+ List *t_list = NIL;
+
+ foreach (temp, qual->args)
+ t_list = lappend (t_list, pull_args(lfirst(temp)));
+ return (make_orclause (pull_ors (t_list)));
+ } else if (not_clause((Node*)qual)) {
+ return (make_notclause (pull_args (get_notclausearg (qual))));
+ } else {
+ return (qual);
+ }
+}
+
+/*
+ * pull-ors--
+ * Pull the arguments of an 'or' clause nested within another 'or'
+ * clause up into the argument list of the parent.
+ *
+ * Returns the modified list.
+ */
+static List *
+pull_ors(List *orlist)
+{
+ if (orlist==NIL)
+ return (NIL);
+
+ if (or_clause(lfirst(orlist))) {
+ List *args = ((Expr*)lfirst(orlist))->args;
+ return (pull_ors(nconc(copyObject((Node*)args),
+ copyObject((Node*)lnext(orlist)))));
+ } else {
+ return (lcons(lfirst(orlist), pull_ors(lnext(orlist))));
+ }
+}
+
+/*
+ * pull-ands--
+ * Pull the arguments of an 'and' clause nested within another 'and'
+ * clause up into the argument list of the parent.
+ *
+ * Returns the modified list.
+ */
+static List *
+pull_ands(List *andlist)
+{
+ if (andlist==NIL)
+ return (NIL);
+
+ if (and_clause (lfirst(andlist))) {
+ List *args = ((Expr*)lfirst(andlist))->args;
+ return (pull_ands(nconc(copyObject((Node*)args),
+ copyObject((Node*)lnext(andlist)))));
+ } else {
+ return (lcons(lfirst(andlist), pull_ands(lnext(andlist))));
+ }
+}
+
+/*
+ * find-nots--
+ * Traverse the qualification, looking for 'not's to take care of.
+ * For 'not' clauses, remove the 'not' and push it down to the clauses'
+ * descendants.
+ * For all other clause types, simply recurse.
+ *
+ * Returns the modified qualification.
+ *
+ */
+static Expr *
+find_nots(Expr *qual)
+{
+ if (qual==NULL)
+ return (NULL);
+
+ if (is_opclause((Node*)qual)) {
+ return (make_clause(qual->opType, qual->oper,
+ lcons(find_nots((Expr*)get_leftop(qual)),
+ lcons(find_nots((Expr*)get_rightop(qual)),
+ NIL))));
+ } else if (and_clause ((Node*)qual)) {
+ List *temp = NIL;
+ List *t_list = NIL;
+
+ foreach (temp, qual->args) {
+ t_list = lappend(t_list,find_nots(lfirst(temp)));
+ }
+
+ return (make_andclause(t_list));
+ } else if (or_clause((Node*)qual)) {
+ List *temp = NIL;
+ List *t_list = NIL;
+
+ foreach (temp, qual->args) {
+ t_list = lappend(t_list,find_nots(lfirst(temp)));
+ }
+ return (make_orclause (t_list));
+ } else if (not_clause((Node*)qual))
+ return (push_nots(get_notclausearg (qual)));
+ else
+ return (qual);
+}
+
+/*
+ * push-nots--
+ * Negate the descendants of a 'not' clause.
+ *
+ * Returns the modified qualification.
+ *
+ */
+static Expr *
+push_nots(Expr *qual)
+{
+ if (qual==NULL)
+ return (NULL);
+
+ /*
+ * Negate an operator clause if possible:
+ * ("NOT" (< A B)) => (> A B)
+ * Otherwise, retain the clause as it is (the 'not' can't be pushed
+ * down any farther).
+ */
+ if (is_opclause((Node*)qual)) {
+ Oper *oper = (Oper*)((Expr*)qual)->oper;
+ Oid negator = get_negator(oper->opno);
+
+ if(negator) {
+ Oper *op = (Oper*) makeOper(negator,
+ InvalidOid,
+ oper->opresulttype,
+ 0, NULL);
+ op->op_fcache = (FunctionCache *) NULL;
+ return
+ (make_opclause(op, get_leftop(qual), get_rightop(qual)));
+ } else {
+ return (make_notclause(qual));
+ }
+ } else if (and_clause((Node*)qual)) {
+ /* Apply DeMorgan's Laws:
+ * ("NOT" ("AND" A B)) => ("OR" ("NOT" A) ("NOT" B))
+ * ("NOT" ("OR" A B)) => ("AND" ("NOT" A) ("NOT" B))
+ * i.e., continue negating down through the clause's descendants.
+ */
+ List *temp = NIL;
+ List *t_list = NIL;
+
+ foreach(temp, qual->args) {
+ t_list = lappend(t_list,push_nots(lfirst(temp)));
+ }
+ return (make_orclause (t_list));
+ } else if (or_clause((Node*)qual)) {
+ List *temp = NIL;
+ List *t_list = NIL;
+
+ foreach(temp, qual->args) {
+ t_list = lappend(t_list,push_nots(lfirst(temp)));
+ }
+ return (make_andclause (t_list));
+ } else if (not_clause((Node*)qual))
+ /* Another 'not' cancels this 'not', so eliminate the 'not' and
+ * stop negating this branch.
+ */
+ return (find_nots (get_notclausearg (qual)));
+ else
+ /* We don't know how to negate anything else, place a 'not' at this
+ * level.
+ */
+ return (make_notclause (qual));
+}
+
+/*
+ * normalize--
+ * Given a qualification tree with the 'not's pushed down, convert it
+ * to a tree in CNF by repeatedly applying the rule:
+ * ("OR" A ("AND" B C)) => ("AND" ("OR" A B) ("OR" A C))
+ * bottom-up.
+ * Note that 'or' clauses will always be turned into 'and' clauses.
+ *
+ * Returns the modified qualification.
+ *
+ */
+static Expr *
+normalize(Expr *qual)
+{
+ if (qual==NULL)
+ return (NULL);
+
+ if (is_opclause((Node*)qual)) {
+ Expr *expr = (Expr*)qual;
+ return (make_clause(expr->opType, expr->oper,
+ lcons(normalize((Expr*)get_leftop(qual)),
+ lcons(normalize((Expr*)get_rightop(qual)),
+ NIL))));
+ } else if (and_clause((Node*)qual)) {
+ List *temp = NIL;
+ List *t_list = NIL;
+
+ foreach (temp, qual->args) {
+ t_list = lappend(t_list,normalize(lfirst(temp)));
+ }
+ return (make_andclause (t_list));
+ } else if (or_clause((Node*)qual)) {
+ /* XXX - let form, maybe incorrect */
+ List *orlist = NIL;
+ List *temp = NIL;
+ bool has_andclause = FALSE;
+
+ foreach(temp, qual->args) {
+ orlist = lappend(orlist,normalize(lfirst(temp)));
+ }
+ foreach (temp, orlist) {
+ if (and_clause (lfirst(temp))) {
+ has_andclause = TRUE;
+ break;
+ }
+ }
+ if (has_andclause == TRUE)
+ return (make_andclause(or_normalize(orlist)));
+ else
+ return (make_orclause(orlist));
+
+ } else if (not_clause((Node*)qual))
+ return (make_notclause (normalize (get_notclausearg (qual))));
+ else
+ return (qual);
+}
+
+/*
+ * or-normalize--
+ * Given a list of exprs which are 'or'ed together, distribute any
+ * 'and' clauses.
+ *
+ * Returns the modified list.
+ *
+ */
+static List *
+or_normalize(List *orlist)
+{
+ List *distributable = NIL;
+ List *new_orlist = NIL;
+ List *temp = NIL;
+
+ if (orlist==NIL)
+ return NIL;
+
+ foreach(temp, orlist) {
+ if (and_clause(lfirst(temp)))
+ distributable = lfirst(temp);
+ }
+ if (distributable)
+ new_orlist = LispRemove(distributable,orlist);
+
+ if(new_orlist) {
+ return
+ (or_normalize(lcons(distribute_args(lfirst(new_orlist),
+ ((Expr*)distributable)->args),
+ lnext(new_orlist))));
+ }else {
+ return (orlist);
+ }
+}
+
+/*
+ * distribute-args--
+ * Create new 'or' clauses by or'ing 'item' with each element of 'args'.
+ * E.g.: (distribute-args A ("AND" B C)) => ("AND" ("OR" A B) ("OR" A C))
+ *
+ * Returns an 'and' clause.
+ *
+ */
+static List *
+distribute_args(List *item, List *args)
+{
+ List *or_list = NIL;
+ List *n_list = NIL;
+ List *temp = NIL;
+ List *t_list = NIL;
+
+ if (args==NULL)
+ return (item);
+
+ foreach (temp,args) {
+ n_list = or_normalize(pull_ors(lcons(item,
+ lcons(lfirst(temp),NIL))));
+ or_list = (List*)make_orclause(n_list);
+ t_list = lappend(t_list,or_list);
+ }
+ return ((List*)make_andclause(t_list));
+}
+
+/*
+ * qualcleanup--
+ * Fix up a qualification by removing duplicate entries (left over from
+ * normalization), and by removing 'and' and 'or' clauses which have only
+ * one valid expr (e.g., ("AND" A) => A).
+ *
+ * Returns the modified qualfication.
+ *
+ */
+static List *
+qualcleanup(Expr *qual)
+{
+ if (qual==NULL)
+ return (NIL);
+
+ if (is_opclause((Node*)qual)) {
+ return ((List*)make_clause(qual->opType, qual->oper,
+ lcons(qualcleanup((Expr*)get_leftop(qual)),
+ lcons(qualcleanup((Expr*)get_rightop(qual)),
+ NIL))));
+ } else if (and_clause((Node*)qual)) {
+ List *temp = NIL;
+ List *t_list = NIL;
+ List *new_and_args = NIL;
+
+ foreach(temp, qual->args)
+ t_list = lappend(t_list,qualcleanup(lfirst(temp)));
+
+ new_and_args = remove_duplicates(t_list);
+
+ if(length (new_and_args) > 1)
+ return ((List*)make_andclause(new_and_args));
+ else
+ return (lfirst(new_and_args));
+ }
+ else if (or_clause((Node*)qual)) {
+ List *temp = NIL;
+ List *t_list = NIL;
+ List *new_or_args = NIL;
+
+ foreach (temp, qual->args)
+ t_list = lappend(t_list,qualcleanup(lfirst(temp)));
+
+ new_or_args = remove_duplicates(t_list);
+
+
+ if(length (new_or_args) > 1)
+ return ((List*)make_orclause (new_or_args));
+ else
+ return (lfirst (new_or_args));
+ } else if (not_clause((Node*)qual))
+ return ((List*)make_notclause((Expr*)qualcleanup((Expr*)get_notclausearg(qual))));
+
+ else
+ return ((List*)qual);
+}
+
+/*
+ * remove-ands--
+ * Remove the explicit "AND"s from the qualification:
+ * ("AND" A B) => (A B)
+ *
+ * RETURNS : qual
+ * MODIFIES: qual
+ */
+static List *
+remove_ands(Expr *qual)
+{
+ List *t_list = NIL;
+
+ if (qual==NULL)
+ return (NIL);
+ if (is_opclause((Node*)qual)) {
+ return ((List*)make_clause(qual->opType, qual->oper,
+ lcons(remove_ands((Expr*)get_leftop(qual)),
+ lcons(remove_ands((Expr*)get_rightop(qual)),
+ NIL))));
+ } else if (and_clause((Node*)qual)) {
+ List *temp = NIL;
+ foreach (temp, qual->args)
+ t_list = lappend(t_list,remove_ands(lfirst(temp)));
+ return(t_list);
+ } else if (or_clause((Node*)qual)) {
+ List *temp = NIL;
+ foreach (temp, qual->args)
+ t_list = lappend(t_list,remove_ands(lfirst(temp)));
+ return ((List*)make_orclause((List*)t_list));
+ } else if (not_clause((Node*)qual)) {
+ return ((List*)make_notclause((Expr*)remove_ands((Expr*)get_notclausearg (qual))));
+ } else {
+ return ((List*)qual);
+ }
+}
+
+/*****************************************************************************
+ *
+ * EXISTENTIAL QUALIFICATIONS
+ *
+ *****************************************************************************/
+
+/*
+ * update-relations--
+ * Returns the range table indices (i.e., varnos) for all relations which
+ * are referenced in the target list.
+ *
+ */
+#if 0
+static List *
+update_relations(List *tlist)
+{
+ return(NIL);
+}
+#endif
+
+/*****************************************************************************
+ *
+ *
+ *
+ *****************************************************************************/
+
+static List *
+remove_duplicates(List *list)
+{
+ List *i;
+ List *j;
+ List *result = NIL;
+ bool there_exists_duplicate = false;
+
+ if (length(list) == 1)
+ return(list);
+
+ foreach (i, list) {
+ if (i != NIL) {
+ foreach (j, lnext(i)) {
+ if (equal(lfirst(i), lfirst(j)))
+ there_exists_duplicate = true;
+ }
+ if (!there_exists_duplicate)
+ result = lappend(result, lfirst(i));
+
+ there_exists_duplicate = false;
+ }
+ }
+ return(result);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * preptlist.c--
+ * Routines to preprocess the parse tree target list
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/preptlist.c,v 1.1.1.1 1996/07/09 06:21:38 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/relation.h"
+#include "nodes/primnodes.h"
+#include "nodes/parsenodes.h"
+
+#include "nodes/makefuncs.h"
+
+#include "utils/builtins.h"
+#include "utils/lsyscache.h"
+#include "utils/palloc.h"
+
+#include "parser/parsetree.h" /* for getrelid() */
+#include "parser/catalog_utils.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/prep.h"
+#include "optimizer/clauses.h"
+#include "optimizer/tlist.h"
+
+static List *expand_targetlist(List *tlist, Oid relid, int command_type,
+ Index result_relation);
+static List *replace_matching_resname(List *new_tlist,
+ List *old_tlist);
+static List *new_relation_targetlist(Oid relid, Index rt_index,
+ NodeTag node_type);
+
+
+/*
+ * preprocess-targetlist--
+ * Driver for preprocessing the parse tree targetlist.
+ *
+ * 1. Deal with appends and replaces by filling missing attributes
+ * in the target list.
+ * 2. Reset operator OIDs to the appropriate regproc ids.
+ *
+ * Returns the new targetlist.
+ */
+List *
+preprocess_targetlist(List *tlist,
+ int command_type,
+ Index result_relation,
+ List *range_table)
+{
+ List *expanded_tlist = NIL;
+ Oid relid = InvalidOid;
+ List *t_list = NIL;
+ List *temp = NIL;
+
+ if (result_relation>=1 && command_type != CMD_SELECT) {
+ relid = getrelid(result_relation, range_table);
+ }
+
+ /*
+ * for heap_formtuple to work, the targetlist must match the exact
+ * order of the attributes. We also need to fill in the missing
+ * attributes here. -ay 10/94
+ */
+ expanded_tlist =
+ expand_targetlist(tlist, relid, command_type, result_relation);
+
+ /* XXX should the fix-opids be this early?? */
+ /* was mapCAR */
+ foreach (temp,expanded_tlist) {
+ TargetEntry *tle = lfirst(temp);
+ if (tle->expr)
+ fix_opid(tle->expr);
+ }
+ t_list = copyObject(expanded_tlist);
+
+ /* ------------------
+ * for "replace" or "delete" queries, add ctid of the result
+ * relation into the target list so that the ctid can get
+ * propogate through the execution and in the end ExecReplace()
+ * will find the right tuple to replace or delete. This
+ * extra field will be removed in ExecReplace().
+ * For convinient, we append this extra field to the end of
+ * the target list.
+ * ------------------
+ */
+ if (command_type == CMD_UPDATE || command_type == CMD_DELETE) {
+ TargetEntry *ctid;
+ Resdom *resdom;
+ Var *var;
+
+ resdom = makeResdom(length(t_list) + 1,
+ 27,
+ 6,
+ "ctid",
+ 0,
+ 0,
+ 1);
+
+ var = makeVar(result_relation, -1, 27, result_relation, -1);
+
+ ctid = makeNode(TargetEntry);
+ ctid->resdom = resdom;
+ ctid->expr = (Node *)var;
+ t_list = lappend(t_list, ctid);
+ }
+
+ return(t_list);
+}
+
+/*****************************************************************************
+ *
+ * TARGETLIST EXPANSION
+ *
+ *****************************************************************************/
+
+/*
+ * expand-targetlist--
+ * Given a target list as generated by the parser and a result relation,
+ * add targetlist entries for the attributes which have not been used.
+ *
+ * XXX This code is only supposed to work with unnested relations.
+ *
+ * 'tlist' is the original target list
+ * 'relid' is the relid of the result relation
+ * 'command' is the update command
+ *
+ * Returns the expanded target list, sorted in resno order.
+ */
+static List *
+expand_targetlist(List *tlist,
+ Oid relid,
+ int command_type,
+ Index result_relation)
+{
+ NodeTag node_type = T_Invalid;
+
+ switch (command_type) {
+ case CMD_INSERT:
+ node_type = (NodeTag)T_Const;
+ break;
+ case CMD_UPDATE:
+ node_type = (NodeTag)T_Var;
+ break;
+ }
+
+ if(node_type != T_Invalid) {
+ List *ntlist = new_relation_targetlist(relid,
+ result_relation,
+ node_type);
+
+ return (replace_matching_resname(ntlist, tlist));
+ } else {
+ return (tlist);
+ }
+
+}
+
+
+static List *
+replace_matching_resname(List *new_tlist, List *old_tlist)
+{
+ List *temp, *i;
+ List *t_list = NIL;
+
+ foreach (i,new_tlist) {
+ TargetEntry *new_tle = (TargetEntry *)lfirst(i);
+ TargetEntry *matching_old_tl = NULL;
+
+ foreach (temp, old_tlist) {
+ TargetEntry *old_tle = (TargetEntry *)lfirst(temp);
+
+ old_tle = lfirst(temp);
+ if (!strcmp(old_tle->resdom->resname,
+ new_tle->resdom->resname)) {
+ matching_old_tl = old_tle;
+ break;
+ }
+ }
+
+ if(matching_old_tl) {
+ matching_old_tl->resdom->resno =
+ new_tle->resdom->resno;
+ t_list = lappend(t_list, matching_old_tl);
+ }
+ else {
+ t_list = lappend(t_list, new_tle);
+ }
+ }
+
+ /*
+ * It is possible that 'old_tlist' has some negative
+ * attributes (i.e. negative resnos). This only happens
+ * if this is a replace/append command and we explicitly
+ * specify a system attribute. Of course this is not a very good
+ * idea if this is a user query, but on the other hand the rule
+ * manager uses this mechanism to replace rule locks.
+ *
+ * So, copy all these entries to the end of the target list
+ * and set their 'resjunk' value to 1 to show that these are
+ * special attributes and have to be treated specially by the
+ * executor!
+ */
+ foreach (temp, old_tlist) {
+ TargetEntry *old_tle, *new_tl;
+ Resdom *newresno;
+
+ old_tle = lfirst(temp);
+ if (old_tle->resdom->resno < 0) {
+ newresno = (Resdom*) copyObject((Node*)old_tle->resdom);
+ newresno->resno = length(t_list) +1;
+ newresno->resjunk = 1;
+ new_tl = MakeTLE(newresno, old_tle->expr);
+ t_list = lappend(t_list, new_tl);
+ }
+ }
+
+ return (t_list);
+}
+
+/*
+ * new-relation-targetlist--
+ * Generate a targetlist for the relation with relation OID 'relid'
+ * and rangetable index 'rt-index'.
+ *
+ * Returns the new targetlist.
+ */
+static List *
+new_relation_targetlist(Oid relid, Index rt_index, NodeTag node_type)
+{
+ AttrNumber attno;
+ List *t_list = NIL;
+ char *attname;
+ Oid atttype = 0;
+ int16 typlen = 0;
+ bool attisset = false;
+/* Oid type_id; */
+/* type_id = RelationIdGetTypeId(relid); */
+
+ for(attno=1; attno <= get_relnatts(relid); attno++) {
+ attname = get_attname(/*type_id,*/ relid, attno);
+ atttype = get_atttype(/*type_id,*/ relid, attno);
+ /*
+ * Since this is an append or replace, the size of any set
+ * attribute is the size of the OID used to represent it.
+ */
+ attisset = get_attisset(/* type_id,*/ relid, attname);
+ if (attisset) {
+ typlen = tlen(type("oid"));
+ } else {
+ typlen = get_typlen(atttype);
+ }
+
+ switch (node_type) {
+ case T_Const:
+ {
+ struct varlena *typedefault = get_typdefault(atttype);
+ int temp = 0;
+ Const *temp2 = (Const*)NULL;
+ TargetEntry *temp3 = (TargetEntry *)NULL;
+
+ if (typedefault==NULL)
+ temp = 0;
+ else
+ temp = typlen;
+
+ temp2 = makeConst (atttype,
+ temp,
+ (Datum)typedefault,
+ (typedefault == (struct varlena *)NULL),
+ /* XXX this is bullshit */
+ false,
+ false /* not a set */);
+
+ temp3 = MakeTLE (makeResdom(attno,
+ atttype,
+ typlen,
+ attname,
+ 0,
+ (Oid)0,
+ 0),
+ (Node*)temp2);
+ t_list = lappend(t_list,temp3);
+ break;
+ }
+ case T_Var:
+ {
+ Var *temp_var = (Var*)NULL;
+ TargetEntry *temp_list = NULL;
+
+ temp_var =
+ makeVar(rt_index, attno, atttype, rt_index, attno);
+
+ temp_list = MakeTLE(makeResdom(attno,
+ atttype,
+ typlen,
+ attname,
+ 0,
+ (Oid)0,
+ 0),
+ (Node*)temp_var);
+ t_list = lappend(t_list,temp_list);
+ break;
+ }
+ default: /* do nothing */
+ break;
+ }
+ }
+
+ return(t_list);
+}
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * prepunion.c--
+ * Routines to plan archive, inheritance, union, and version queries
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.1.1.1 1996/07/09 06:21:38 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/nodes.h"
+#include "nodes/pg_list.h"
+#include "nodes/execnodes.h"
+#include "nodes/plannodes.h"
+#include "nodes/relation.h"
+
+#include "parser/parse_query.h"
+#include "parser/parsetree.h"
+
+#include "utils/elog.h"
+#include "utils/lsyscache.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/prep.h"
+#include "optimizer/plancat.h"
+#include "optimizer/planner.h"
+#include "optimizer/prep.h"
+
+static List *plan_union_query(List *relids, Index rt_index,
+ RangeTblEntry *rt_entry, Query *parse, UnionFlag flag,
+ List **union_rtentriesPtr);
+static RangeTblEntry *new_rangetable_entry(Oid new_relid,
+ RangeTblEntry *old_entry);
+static Query *subst_rangetable(Query *root, Index index,
+ RangeTblEntry *new_entry);
+static void fix_parsetree_attnums(Index rt_index, Oid old_relid,
+ Oid new_relid, Query *parsetree);
+static Append *make_append(List *unionplans, Index rt_index,
+ List *union_rt_entries, List *tlist);
+
+
+/*
+ * find-all-inheritors -
+ * Returns a list of relids corresponding to relations that inherit
+ * attributes from any relations listed in either of the argument relid
+ * lists.
+ */
+List *
+find_all_inheritors(List *unexamined_relids,
+ List *examined_relids)
+{
+ List *new_inheritors = NIL;
+ List *new_examined_relids = NIL;
+ List *new_unexamined_relids = NIL;
+
+ /* Find all relations which inherit from members of
+ * 'unexamined-relids' and store them in 'new-inheritors'.
+ */
+ List *rels = NIL;
+ List *newrels = NIL;
+
+ foreach(rels,unexamined_relids) {
+ newrels = (List*)LispUnioni(find_inheritance_children(lfirsti(rels)),
+ newrels);
+ }
+ new_inheritors = newrels;
+
+ new_examined_relids = (List*)LispUnioni(examined_relids,unexamined_relids);
+ new_unexamined_relids = set_differencei(new_inheritors,
+ new_examined_relids);
+
+ if (new_unexamined_relids==NULL) {
+ return(new_examined_relids);
+ } else {
+ return (find_all_inheritors (new_unexamined_relids,
+ new_examined_relids));
+ }
+}
+
+/*
+ * first-matching-rt-entry -
+ * Given a rangetable, find the first rangetable entry that represents
+ * the appropriate special case.
+ *
+ * Returns a rangetable index., Returns -1 if no matches
+ */
+int
+first_matching_rt_entry (List *rangetable, UnionFlag flag)
+{
+ int count = 0;
+ List *temp = NIL;
+
+ foreach(temp, rangetable) {
+ RangeTblEntry *rt_entry = lfirst(temp);
+
+ switch(flag) {
+ case INHERITS_FLAG:
+ if (rt_entry->inh)
+ return count+1;
+ break;
+ case ARCHIVE_FLAG:
+ if (rt_entry->archive)
+ return count+1;
+ break;
+ default:
+ break;
+ }
+ count++;
+ }
+
+ return(-1);
+}
+
+
+/*
+ * plan-union-queries--
+ *
+ * Plans the queries for a given parent relation.
+ *
+ * Returns a list containing a list of plans and a list of rangetable
+ * entries to be inserted into an APPEND node.
+ * XXX - what exactly does this mean, look for make_append
+ */
+Append *
+plan_union_queries(Index rt_index,
+ Query *parse,
+ UnionFlag flag)
+{
+ List *rangetable = parse->rtable;
+ RangeTblEntry *rt_entry = rt_fetch(rt_index,rangetable);
+ List *union_relids = NIL;
+ List *union_plans = NIL;
+ List *union_rt_entries = NIL;
+
+ switch (flag) {
+ case INHERITS_FLAG:
+ union_relids =
+ find_all_inheritors(lconsi(rt_entry->relid,
+ NIL),
+ NIL);
+ break;
+
+#if 0
+ case UNION_FLAG:
+ {
+ Index rt_index = 0;
+ union_plans = handleunion(root,rangetable,tlist,qual);
+ return (make_append (union_plans,
+ rt_index, rangetable,
+ ((Plan*)lfirst(union_plans))->targetlist ));
+ }
+ break;
+#endif
+
+ case VERSION_FLAG:
+ union_relids = VersionGetParents(rt_entry->relid);
+ break;
+
+ case ARCHIVE_FLAG:
+ union_relids = find_archive_rels(rt_entry->relid);
+ break;
+
+ default:
+ /* do nothing */
+ break;
+ }
+
+ /*
+ * Remove the flag for this relation, since we're about to handle it
+ * (do it before recursing!).
+ * XXX destructive parse tree change
+ */
+ switch(flag) {
+ case INHERITS_FLAG:
+ rt_fetch(rt_index,rangetable)->inh = false;
+ break;
+ case ARCHIVE_FLAG:
+ rt_fetch(rt_index,rangetable)->archive = false;
+ break;
+ default:
+ break;
+ }
+
+ /* XXX - can't find any reason to sort union-relids
+ * as paul did, so we're leaving it out for now
+ * (maybe forever) - jeff & lp
+ *
+ * [maybe so. btw, jeff & lp did the lisp conversion, according to Paul.
+ * -- ay 10/94.]
+ */
+ union_plans = plan_union_query(union_relids, rt_index, rt_entry,
+ parse, flag, &union_rt_entries);
+
+ return (make_append(union_plans,
+ rt_index,
+ union_rt_entries,
+ ((Plan*)lfirst(union_plans))->targetlist));
+}
+
+
+/*
+ * plan-union-query--
+ * Returns a list of plans for 'relids' and a list of range table entries
+ * in union_rtentries.
+ */
+static List *
+plan_union_query(List *relids,
+ Index rt_index,
+ RangeTblEntry *rt_entry,
+ Query *root,
+ UnionFlag flag,
+ List **union_rtentriesPtr)
+{
+ List *i;
+ List *union_plans = NIL;
+ List *union_rtentries = NIL;
+
+ foreach (i, relids) {
+ int relid = lfirsti(i);
+ RangeTblEntry *new_rt_entry = new_rangetable_entry(relid,
+ rt_entry);
+ Query *new_root = subst_rangetable(root,
+ rt_index,
+ new_rt_entry);
+
+ /* reset the uniqueflag and sortclause in parse tree root, so that
+ * sorting will only be done once after append
+ */
+/* new_root->uniqueFlag = false; */
+ new_root->uniqueFlag = NULL;
+ new_root->sortClause = NULL;
+ if (flag == ARCHIVE_FLAG) {
+ /*
+ * the entire union query uses the same (most recent) schema.
+ * to do otherwise would require either ragged tuples or careful
+ * archiving and interpretation of pg_attribute...
+ */
+ } else {
+ fix_parsetree_attnums(rt_index,
+ rt_entry->relid,
+ relid,
+ new_root);
+ }
+
+ union_plans = lappend(union_plans, planner(new_root));
+ union_rtentries = lappend(union_rtentries, new_rt_entry);
+ }
+
+ *union_rtentriesPtr = union_rtentries;
+ return(union_plans);
+}
+
+/*
+ * new-rangetable-entry -
+ * Replaces the name and relid of 'old-entry' with the values for
+ * 'new-relid'.
+ *
+ * Returns a copy of 'old-entry' with the parameters substituted.
+ */
+static RangeTblEntry *
+new_rangetable_entry(Oid new_relid, RangeTblEntry *old_entry)
+{
+ RangeTblEntry *new_entry = copyObject(old_entry);
+
+ /* ??? someone tell me what the following is doing! - ay 11/94 */
+ if (!strcmp(new_entry->refname, "*CURRENT*") ||
+ !strcmp(new_entry->refname, "*NEW*"))
+ new_entry->refname = get_rel_name(new_relid);
+ else
+ new_entry->relname = get_rel_name(new_relid);
+
+ new_entry->relid = new_relid;
+ return(new_entry);
+}
+
+/*
+ * subst-rangetable--
+ * Replaces the 'index'th rangetable entry in 'root' with 'new-entry'.
+ *
+ * Returns a new copy of 'root'.
+ */
+static Query *
+subst_rangetable(Query *root, Index index, RangeTblEntry *new_entry)
+{
+ Query *new_root = copyObject(root);
+ List *temp = NIL;
+ int i = 0;
+
+ for(temp = new_root->rtable,i =1; i < index; temp =lnext(temp),i++)
+ ;
+ lfirst(temp) = new_entry;
+
+ return (new_root);
+}
+
+static void
+fix_parsetree_attnums_nodes(Index rt_index,
+ Oid old_relid,
+ Oid new_relid,
+ Node *node)
+{
+ if (node==NULL)
+ return;
+
+ switch(nodeTag(node)) {
+ case T_TargetEntry:
+ {
+ TargetEntry *tle = (TargetEntry *)node;
+
+ fix_parsetree_attnums_nodes(rt_index, old_relid, new_relid,
+ tle->expr);
+ }
+ break;
+ case T_Expr:
+ {
+ Expr *expr = (Expr *)node;
+ fix_parsetree_attnums_nodes(rt_index, old_relid, new_relid,
+ (Node*)expr->args);
+ }
+ break;
+ case T_Var:
+ {
+ Var *var = (Var *)node;
+ Oid old_typeid, new_typeid;
+
+/* old_typeid = RelationIdGetTypeId(old_relid);*/
+/* new_typeid = RelationIdGetTypeId(new_relid);*/
+ old_typeid = old_relid;
+ new_typeid = new_relid;
+
+ if (var->varno == rt_index && var->varattno != 0) {
+ var->varattno =
+ get_attnum(new_typeid,
+ get_attname(old_typeid, var->varattno));
+ }
+ }
+ break;
+ case T_List:
+ {
+ List *l;
+ foreach(l, (List*)node) {
+ fix_parsetree_attnums_nodes(rt_index, old_relid, new_relid,
+ (Node*)lfirst(l));
+ }
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+/*
+ * fix-parsetree-attnums--
+ * Replaces attribute numbers from the relation represented by
+ * 'old-relid' in 'parsetree' with the attribute numbers from
+ * 'new-relid'.
+ *
+ * Returns the destructively-modified parsetree.
+ *
+ */
+static void
+fix_parsetree_attnums(Index rt_index,
+ Oid old_relid,
+ Oid new_relid,
+ Query *parsetree)
+{
+ if (old_relid == new_relid)
+ return;
+
+ fix_parsetree_attnums_nodes(rt_index, old_relid, new_relid,
+ (Node*)parsetree->targetList);
+ fix_parsetree_attnums_nodes(rt_index, old_relid, new_relid,
+ parsetree->qual);
+}
+
+static Append *
+make_append(List *unionplans,
+ Index rt_index,
+ List *union_rt_entries,
+ List *tlist)
+{
+ Append *node = makeNode(Append);
+
+ node->unionplans = unionplans;
+ node->unionrelid = rt_index;
+ node->unionrtentries = union_rt_entries;
+ node->plan.cost = 0.0;
+ node->plan.state = (EState*)NULL;
+ node->plan.targetlist = tlist;
+ node->plan.qual = NIL;
+ node->plan.lefttree = (Plan*)NULL;
+ node->plan.righttree = (Plan*)NULL;
+
+ return(node);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * tlist.h--
+ * prototypes for tlist.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: tlist.h,v 1.1.1.1 1996/07/09 06:21:34 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef TLIST_H
+#define TLIST_H
+
+extern int exec_tlist_length(List *targelist);
+extern TargetEntry *tlistentry_member(Var *var, List *targetlist);
+extern Expr *matching_tlvar(Var *var, List *targetlist);
+extern void add_tl_element(Rel *rel, Var *var);
+extern TargetEntry *create_tl_element(Var *var, int resdomno);
+extern List *get_actual_tlist(List *tlist);
+extern Resdom *tlist_member(Var *var, List *tlist);
+extern Resdom *tlist_resdom(List *tlist, Resdom *resnode);
+
+extern TargetEntry *MakeTLE(Resdom *resdom, Node *expr);
+extern Var *get_expr(TargetEntry *tle);
+
+extern TargetEntry *match_varid(Var *test_var, List *tlist);
+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,
+ List *flat_tlist);
+extern void AddGroupAttrToTlist(List *tlist, List *grpCl);
+
+#endif /* TLIST_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for optimizer/util
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:38 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= clauseinfo.c clauses.c indexnode.c internal.c plancat.c \
+ joininfo.c keys.c ordering.c pathnode.c relnode.c tlist.c var.c
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * clauseinfo.c--
+ * ClauseInfo node manipulation routines.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/clauseinfo.c,v 1.1.1.1 1996/07/09 06:21:38 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/relation.h"
+#include "nodes/nodeFuncs.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/clauses.h"
+#include "optimizer/clauseinfo.h"
+
+/*
+ * valid-or-clause--
+ *
+ * Returns t iff the clauseinfo node contains a 'normal' 'or' clause.
+ *
+ */
+bool
+valid_or_clause(CInfo *clauseinfo)
+{
+ if (clauseinfo != NULL &&
+ !single_node((Node*)clauseinfo->clause) &&
+ !clauseinfo->notclause &&
+ or_clause((Node*)clauseinfo->clause))
+ return(true);
+ else
+ return(false);
+}
+
+/*
+ * get-actual-clauses--
+ *
+ * Returns a list containing the clauses from 'clauseinfo-list'.
+ *
+ */
+List *
+get_actual_clauses(List *clauseinfo_list)
+{
+ List *temp = NIL;
+ List *result = NIL;
+ CInfo *clause = (CInfo *)NULL;
+
+ foreach(temp,clauseinfo_list) {
+ clause = (CInfo *)lfirst(temp);
+ result = lappend(result,clause->clause);
+ }
+ return(result);
+}
+
+/*
+ * XXX NOTE:
+ * The following routines must return their contents in the same order
+ * (e.g., the first clause's info should be first, and so on) or else
+ * get_index_sel() won't work.
+ *
+ */
+
+/*
+ * get_relattvals--
+ * For each member of a list of clauseinfo nodes to be used with an
+ * index, create a vectori-long specifying:
+ * the attnos,
+ * the values of the clause constants, and
+ * flags indicating the type and location of the constant within
+ * each clause.
+ * Each clause is of the form (op var some_type_of_constant), thus the
+ * flag indicating whether the constant is on the left or right should
+ * always be *SELEC-CONSTANT-RIGHT*.
+ *
+ * 'clauseinfo-list' is a list of clauseinfo nodes
+ *
+ * Returns a list of vectori-longs.
+ *
+ */
+void
+get_relattvals(List *clauseinfo_list,
+ List **attnos,
+ List **values,
+ List **flags)
+{
+ List *result1 = NIL;
+ List *result2 = NIL;
+ List *result3 = NIL;
+ CInfo *temp = (CInfo *)NULL;
+ List *i = NIL;
+
+ foreach (i,clauseinfo_list) {
+ int dummy;
+ AttrNumber attno;
+ Datum constval;
+ int flag;
+
+ temp = (CInfo *)lfirst(i);
+ get_relattval((Node*)temp->clause, &dummy, &attno, &constval, &flag);
+ result1 = lappendi(result1, attno);
+ result2 = lappendi(result2, constval);
+ result3 = lappendi(result3, flag);
+ }
+
+ *attnos = result1;
+ *values = result2;
+ *flags = result3;
+ return;
+}
+
+/*
+ * get_joinvars --
+ * Given a list of join clauseinfo nodes to be used with the index
+ * of an inner join relation, return three lists consisting of:
+ * the attributes corresponding to the inner join relation
+ * the value of the inner var clause (always "")
+ * whether the attribute appears on the left or right side of
+ * the operator.
+ *
+ * 'relid' is the inner join relation
+ * 'clauseinfo-list' is a list of qualification clauses to be used with
+ * 'rel'
+ *
+ */
+void
+get_joinvars(Oid relid,
+ List *clauseinfo_list,
+ List **attnos,
+ List **values,
+ List **flags)
+{
+ List *result1 = NIL;
+ List *result2 = NIL;
+ List *result3 = NIL;
+ List *temp;
+
+ foreach(temp, clauseinfo_list) {
+ CInfo *clauseinfo = lfirst(temp);
+ Expr *clause = clauseinfo->clause;
+
+ if( IsA (get_leftop(clause),Var) &&
+ (relid == (get_leftop(clause))->varno)) {
+
+ result1 = lappendi(result1, (get_leftop(clause))->varattno);
+ result2 = lappend(result2, "");
+ result3 = lappendi(result3, _SELEC_CONSTANT_RIGHT_);
+ } else {
+ result1 = lappendi(result1, (get_rightop(clause))->varattno);
+ result2 = lappend(result2, "");
+ result3 = lappendi(result3, _SELEC_CONSTANT_LEFT_);
+ }
+ }
+ *attnos = result1;
+ *values = result2;
+ *flags = result3;
+ return;
+}
+
+/*
+ * get_opnos--
+ * Create and return a list containing the clause operators of each member
+ * of a list of clauseinfo nodes to be used with an index.
+ *
+ */
+List *
+get_opnos(List *clauseinfo_list)
+{
+ CInfo *temp = (CInfo *)NULL;
+ List *result = NIL;
+ List *i = NIL;
+
+ foreach(i,clauseinfo_list) {
+ temp = (CInfo *)lfirst(i);
+ result =
+ lappendi(result,
+ (((Oper*)temp->clause->oper)->opno));
+ }
+ return(result);
+}
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * clauses.c--
+ * routines to manipulate qualification clauses
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.1.1.1 1996/07/09 06:21:38 scrappy Exp $
+ *
+ * HISTORY
+ * AUTHOR DATE MAJOR EVENT
+ * Andrew Yu Nov 3, 1994 clause.c and clauses.c combined
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/primnodes.h"
+#include "nodes/relation.h"
+#include "nodes/parsenodes.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
+
+#include "catalog/pg_aggregate.h"
+
+#include "utils/elog.h"
+#include "utils/syscache.h"
+#include "utils/lsyscache.h"
+
+#include "optimizer/clauses.h"
+#include "optimizer/internal.h"
+#include "optimizer/var.h"
+
+
+Expr *
+make_clause(int type, Node *oper, List *args)
+{
+ if (type == AND_EXPR || type == OR_EXPR || type == NOT_EXPR ||
+ type == OP_EXPR || type == FUNC_EXPR) {
+ Expr *expr = makeNode(Expr);
+
+ /*
+ * assume type checking already done and we don't need the type of
+ * the expr any more.
+ */
+ expr->typeOid = InvalidOid;
+ expr->opType = type;
+ expr->oper = oper; /* ignored for AND, OR, NOT */
+ expr->args = args;
+ return expr;
+ }else {
+ /* will this ever happen? translated from lispy C code - ay 10/94 */
+ return((Expr*)args);
+ }
+}
+
+
+/*****************************************************************************
+ * OPERATOR clause functions
+ *****************************************************************************/
+
+
+/*
+ * is_opclause--
+ *
+ * Returns t iff the clause is an operator clause:
+ * (op expr expr) or (op expr).
+ *
+ * [historical note: is_clause has the exact functionality and is used
+ * throughout the code. They're renamed to is_opclause for clarity.
+ * - ay 10/94.]
+ */
+bool
+is_opclause(Node *clause)
+{
+ return
+ (clause!=NULL &&
+ nodeTag(clause)==T_Expr && ((Expr*)clause)->opType==OP_EXPR);
+}
+
+/*
+ * make_opclause--
+ * Creates a clause given its operator left operand and right
+ * operand (if it is non-null).
+ *
+ */
+Expr *
+make_opclause(Oper *op, Var *leftop, Var *rightop)
+{
+ Expr *expr = makeNode(Expr);
+
+ expr->typeOid = InvalidOid; /* assume type checking done */
+ expr->opType = OP_EXPR;
+ expr->oper = (Node*)op;
+ expr->args = makeList(leftop, rightop, -1);
+ return expr;
+}
+
+/*
+ * get_leftop--
+ *
+ * Returns the left operand of a clause of the form (op expr expr)
+ * or (op expr)
+ * NB: it is assumed (for now) that all expr must be Var nodes
+ */
+Var *
+get_leftop(Expr *clause)
+{
+ if (clause->args!=NULL)
+ return(lfirst(clause->args));
+ else
+ return NULL;
+}
+
+/*
+ * get_rightop
+ *
+ * Returns the right operand in a clause of the form (op expr expr).
+ *
+ */
+Var *
+get_rightop(Expr *clause)
+{
+ if (clause->args!=NULL && lnext(clause->args)!=NULL)
+ return (lfirst(lnext(clause->args)));
+ else
+ return NULL;
+}
+
+/*****************************************************************************
+ * AGG clause functions
+ *****************************************************************************/
+
+bool
+agg_clause(Node *clause)
+{
+ return
+ (clause!=NULL && nodeTag(clause)==T_Aggreg);
+}
+
+/*****************************************************************************
+ * FUNC clause functions
+ *****************************************************************************/
+
+/*
+ * is_funcclause--
+ *
+ * Returns t iff the clause is a function clause: (func { expr }).
+ *
+ */
+bool
+is_funcclause(Node *clause)
+{
+ return
+ (clause!=NULL &&
+ nodeTag(clause)==T_Expr && ((Expr*)clause)->opType==FUNC_EXPR);
+}
+
+/*
+ * make_funcclause--
+ *
+ * Creates a function clause given the FUNC node and the functional
+ * arguments.
+ *
+ */
+Expr *
+make_funcclause(Func *func, List *funcargs)
+{
+ Expr *expr = makeNode(Expr);
+
+ expr->typeOid = InvalidOid; /* assume type checking done */
+ expr->opType = FUNC_EXPR;
+ expr->oper = (Node*)func;
+ expr->args = funcargs;
+ return expr;
+}
+
+/*****************************************************************************
+ * OR clause functions
+ *****************************************************************************/
+
+/*
+ * or_clause--
+ *
+ * Returns t iff the clause is an 'or' clause: (OR { expr }).
+ *
+ */
+bool
+or_clause(Node *clause)
+{
+ return
+ (clause!=NULL &&
+ nodeTag(clause)==T_Expr && ((Expr*)clause)->opType==OR_EXPR);
+}
+
+/*
+ * make_orclause--
+ *
+ * Creates an 'or' clause given a list of its subclauses.
+ *
+ */
+Expr *
+make_orclause(List *orclauses)
+{
+ Expr *expr = makeNode(Expr);
+
+ expr->typeOid = InvalidOid; /* assume type checking done */
+ expr->opType = OR_EXPR;
+ expr->oper = NULL;
+ expr->args = orclauses;
+ return expr;
+}
+
+/*****************************************************************************
+ * NOT clause functions
+ *****************************************************************************/
+
+/*
+ * not_clause--
+ *
+ * Returns t iff this is a 'not' clause: (NOT expr).
+ *
+ */
+bool
+not_clause(Node *clause)
+{
+ return
+ (clause!=NULL &&
+ nodeTag(clause)==T_Expr && ((Expr*)clause)->opType == NOT_EXPR);
+}
+
+/*
+ * make_notclause--
+ *
+ * Create a 'not' clause given the expression to be negated.
+ *
+ */
+Expr *
+make_notclause(Expr *notclause)
+{
+ Expr *expr = makeNode(Expr);
+
+ expr->typeOid = InvalidOid; /* assume type checking done */
+ expr->opType = NOT_EXPR;
+ expr->oper = NULL;
+ expr->args = lcons(notclause, NIL);
+ return expr;
+}
+
+/*
+ * get_notclausearg--
+ *
+ * Retrieve the clause within a 'not' clause
+ *
+ */
+Expr *
+get_notclausearg(Expr *notclause)
+{
+ return(lfirst(notclause->args));
+}
+
+/*****************************************************************************
+ * AND clause functions
+ *****************************************************************************/
+
+
+/*
+ * and_clause--
+ *
+ * Returns t iff its argument is an 'and' clause: (AND { expr }).
+ *
+ */
+bool
+and_clause(Node *clause)
+{
+ return
+ (clause!=NULL &&
+ nodeTag(clause)==T_Expr && ((Expr*)clause)->opType == AND_EXPR);
+}
+/*
+ * make_andclause--
+ *
+ * Create an 'and' clause given its arguments in a list.
+ *
+ */
+Expr *
+make_andclause(List *andclauses)
+{
+ Expr *expr = makeNode(Expr);
+
+ expr->typeOid = InvalidOid; /* assume type checking done */
+ expr->opType = AND_EXPR;
+ expr->oper = NULL;
+ expr->args = andclauses;
+ return expr;
+}
+
+/*****************************************************************************
+ * *
+ * *
+ * *
+ *****************************************************************************/
+
+
+/*
+ * pull-constant-clauses--
+ * Scans through a list of qualifications and find those that
+ * contain no variables.
+ *
+ * Returns a list of the constant clauses in constantQual and the remaining
+ * quals as the return value.
+ *
+ */
+List *
+pull_constant_clauses(List *quals, List **constantQual)
+{
+ List *q;
+ List *constqual=NIL;
+ List *restqual=NIL;
+
+ foreach(q, quals) {
+ if (!contain_var_clause(lfirst(q))) {
+ constqual = lcons(lfirst(q), constqual);
+ }else {
+ restqual = lcons(lfirst(q), restqual);
+ }
+ }
+ freeList(quals);
+ *constantQual = constqual;
+ return restqual;
+}
+
+/*
+ * clause-relids-vars--
+ * Retrieves relids and vars appearing within a clause.
+ * Returns ((relid1 relid2 ... relidn) (var1 var2 ... varm)) where
+ * vars appear in the clause this is done by recursively searching
+ * through the left and right operands of a clause.
+ *
+ * Returns the list of relids and vars.
+ *
+ * XXX take the nreverse's out later
+ *
+ */
+void
+clause_relids_vars(Node *clause, List **relids, List **vars)
+{
+ List *clvars = pull_var_clause(clause);
+ List *var_list = NIL;
+ List *varno_list = NIL;
+ List *i = NIL;
+
+ foreach (i, clvars) {
+ Var *var = (Var *)lfirst(i);
+
+ if (!intMember(var->varno, varno_list)) {
+ varno_list = lappendi(varno_list, var->varno);
+ var_list = lappend(var_list, var);
+ }
+ }
+
+ *relids = varno_list;
+ *vars = var_list;
+ return;
+}
+
+/*
+ * NumRelids--
+ * (formerly clause-relids)
+ *
+ * Returns the number of different relations referenced in 'clause'.
+ */
+int
+NumRelids(Node *clause)
+{
+ List *vars = pull_var_clause(clause);
+ List *i = NIL;
+ List *var_list = NIL;
+
+ foreach (i, vars) {
+ Var *var = (Var *)lfirst(i);
+
+ if (!intMember(var->varno, var_list)) {
+ var_list = lconsi(var->varno, var_list);
+ }
+ }
+
+ return(length(var_list));
+}
+
+/*
+ * contains-not--
+ *
+ * Returns t iff the clause is a 'not' clause or if any of the
+ * subclauses within an 'or' clause contain 'not's.
+ *
+ */
+bool
+contains_not(Node *clause)
+{
+ if (single_node(clause))
+ return (false);
+
+ if (not_clause(clause))
+ return (true);
+
+ if (or_clause(clause)) {
+ List *a;
+ foreach(a, ((Expr*)clause)->args) {
+ if (contains_not(lfirst(a)))
+ return (true);
+ }
+ }
+
+ return(false);
+}
+
+/*
+ * join-clause-p--
+ *
+ * Returns t iff 'clause' is a valid join clause.
+ *
+ */
+bool
+join_clause_p(Node *clause)
+{
+ Node *leftop, *rightop;
+
+ if (!is_opclause(clause))
+ return false;
+
+ leftop = (Node*)get_leftop((Expr*)clause);
+ rightop = (Node*)get_rightop((Expr*)clause);
+
+ /*
+ * One side of the clause (i.e. left or right operands)
+ * must either be a var node ...
+ */
+ if (IsA(leftop,Var) || IsA(rightop,Var))
+ return true;
+
+ /*
+ * ... or a func node.
+ */
+ if (is_funcclause(leftop) || is_funcclause(rightop))
+ return(true);
+
+ return(false);
+}
+
+/*
+ * qual-clause-p--
+ *
+ * Returns t iff 'clause' is a valid qualification clause.
+ *
+ */
+bool
+qual_clause_p(Node *clause)
+{
+ if (!is_opclause(clause))
+ return false;
+
+ if (IsA (get_leftop((Expr*)clause),Var) &&
+ IsA (get_rightop((Expr*)clause),Const))
+ {
+ return(true);
+ }
+ else if (IsA (get_rightop((Expr*)clause),Var) &&
+ IsA (get_leftop((Expr*)clause),Const))
+ {
+ return(true);
+ }
+ return(false);
+}
+
+/*
+ * fix-opid--
+ * Calculate the opfid from the opno...
+ *
+ * Returns nothing.
+ *
+ */
+void
+fix_opid(Node *clause)
+{
+ if (clause==NULL || single_node(clause)) {
+ ;
+ }
+ else if (or_clause (clause)) {
+ fix_opids(((Expr*)clause)->args);
+ }
+ else if (is_funcclause (clause)) {
+ fix_opids(((Expr*)clause)->args);
+ }
+ else if (IsA(clause,ArrayRef)) {
+ ArrayRef *aref = (ArrayRef *)clause;
+
+ fix_opids(aref->refupperindexpr);
+ fix_opids(aref->reflowerindexpr);
+ fix_opid(aref->refexpr);
+ fix_opid(aref->refassgnexpr);
+ }
+ else if (not_clause(clause)) {
+ fix_opid((Node*)get_notclausearg((Expr*)clause));
+ }
+ else if (is_opclause (clause)) {
+ replace_opid((Oper*)((Expr*)clause)->oper);
+ fix_opid((Node*)get_leftop((Expr*)clause));
+ fix_opid((Node*)get_rightop((Expr*)clause));
+ }
+
+}
+
+/*
+ * fix-opids--
+ * Calculate the opfid from the opno for all the clauses...
+ *
+ * Returns its argument.
+ *
+ */
+List *
+fix_opids(List *clauses)
+{
+ List *clause;
+
+ foreach(clause, clauses)
+ fix_opid(lfirst(clause));
+
+ return(clauses);
+}
+
+/*
+ * get_relattval--
+ * For a non-join clause, returns a list consisting of the
+ * relid,
+ * attno,
+ * value of the CONST node (if any), and a
+ * flag indicating whether the value appears on the left or right
+ * of the operator and whether the value varied.
+ *
+ * OLD OBSOLETE COMMENT FOLLOWS:
+ * If 'clause' is not of the format (op var node) or (op node var),
+ * or if the var refers to a nested attribute, then -1's are returned for
+ * everything but the value a blank string "" (pointer to \0) is
+ * returned for the value if it is unknown or null.
+ * END OF OLD OBSOLETE COMMENT.
+ * NEW COMMENT:
+ * when defining rules one of the attibutes of the operator can
+ * be a Param node (which is supposed to be treated as a constant).
+ * However as there is no value specified for a parameter until run time
+ * this routine used to return "" as value, which made 'compute_selec'
+ * to bomb (because it was expecting a lisp integer and got back a lisp
+ * string). Now the code returns a plain old good "lispInteger(0)".
+ *
+ */
+void
+get_relattval(Node *clause,
+ int *relid,
+ AttrNumber *attno,
+ Datum *constval,
+ int *flag)
+{
+ Var *left = get_leftop((Expr*)clause);
+ Var *right = get_rightop((Expr*)clause);
+
+ if(is_opclause(clause) && IsA(left,Var) &&
+ IsA(right,Const)) {
+
+ if(right!=NULL) {
+
+ *relid = left->varno;
+ *attno = left->varattno;
+ *constval = ((Const *)right)->constvalue;
+ *flag = (_SELEC_CONSTANT_RIGHT_ | _SELEC_IS_CONSTANT_);
+
+ } else {
+
+ *relid = left->varno;
+ *attno = left->varattno;
+ *constval = 0;
+ *flag = (_SELEC_CONSTANT_RIGHT_ | _SELEC_NOT_CONSTANT_);
+
+ }
+ }else if (is_opclause(clause) &&
+ is_funcclause((Node*)left) &&
+ IsA(right,Const)) {
+ List *args = ((Expr*)left)->args;
+
+
+ *relid = ((Var*)lfirst(args))->varno;
+ *attno = InvalidAttrNumber;
+ *constval = ((Const*)right)->constvalue;
+ *flag = (_SELEC_CONSTANT_RIGHT_ | _SELEC_IS_CONSTANT_);
+
+ /*
+ * XXX both of these func clause handling if's seem wrong to me.
+ * they assume that the first argument is the Var. It could
+ * not handle (for example) f(1, emp.name). I think I may have
+ * been assuming no constants in functional index scans when I
+ * implemented this originally (still currently true).
+ * -mer 10 Aug 1992
+ */
+ } else if (is_opclause(clause) &&
+ is_funcclause((Node*)right) &&
+ IsA(left,Const)) {
+ List *args = ((Expr*)right)->args;
+
+ *relid = ((Var*)lfirst(args))->varno;
+ *attno = InvalidAttrNumber;
+ *constval = ((Const*)left)->constvalue;
+ *flag = ( _SELEC_IS_CONSTANT_);
+
+ } else if (is_opclause (clause) && IsA (right,Var) &&
+ IsA (left,Const)) {
+ if (left!=NULL) {
+
+ *relid = right->varno;
+ *attno = right->varattno;
+ *constval = ((Const*)left)->constvalue;
+ *flag = (_SELEC_IS_CONSTANT_);
+ } else {
+
+ *relid = right->varno;
+ *attno = right->varattno;
+ *constval = 0;
+ *flag = (_SELEC_NOT_CONSTANT_);
+ }
+ } else {
+ /* One or more of the operands are expressions
+ * (e.g., oper clauses)
+ */
+ *relid = _SELEC_VALUE_UNKNOWN_;
+ *attno = _SELEC_VALUE_UNKNOWN_;
+ *constval = 0;
+ *flag = (_SELEC_NOT_CONSTANT_);
+ }
+}
+
+/*
+ * get_relsatts--
+ *
+ * Returns a list
+ * ( relid1 attno1 relid2 attno2 )
+ * for a joinclause.
+ *
+ * If the clause is not of the form (op var var) or if any of the vars
+ * refer to nested attributes, then -1's are returned.
+ *
+ */
+void
+get_rels_atts(Node *clause,
+ int *relid1,
+ AttrNumber *attno1,
+ int *relid2,
+ AttrNumber *attno2)
+{
+ Var *left = get_leftop((Expr*)clause);
+ Var *right = get_rightop((Expr*)clause);
+ bool var_left = (IsA(left,Var));
+ bool var_right = (IsA(right,Var));
+ bool varexpr_left = (bool)((IsA(left,Func) || IsA (left,Oper)) &&
+ contain_var_clause((Node*)left));
+ bool varexpr_right = (bool)(( IsA(right,Func) || IsA (right,Oper)) &&
+ contain_var_clause((Node*)right));
+
+ if (is_opclause(clause)) {
+ if(var_left && var_right) {
+
+ *relid1 = left->varno;
+ *attno1 = left->varoattno;
+ *relid2 = right->varno;
+ *attno2 = right->varoattno;
+ return;
+ } else if (var_left && varexpr_right ) {
+
+ *relid1 = left->varno;
+ *attno1 = left->varoattno;
+ *relid2 = _SELEC_VALUE_UNKNOWN_;
+ *attno2 = _SELEC_VALUE_UNKNOWN_;
+ return;
+ } else if (varexpr_left && var_right) {
+
+ *relid1 = _SELEC_VALUE_UNKNOWN_;
+ *attno1 = _SELEC_VALUE_UNKNOWN_;
+ *relid2 = right->varno;
+ *attno2 = right->varoattno;
+ return;
+ }
+ }
+
+ *relid1 = _SELEC_VALUE_UNKNOWN_;
+ *attno1 = _SELEC_VALUE_UNKNOWN_;
+ *relid2 = _SELEC_VALUE_UNKNOWN_;
+ *attno2 = _SELEC_VALUE_UNKNOWN_;
+ return;
+}
+
+void
+CommuteClause(Node *clause)
+{
+ Node *temp;
+ Oper *commu;
+ OperatorTupleForm commuTup;
+ HeapTuple heapTup;
+
+ if (!is_opclause(clause))
+ return;
+
+ heapTup = (HeapTuple)
+ get_operator_tuple(get_commutator(((Oper*)((Expr*)clause)->oper)->opno));
+
+ if (heapTup == (HeapTuple)NULL)
+ return;
+
+ commuTup = (OperatorTupleForm)GETSTRUCT(heapTup);
+
+ commu = makeOper(heapTup->t_oid,
+ InvalidOid,
+ commuTup->oprresult,
+ ((Oper*)((Expr*)clause)->oper)->opsize,
+ NULL);
+
+ /*
+ * reform the clause -> (operator func/var constant)
+ */
+ ((Expr*)clause)->oper = (Node*)commu;
+ temp = lfirst(((Expr*)clause)->args);
+ lfirst(((Expr*)clause)->args) = lsecond(((Expr*)clause)->args);
+ lsecond(((Expr*)clause)->args) = temp;
+}
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * indexnode.c--
+ * Routines to find all indices on a relation
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/indexnode.c,v 1.1.1.1 1996/07/09 06:21:38 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/plannodes.h"
+#include "nodes/parsenodes.h"
+#include "nodes/relation.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/plancat.h"
+#include "optimizer/pathnode.h" /* where the decls go */
+
+
+static List *find_secondary_index(Query *root, Oid relid);
+
+/*
+ * find-relation-indices--
+ * Returns a list of index nodes containing appropriate information for
+ * each (secondary) index defined on a relation.
+ *
+ */
+List *
+find_relation_indices(Query *root, Rel *rel)
+{
+ if (rel->indexed) {
+ return (find_secondary_index(root, lfirsti(rel->relids)));
+ } else {
+ return (NIL);
+ }
+}
+
+/*
+ * find-secondary-index--
+ * Creates a list of index path nodes containing information for each
+ * secondary index defined on a relation by searching through the index
+ * catalog.
+ *
+ * 'relid' is the OID of the relation for which indices are being located
+ *
+ * Returns a list of new index nodes.
+ *
+ */
+static List *
+find_secondary_index(Query *root, Oid relid)
+{
+ IdxInfoRetval indexinfo;
+ List *indexes = NIL;
+ bool first = TRUE;
+
+ while (index_info(root, first, relid,&indexinfo)) {
+ Rel *indexnode = makeNode(Rel);
+
+ indexnode->relids = lconsi(indexinfo.relid,NIL);
+ indexnode->relam = indexinfo.relam;
+ indexnode->pages = indexinfo.pages;
+ indexnode->tuples = indexinfo.tuples;
+ indexnode->indexkeys = indexinfo.indexkeys;
+ indexnode->ordering = indexinfo.orderOprs;
+ indexnode->classlist = indexinfo.classlist;
+ indexnode->indproc= indexinfo.indproc;
+ indexnode->indpred = (List*)indexinfo.indpred;
+
+ indexnode->indexed= false; /* not indexed itself */
+ indexnode->size = 0;
+ indexnode->width= 0;
+ indexnode->targetlist= NIL;
+ indexnode->pathlist= NIL;
+ indexnode->unorderedpath= NULL;
+ indexnode->cheapestpath= NULL;
+ indexnode->pruneable= true;
+ indexnode->clauseinfo= NIL;
+ indexnode->joininfo= NIL;
+ indexnode->innerjoin= NIL;
+
+ indexes = lcons(indexnode, indexes);
+ first = FALSE;
+ }
+
+ return indexes;
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * internal.c--
+ * Definitions required throughout the query optimizer.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/internal.c,v 1.1.1.1 1996/07/09 06:21:38 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+
+/*
+ * ---------- SHARED MACROS
+ *
+ * Macros common to modules for creating, accessing, and modifying
+ * query tree and query plan components.
+ * Shared with the executor.
+ *
+ */
+
+
+#include "optimizer/internal.h"
+
+#include "nodes/relation.h"
+#include "nodes/plannodes.h"
+#include "nodes/primnodes.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+#if 0
+/*****************************************************************************
+ *
+ *****************************************************************************/
+
+/* the following should probably be moved elsewhere -ay */
+
+TargetEntry *
+MakeTLE(Resdom *resdom, Node *expr)
+{
+ TargetEntry *rt = makeNode(TargetEntry);
+ rt->resdom = resdom;
+ rt->expr = expr;
+ return rt;
+}
+
+Var *
+get_expr(TargetEntry *tle)
+{
+ Assert(tle!=NULL);
+ Assert(tle->expr!=NULL);
+
+ return ((Var *)tle->expr);
+}
+
+#endif /* 0 */
+
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * joininfo.c--
+ * JoinInfo node manipulation routines
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/joininfo.c,v 1.1.1.1 1996/07/09 06:21:38 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/relation.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/var.h"
+#include "optimizer/clauses.h"
+
+
+/*
+ * joininfo-member--
+ * Determines whether a node has already been created for a join
+ * between a set of join relations and the relation described by
+ * 'joininfo-list'.
+ *
+ * 'join-relids' is a list of relids corresponding to the join relation
+ * 'joininfo-list' is the list of joininfo nodes against which this is
+ * checked
+ *
+ * Returns the corresponding node in 'joininfo-list' if such a node
+ * exists.
+ *
+ */
+JInfo *
+joininfo_member(List *join_relids, List *joininfo_list)
+{
+ List *i = NIL;
+ List *other_rels = NIL;
+
+ foreach(i,joininfo_list) {
+ other_rels = lfirst(i);
+ if(same(join_relids, ((JInfo*)other_rels)->otherrels))
+ return((JInfo*)other_rels);
+ }
+ return((JInfo*)NULL);
+}
+
+
+/*
+ * find-joininfo-node--
+ * Find the joininfo node within a relation entry corresponding
+ * to a join between 'this_rel' and the relations in 'join-relids'. A
+ * new node is created and added to the relation entry's joininfo
+ * field if the desired one can't be found.
+ *
+ * Returns a joininfo node.
+ *
+ */
+JInfo *
+find_joininfo_node(Rel *this_rel, List *join_relids)
+{
+ JInfo *joininfo = joininfo_member(join_relids,
+ this_rel->joininfo);
+ if( joininfo == NULL ) {
+ joininfo = makeNode(JInfo);
+ joininfo->otherrels = join_relids;
+ joininfo->jinfoclauseinfo = NIL;
+ joininfo->mergesortable = false;
+ joininfo->hashjoinable = false;
+ joininfo->inactive = false;
+ this_rel->joininfo = lcons(joininfo, this_rel->joininfo);
+ }
+ return(joininfo);
+}
+
+/*
+ * other-join-clause-var--
+ * Determines whether a var node is contained within a joinclause
+ * of the form(op var var).
+ *
+ * Returns the other var node in the joinclause if it is, nil if not.
+ *
+ */
+Var *
+other_join_clause_var(Var *var, Expr *clause)
+{
+ Var *retval;
+ Var *l, *r;
+
+ retval = (Var*) NULL;
+
+ if( var != NULL && join_clause_p((Node*)clause)) {
+ l = (Var *) get_leftop(clause);
+ r = (Var *) get_rightop(clause);
+
+ if(var_equal(var, l)) {
+ retval = r;
+ } else if(var_equal(var, r)) {
+ retval = l;
+ }
+ }
+
+ return(retval);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * keys.c--
+ * Key manipulation routines
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/keys.c,v 1.1.1.1 1996/07/09 06:21:38 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+#include "nodes/pg_list.h"
+#include "nodes/nodes.h"
+#include "nodes/relation.h"
+#include "utils/elog.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/keys.h"
+#include "optimizer/tlist.h"
+
+
+static Expr *matching2_tlvar(int var, List *tlist, bool (*test)());
+
+/*
+ * 1. index key
+ * one of:
+ * attnum
+ * (attnum arrayindex)
+ * 2. path key
+ * (subkey1 ... subkeyN)
+ * where subkeyI is a var node
+ * note that the 'Keys field is a list of these
+ * 3. join key
+ * (outer-subkey inner-subkey)
+ * where each subkey is a var node
+ * 4. sort key
+ * one of:
+ * SortKey node
+ * number
+ * nil
+ * (may also refer to the 'SortKey field of a SortKey node,
+ * which looks exactly like an index key)
+ *
+ */
+
+/*
+ * match-indexkey-operand--
+ * Returns t iff an index key 'index-key' matches the given clause
+ * operand.
+ *
+ */
+bool
+match_indexkey_operand(int indexkey, Var *operand, Rel *rel)
+{
+ if (IsA (operand,Var) &&
+ (lfirsti(rel->relids) == operand->varno) &&
+ equal_indexkey_var(indexkey,operand))
+ return(true);
+ else
+ return(false);
+}
+
+/*
+ * equal_indexkey_var--
+ * Returns t iff an index key 'index-key' matches the corresponding
+ * fields of var node 'var'.
+ *
+ */
+bool
+equal_indexkey_var(int index_key, Var *var)
+{
+ if (index_key == var->varattno)
+ return(true);
+ else
+ return(false);
+}
+
+/*
+ * extract-subkey--
+ * Returns the subkey in a join key corresponding to the outer or inner
+ * lelation.
+ *
+ */
+Var *
+extract_subkey(JoinKey *jk, int which_subkey)
+{
+ Var *retval;
+
+ switch (which_subkey) {
+ case OUTER:
+ retval = jk->outer;
+ break;
+ case INNER:
+ retval = jk->inner;
+ break;
+ default: /* do nothing */
+ elog(DEBUG,"extract_subkey with neither INNER or OUTER");
+ retval = NULL;
+ }
+ return(retval);
+}
+
+/*
+ * samekeys--
+ * Returns t iff two sets of path keys are equivalent. They are
+ * equivalent if the first subkey (var node) within each sublist of
+ * list 'keys1' is contained within the corresponding sublist of 'keys2'.
+ *
+ * XXX It isn't necessary to check that each sublist exactly contain
+ * the same elements because if the routine that built these
+ * sublists together is correct, having one element in common
+ * implies having all elements in common.
+ *
+ */
+bool
+samekeys(List *keys1, List *keys2)
+{
+ bool allmember = true;
+ List *key1, *key2;
+
+ for(key1=keys1,key2=keys2 ; key1 != NIL && key2 !=NIL ;
+ key1=lnext(key1), key2=lnext(key2))
+ if (!member(lfirst(key1), lfirst(key2)))
+ allmember = false;
+
+ if ( (length (keys2) >= length (keys1)) && allmember)
+ return(true);
+ else
+ return(false);
+}
+
+/*
+ * collect-index-pathkeys--
+ * Creates a list of subkeys by retrieving var nodes corresponding to
+ * each index key in 'index-keys' from the relation's target list
+ * 'tlist'. If the key is not in the target list, the key is irrelevant
+ * and is thrown away. The returned subkey list is of the form:
+ * ((var1) (var2) ... (varn))
+ *
+ * 'index-keys' is a list of index keys
+ * 'tlist' is a relation target list
+ *
+ * Returns the list of cons'd subkeys.
+ *
+ */
+/* This function is identical to matching_tlvar and tlistentry_member.
+ * They should be merged.
+ */
+static Expr *
+matching2_tlvar(int var, List *tlist, bool (*test)())
+{
+ TargetEntry *tlentry = NULL;
+
+ if (var) {
+ List *temp;
+ foreach (temp,tlist) {
+ if ((*test)(var, get_expr(lfirst(temp)))) {
+ tlentry = lfirst(temp);
+ break;
+ }
+ }
+ }
+
+ if (tlentry)
+ return((Expr*)get_expr(tlentry));
+ else
+ return((Expr*)NULL);
+}
+
+
+List *
+collect_index_pathkeys(int *index_keys, List *tlist)
+{
+ List *retval = NIL;
+
+ Assert (index_keys != NULL);
+
+ while(index_keys[0] != 0) {
+ Expr *mvar;
+ mvar = matching2_tlvar(index_keys[0],
+ tlist,
+ equal_indexkey_var);
+ if (mvar)
+ retval = nconc(retval,lcons(lcons(mvar,NIL),
+ NIL));
+ index_keys++;
+ }
+ return(retval);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * ordering.c--
+ * Routines to manipulate and compare merge and path orderings
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/ordering.c,v 1.1.1.1 1996/07/09 06:21:38 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "optimizer/internal.h"
+#include "optimizer/ordering.h"
+
+
+/*
+ * equal-path-path-ordering--
+ * Returns t iff two path orderings are equal.
+ *
+ */
+bool
+equal_path_path_ordering(PathOrder *path_ordering1,
+ PathOrder *path_ordering2)
+{
+ if (path_ordering1 == path_ordering2)
+ return true;
+
+ if (!path_ordering1 || !path_ordering2)
+ return false;
+
+ if (path_ordering1->ordtype == MERGE_ORDER &&
+ path_ordering2->ordtype == MERGE_ORDER) {
+
+ return equal(path_ordering1->ord.merge, path_ordering2->ord.merge);
+
+ } else if (path_ordering1->ordtype == SORTOP_ORDER &&
+ path_ordering2->ordtype == SORTOP_ORDER) {
+
+ return
+ (equal_sortops_order(path_ordering1->ord.sortop,
+ path_ordering2->ord.sortop));
+ } else if (path_ordering1->ordtype == MERGE_ORDER &&
+ path_ordering2->ordtype == SORTOP_ORDER) {
+
+ return (path_ordering2->ord.sortop &&
+ (path_ordering1->ord.merge->left_operator ==
+ path_ordering2->ord.sortop[0]));
+ } else {
+
+ return (path_ordering1->ord.sortop &&
+ (path_ordering1->ord.sortop[0] ==
+ path_ordering2->ord.merge->left_operator));
+ }
+}
+
+/*
+ * equal-path-merge-ordering--
+ * Returns t iff a path ordering is usable for ordering a merge join.
+ *
+ * XXX Presently, this means that the first sortop of the path matches
+ * either of the merge sortops. Is there a "right" and "wrong"
+ * sortop to match?
+ *
+ */
+bool
+equal_path_merge_ordering(Oid *path_ordering,
+ MergeOrder *merge_ordering)
+{
+ if (path_ordering == NULL || merge_ordering == NULL)
+ return(false);
+
+ if (path_ordering[0] == merge_ordering->left_operator ||
+ path_ordering[0] == merge_ordering->right_operator)
+ return(true);
+ else
+ return(false);
+}
+
+/*
+ * equal-merge-merge-ordering--
+ * Returns t iff two merge orderings are equal.
+ *
+ */
+bool
+equal_merge_merge_ordering(MergeOrder *merge_ordering1,
+ MergeOrder *merge_ordering2)
+{
+ return (equal(merge_ordering1, merge_ordering2));
+}
+
+/*****************************************************************************
+ *
+ *****************************************************************************/
+
+/*
+ * equal_sort_ops_order -
+ * Returns true iff the sort operators are in the same order.
+ */
+bool
+equal_sortops_order(Oid *ordering1, Oid *ordering2)
+{
+ int i = 0;
+
+ if (ordering1 == NULL || ordering2 == NULL)
+ return (ordering1==ordering2);
+
+ while (ordering1[i]!=0 && ordering2[i]!=0) {
+ if (ordering1[i] != ordering2[i])
+ break;
+ i++;
+ }
+
+ return (ordering1[i]==0 && ordering2[i]==0);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * pathnode.c--
+ * Routines to manipulate pathlists and create path nodes
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.1.1.1 1996/07/09 06:21:38 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+
+#include "postgres.h"
+
+#include "nodes/relation.h"
+#include "utils/elog.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/clauseinfo.h"
+#include "optimizer/plancat.h"
+#include "optimizer/cost.h"
+#include "optimizer/keys.h"
+#include "optimizer/xfunc.h"
+#include "optimizer/ordering.h"
+
+#include "parser/parsetree.h" /* for getrelid() */
+
+static Path *better_path(Path *new_path, List *unique_paths, bool *noOther);
+
+
+/*****************************************************************************
+ * MISC. PATH UTILITIES
+ *****************************************************************************/
+
+/*
+ * path-is-cheaper--
+ * Returns t iff 'path1' is cheaper than 'path2'.
+ *
+ */
+bool
+path_is_cheaper(Path *path1, Path *path2)
+{
+ Cost cost1 = path1->path_cost;
+ Cost cost2 = path2->path_cost;
+
+ return((bool)(cost1 < cost2));
+}
+
+/*
+ * set_cheapest--
+ * Finds the minimum cost path from among a relation's paths.
+ *
+ * 'parent-rel' is the parent relation
+ * 'pathlist' is a list of path nodes corresponding to 'parent-rel'
+ *
+ * Returns and sets the relation entry field with the pathnode that
+ * is minimum.
+ *
+ */
+Path *
+set_cheapest(Rel *parent_rel, List *pathlist)
+{
+ List *p;
+ Path *cheapest_so_far;
+
+ Assert(pathlist!=NIL);
+ Assert(IsA(parent_rel,Rel));
+
+ cheapest_so_far = (Path*)lfirst(pathlist);
+
+ foreach (p, lnext(pathlist)) {
+ Path *path = (Path*)lfirst(p);
+
+ if (path_is_cheaper(path, cheapest_so_far)) {
+ cheapest_so_far = path;
+ }
+ }
+
+ parent_rel->cheapestpath = cheapest_so_far;
+
+ return(cheapest_so_far);
+}
+
+/*
+ * add_pathlist--
+ * For each path in the list 'new-paths', add to the list 'unique-paths'
+ * only those paths that are unique (i.e., unique ordering and ordering
+ * keys). Should a conflict arise, the more expensive path is thrown out,
+ * thereby pruning the plan space. But we don't prune if xfunc
+ * told us not to.
+ *
+ * 'parent-rel' is the relation entry to which these paths correspond.
+ *
+ * Returns the list of unique pathnodes.
+ *
+ */
+List *
+add_pathlist(Rel *parent_rel, List *unique_paths, List *new_paths)
+{
+ List *x;
+ Path *new_path;
+ Path *old_path;
+ bool noOther;
+
+ foreach (x, new_paths) {
+ new_path = (Path*)lfirst(x);
+ if (member(new_path, unique_paths))
+ continue;
+ old_path = better_path(new_path,unique_paths,&noOther);
+
+ if (noOther) {
+ /* Is a brand new path. */
+ new_path->parent = parent_rel;
+ unique_paths = lcons(new_path, unique_paths);
+ } else if (old_path==NULL) {
+ ; /* do nothing if path is not cheaper */
+ } else if (old_path != NULL) { /* (IsA(old_path,Path)) { */
+ new_path->parent = parent_rel;
+ if (!parent_rel->pruneable) {
+ unique_paths = lcons(new_path, unique_paths);
+ }else
+ unique_paths = lcons(new_path,
+ LispRemove(old_path,unique_paths));
+ }
+ }
+ return(unique_paths);
+}
+
+/*
+ * better_path--
+ * Determines whether 'new-path' has the same ordering and keys as some
+ * path in the list 'unique-paths'. If there is a redundant path,
+ * eliminate the more expensive path.
+ *
+ * Returns:
+ * The old path - if 'new-path' matches some path in 'unique-paths' and is
+ * cheaper
+ * nil - if 'new-path' matches but isn't cheaper
+ * t - if there is no path in the list with the same ordering and keys
+ *
+ */
+static Path *
+better_path(Path *new_path, List *unique_paths, bool *noOther)
+{
+ Path *old_path = (Path*)NULL;
+ Path *path = (Path*)NULL;
+ List *temp = NIL;
+ Path *retval = NULL;
+
+ /* XXX - added the following two lines which weren't int
+ * the lisp planner, but otherwise, doesn't seem to work
+ * for the case where new_path is 'nil
+ */
+ foreach (temp,unique_paths) {
+ path = (Path*) lfirst(temp);
+
+ if ((equal_path_path_ordering(&new_path->p_ordering,
+ &path->p_ordering) &&
+ samekeys(new_path->keys, path->keys))) {
+ old_path = path;
+ break;
+ }
+ }
+
+ if (old_path==NULL) {
+ *noOther = true;
+ } else {
+ *noOther = false;
+ if (path_is_cheaper(new_path,old_path)) {
+ retval = old_path;
+ }
+ }
+
+ return(retval);
+}
+
+
+
+/*****************************************************************************
+ * PATH NODE CREATION ROUTINES
+ *****************************************************************************/
+
+/*
+ * create_seqscan_path--
+ * Creates a path corresponding to a sequential scan, returning the
+ * pathnode.
+ *
+ */
+Path *
+create_seqscan_path(Rel *rel)
+{
+ int relid=0;
+
+ Path *pathnode = makeNode(Path);
+
+ pathnode->pathtype = T_SeqScan;
+ pathnode->parent = rel;
+ pathnode->path_cost = 0.0;
+ pathnode->p_ordering.ordtype = SORTOP_ORDER;
+ pathnode->p_ordering.ord.sortop = NULL;
+ pathnode->keys = NIL;
+ /* copy clauseinfo list into path for expensive function processing
+ * -- JMH, 7/7/92
+ */
+ pathnode->locclauseinfo=
+ (List*)copyObject((Node*)rel->clauseinfo);
+
+ if (rel->relids !=NULL)
+ relid = lfirsti(rel->relids);
+
+ pathnode->path_cost = cost_seqscan (relid,
+ rel->pages, rel->tuples);
+ /* add in expensive functions cost! -- JMH, 7/7/92 */
+#if 0
+ if (XfuncMode != XFUNC_OFF) {
+ pathnode->path_cost +=
+ xfunc_get_path_cost(pathnode));
+ }
+#endif
+ return (pathnode);
+}
+
+/*
+ * create_index_path--
+ * Creates a single path node for an index scan.
+ *
+ * 'rel' is the parent rel
+ * 'index' is the pathnode for the index on 'rel'
+ * 'restriction-clauses' is a list of restriction clause nodes.
+ * 'is-join-scan' is a flag indicating whether or not the index is being
+ * considered because of its sort order.
+ *
+ * Returns the new path node.
+ *
+ */
+IndexPath *
+create_index_path(Query *root,
+ Rel *rel,
+ Rel *index,
+ List *restriction_clauses,
+ bool is_join_scan)
+{
+ IndexPath *pathnode = makeNode(IndexPath);
+
+ pathnode->path.pathtype = T_IndexScan;
+ pathnode->path.parent = rel;
+ pathnode->indexid = index->relids;
+
+ pathnode->path.p_ordering.ordtype = SORTOP_ORDER;
+ pathnode->path.p_ordering.ord.sortop = index->ordering;
+ pathnode->indexqual = NIL;
+
+ /* copy clauseinfo list into path for expensive function processing
+ * -- JMH, 7/7/92
+ */
+ pathnode->path.locclauseinfo =
+ set_difference((List*) copyObject((Node*)rel->clauseinfo),
+ (List*) restriction_clauses);
+
+ /*
+ * The index must have an ordering for the path to have (ordering) keys,
+ * and vice versa.
+ */
+ if (pathnode->path.p_ordering.ord.sortop) {
+ pathnode->path.keys = collect_index_pathkeys(index->indexkeys,
+ rel->targetlist);
+ /*
+ * Check that the keys haven't 'disappeared', since they may
+ * no longer be in the target list (i.e., index keys that are not
+ * relevant to the scan are not applied to the scan path node,
+ * so if no index keys were found, we can't order the path).
+ */
+ if (pathnode->path.keys==NULL) {
+ pathnode->path.p_ordering.ord.sortop = NULL;
+ }
+ } else {
+ pathnode->path.keys = NULL;
+ }
+
+ if (is_join_scan || restriction_clauses==NULL) {
+ /*
+ * Indices used for joins or sorting result nodes don't
+ * restrict the result at all, they simply order it,
+ * so compute the scan cost
+ * accordingly -- use a selectivity of 1.0.
+ */
+/* is the statement above really true? what about IndexScan as the
+ inner of a join? */
+ pathnode->path.path_cost =
+ cost_index (lfirsti(index->relids),
+ index->pages,
+ 1.0,
+ rel->pages,
+ rel->tuples,
+ index->pages,
+ index->tuples,
+ false);
+ /* add in expensive functions cost! -- JMH, 7/7/92 */
+#if 0
+ if (XfuncMode != XFUNC_OFF) {
+ pathnode->path_cost =
+ (pathnode->path_cost +
+ xfunc_get_path_cost((Path*)pathnode));
+ }
+#endif
+ } else {
+ /*
+ * Compute scan cost for the case when 'index' is used with a
+ * restriction clause.
+ */
+ List *attnos;
+ List *values;
+ List *flags;
+ float npages;
+ float selec;
+ Cost clausesel;
+
+ get_relattvals(restriction_clauses,
+ &attnos,
+ &values,
+ &flags);
+ index_selectivity(lfirsti(index->relids),
+ index->classlist,
+ get_opnos(restriction_clauses),
+ getrelid(lfirsti(rel->relids),
+ root->rtable),
+ attnos,
+ values,
+ flags,
+ length(restriction_clauses),
+ &npages,
+ &selec);
+ /* each clause gets an equal selectivity */
+ clausesel =
+ pow(selec,
+ 1.0 / (double) length(restriction_clauses));
+
+ pathnode->indexqual = restriction_clauses;
+ pathnode->path.path_cost =
+ cost_index (lfirsti(index->relids),
+ (int)npages,
+ selec,
+ rel->pages,
+ rel->tuples,
+ index->pages,
+ index->tuples,
+ false);
+
+#if 0
+ /* add in expensive functions cost! -- JMH, 7/7/92 */
+ if (XfuncMode != XFUNC_OFF) {
+ pathnode->path_cost +=
+ xfunc_get_path_cost((Path*)pathnode);
+ }
+#endif
+ /* Set selectivities of clauses used with index to the selectivity
+ * of this index, subdividing the selectivity equally over each of
+ * the clauses.
+ */
+
+ /* XXX Can this divide the selectivities in a better way? */
+ set_clause_selectivities(restriction_clauses, clausesel);
+ }
+ return(pathnode);
+}
+
+/*
+ * create_nestloop_path--
+ * Creates a pathnode corresponding to a nestloop join between two
+ * relations.
+ *
+ * 'joinrel' is the join relation.
+ * 'outer_rel' is the outer join relation
+ * 'outer_path' is the outer join path.
+ * 'inner_path' is the inner join path.
+ * 'keys' are the keys of the path
+ *
+ * Returns the resulting path node.
+ *
+ */
+JoinPath *
+create_nestloop_path(Rel *joinrel,
+ Rel *outer_rel,
+ Path *outer_path,
+ Path *inner_path,
+ List *keys)
+{
+ JoinPath *pathnode = makeNode(JoinPath);
+
+ pathnode->path.pathtype = T_NestLoop;
+ pathnode->path.parent = joinrel;
+ pathnode->outerjoinpath = outer_path;
+ pathnode->innerjoinpath = inner_path;
+ pathnode->pathclauseinfo = joinrel->clauseinfo;
+ pathnode->path.keys = keys;
+ pathnode->path.joinid = NIL;
+ pathnode->path.outerjoincost = (Cost)0.0;
+ pathnode->path.locclauseinfo = NIL;
+
+ if (keys) {
+ pathnode->path.p_ordering.ordtype =
+ outer_path->p_ordering.ordtype;
+ if (outer_path->p_ordering.ordtype == SORTOP_ORDER) {
+ pathnode->path.p_ordering.ord.sortop =
+ outer_path->p_ordering.ord.sortop;
+ } else {
+ pathnode->path.p_ordering.ord.merge =
+ outer_path->p_ordering.ord.merge;
+ }
+ } else {
+ pathnode->path.p_ordering.ordtype = SORTOP_ORDER;
+ pathnode->path.p_ordering.ord.sortop = NULL;
+ }
+
+ pathnode->path.path_cost =
+ cost_nestloop(outer_path->path_cost,
+ inner_path->path_cost,
+ outer_rel->size,
+ inner_path->parent->size,
+ page_size(outer_rel->size,
+ outer_rel->width),
+ IsA(inner_path,IndexPath));
+ /* add in expensive function costs -- JMH 7/7/92 */
+#if 0
+ if (XfuncMode != XFUNC_OFF) {
+ pathnode->path_cost += xfunc_get_path_cost((Path*)pathnode);
+ }
+#endif
+ return(pathnode);
+}
+
+/*
+ * create_mergesort_path--
+ * Creates a pathnode corresponding to a mergesort join between
+ * two relations
+ *
+ * 'joinrel' is the join relation
+ * 'outersize' is the number of tuples in the outer relation
+ * 'innersize' is the number of tuples in the inner relation
+ * 'outerwidth' is the number of bytes per tuple in the outer relation
+ * 'innerwidth' is the number of bytes per tuple in the inner relation
+ * 'outer_path' is the outer path
+ * 'inner_path' is the inner path
+ * 'keys' are the new keys of the join relation
+ * 'order' is the sort order required for the merge
+ * 'mergeclauses' are the applicable join/restriction clauses
+ * 'outersortkeys' are the sort varkeys for the outer relation
+ * 'innersortkeys' are the sort varkeys for the inner relation
+ *
+ */
+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)
+{
+ MergePath *pathnode = makeNode(MergePath);
+
+ pathnode->jpath.path.pathtype = T_MergeJoin;
+ pathnode->jpath.path.parent = joinrel;
+ pathnode->jpath.outerjoinpath = outer_path;
+ pathnode->jpath.innerjoinpath = inner_path;
+ pathnode->jpath.pathclauseinfo = joinrel->clauseinfo;
+ pathnode->jpath.path.keys = keys;
+ pathnode->jpath.path.p_ordering.ordtype = MERGE_ORDER;
+ pathnode->jpath.path.p_ordering.ord.merge = order;
+ pathnode->path_mergeclauses = mergeclauses;
+ pathnode->jpath.path.locclauseinfo = NIL;
+ pathnode->outersortkeys = outersortkeys;
+ pathnode->innersortkeys = innersortkeys;
+ pathnode->jpath.path.path_cost =
+ cost_mergesort(outer_path->path_cost,
+ inner_path->path_cost,
+ outersortkeys,
+ innersortkeys,
+ outersize,
+ innersize,
+ outerwidth,
+ innerwidth);
+ /* add in expensive function costs -- JMH 7/7/92 */
+#if 0
+ if (XfuncMode != XFUNC_OFF) {
+ pathnode->path_cost +=
+ xfunc_get_path_cost((Path*)pathnode);
+ }
+#endif
+ return(pathnode);
+}
+
+/*
+ * create_hashjoin_path-- XXX HASH
+ * Creates a pathnode corresponding to a hash join between two relations.
+ *
+ * 'joinrel' is the join relation
+ * 'outersize' is the number of tuples in the outer relation
+ * 'innersize' is the number of tuples in the inner relation
+ * 'outerwidth' is the number of bytes per tuple in the outer relation
+ * 'innerwidth' is the number of bytes per tuple in the inner relation
+ * 'outer_path' is the outer path
+ * 'inner_path' is the inner path
+ * 'keys' are the new keys of the join relation
+ * 'operator' is the hashjoin operator
+ * 'hashclauses' are the applicable join/restriction clauses
+ * 'outerkeys' are the sort varkeys for the outer relation
+ * 'innerkeys' are the sort varkeys for the inner relation
+ *
+ */
+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)
+{
+ HashPath *pathnode = makeNode(HashPath);
+
+ pathnode->jpath.path.pathtype = T_HashJoin;
+ pathnode->jpath.path.parent = joinrel;
+ pathnode->jpath.outerjoinpath = outer_path;
+ pathnode->jpath.innerjoinpath = inner_path;
+ pathnode->jpath.pathclauseinfo = joinrel->clauseinfo;
+ pathnode->jpath.path.locclauseinfo = NIL;
+ pathnode->jpath.path.keys = keys;
+ pathnode->jpath.path.p_ordering.ordtype = SORTOP_ORDER;
+ pathnode->jpath.path.p_ordering.ord.sortop = NULL;
+ pathnode->jpath.path.outerjoincost = (Cost)0.0;
+ pathnode->jpath.path.joinid = (Relid)NULL;
+ /* pathnode->hashjoinoperator = operator; */
+ pathnode->path_hashclauses = hashclauses;
+ pathnode->outerhashkeys = outerkeys;
+ pathnode->innerhashkeys = innerkeys;
+ pathnode->jpath.path.path_cost =
+ cost_hashjoin(outer_path->path_cost,
+ inner_path->path_cost,
+ outerkeys,
+ innerkeys,
+ outersize,innersize,
+ outerwidth,innerwidth);
+ /* add in expensive function costs -- JMH 7/7/92 */
+#if 0
+ if (XfuncMode != XFUNC_OFF) {
+ pathnode->path_cost +=
+ xfunc_get_path_cost((Path*)pathnode);
+ }
+#endif
+ return(pathnode);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * plancat.c--
+ * routines for accessing the system catalogs
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.1.1.1 1996/07/09 06:21:39 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "access/genam.h"
+#include "access/htup.h"
+#include "access/itup.h"
+
+#include "catalog/catname.h"
+#include "catalog/pg_amop.h"
+#include "catalog/pg_index.h"
+#include "catalog/pg_inherits.h"
+#include "catalog/pg_version.h"
+
+#include "nodes/pg_list.h"
+#include "parser/parsetree.h" /* for getrelid() */
+#include "fmgr.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/plancat.h"
+
+#include "utils/tqual.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/syscache.h"
+
+
+static void IndexSelectivity(Oid indexrelid, Oid indrelid, int32 nIndexKeys,
+ Oid AccessMethodOperatorClasses[], Oid operatorObjectIds[],
+ int32 varAttributeNumbers[], char *constValues[], int32 constFlags[],
+ float *idxPages, float *idxSelec);
+
+
+/*
+ * relation-info -
+ * Retrieves catalog information for a given relation. Given the oid of
+ * the relation, return the following information:
+ * whether the relation has secondary indices
+ * number of pages
+ * number of tuples
+ */
+void
+relation_info(Query *root, Index relid,
+ bool *hasindex, int *pages, int *tuples)
+{
+ HeapTuple relationTuple;
+ Form_pg_class relation;
+ Oid relationObjectId;
+
+ relationObjectId = getrelid(relid, root->rtable);
+ relationTuple = SearchSysCacheTuple(RELOID,
+ ObjectIdGetDatum(relationObjectId),
+ 0,0,0);
+ if (HeapTupleIsValid(relationTuple)) {
+ relation = (Form_pg_class)GETSTRUCT(relationTuple);
+
+ *hasindex = (relation->relhasindex) ? TRUE : FALSE;
+ *pages = relation->relpages;
+ *tuples = relation->reltuples;
+ } else {
+ elog(WARN, "RelationCatalogInformation: Relation %d not found",
+ relationObjectId);
+ }
+
+ return;
+}
+
+
+/*
+ * index-info--
+ * Retrieves catalog information on an index on a given relation.
+ *
+ * The index relation is opened on the first invocation. The current
+ * retrieves the next index relation within the catalog that has not
+ * already been retrieved by a previous call. The index catalog
+ * is closed when no more indices for 'relid' can be found.
+ *
+ * 'first' is 1 if this is the first call
+ *
+ * Returns true if successful and false otherwise. Index info is returned
+ * via the transient data structure 'info'.
+ *
+ */
+bool
+index_info(Query *root, bool first, int relid, IdxInfoRetval *info)
+{
+ register i;
+ HeapTuple indexTuple, amopTuple;
+ IndexTupleForm index;
+ Relation indexRelation;
+ uint16 amstrategy;
+ Oid relam;
+ Oid indrelid;
+
+ static Relation relation = (Relation) NULL;
+ static HeapScanDesc scan = (HeapScanDesc) NULL;
+ static ScanKeyData indexKey;
+
+
+ /* find the oid of the indexed relation */
+ indrelid = getrelid(relid, root->rtable);
+
+ memset(info, 0, sizeof(IdxInfoRetval));
+
+ /*
+ * the maximum number of elements in each of the following arrays is
+ * 8. We allocate one more for a terminating 0 to indicate the end
+ * of the array.
+ */
+ info->indexkeys = (int *)palloc(sizeof(int)*9);
+ memset(info->indexkeys, 0, sizeof(int)*9);
+ info->orderOprs = (Oid *)palloc(sizeof(Oid)*9);
+ memset(info->orderOprs, 0, sizeof(Oid)*9);
+ info->classlist = (Oid *)palloc(sizeof(Oid)*9);
+ memset(info->classlist, 0, sizeof(Oid)*9);
+
+ /* Find an index on the given relation */
+ if (first) {
+ if (RelationIsValid(relation))
+ heap_close(relation);
+ if (HeapScanIsValid(scan))
+ heap_endscan(scan);
+
+ ScanKeyEntryInitialize(&indexKey, 0,
+ Anum_pg_index_indrelid,
+ F_OIDEQ,
+ ObjectIdGetDatum(indrelid));
+
+ relation = heap_openr(IndexRelationName);
+ scan = heap_beginscan(relation, 0, NowTimeQual,
+ 1, &indexKey);
+ }
+ if (!HeapScanIsValid(scan))
+ elog(WARN, "index_info: scan not started");
+ indexTuple = heap_getnext(scan, 0, (Buffer *) NULL);
+ if (!HeapTupleIsValid(indexTuple)) {
+ heap_endscan(scan);
+ heap_close(relation);
+ scan = (HeapScanDesc) NULL;
+ relation = (Relation) NULL;
+ return(0);
+ }
+
+ /* Extract info from the index tuple */
+ index = (IndexTupleForm)GETSTRUCT(indexTuple);
+ info->relid = index->indexrelid; /* index relation */
+ for (i = 0; i < 8; i++)
+ info->indexkeys[i] = index->indkey[i];
+ for (i = 0; i < 8; i++)
+ info->classlist[i] = index->indclass[i];
+
+ info->indproc = index->indproc; /* functional index ?? */
+
+ /* partial index ?? */
+ if (VARSIZE(&index->indpred) != 0) {
+ /*
+ * The memory allocated here for the predicate (in lispReadString)
+ * only needs to stay around until it's used in find_index_paths,
+ * which is all within a command, so the automatic pfree at end
+ * of transaction should be ok.
+ */
+ char *predString;
+
+ predString = fmgr(F_TEXTOUT, &index->indpred);
+ info->indpred = (Node*)stringToNode(predString);
+ pfree(predString);
+ }
+
+ /* Extract info from the relation descriptor for the index */
+ indexRelation = index_open(index->indexrelid);
+#ifdef notdef
+ /* XXX should iterate through strategies -- but how? use #1 for now */
+ amstrategy = indexRelation->rd_am->amstrategies;
+#endif /* notdef */
+ amstrategy = 1;
+ relam = indexRelation->rd_rel->relam;
+ info->relam = relam;
+ info->pages = indexRelation->rd_rel->relpages;
+ info->tuples = indexRelation->rd_rel->reltuples;
+ heap_close(indexRelation);
+
+ /*
+ * Find the index ordering keys
+ *
+ * Must use indclass to know when to stop looking since with
+ * functional indices there could be several keys (args) for
+ * one opclass. -mer 27 Sept 1991
+ */
+ for (i = 0; i < 8 && index->indclass[i]; ++i) {
+ amopTuple = SearchSysCacheTuple(AMOPSTRATEGY,
+ ObjectIdGetDatum(relam),
+ ObjectIdGetDatum(index->indclass[i]),
+ UInt16GetDatum(amstrategy),
+ 0);
+ if (!HeapTupleIsValid(amopTuple))
+ elog(WARN, "index_info: no amop %d %d %d",
+ relam, index->indclass[i], amstrategy);
+ info->orderOprs[i] =
+ ((Form_pg_amop)GETSTRUCT(amopTuple))->amopopr;
+ }
+ return(TRUE);
+}
+
+/*
+ * index-selectivity--
+ *
+ * Call util/plancat.c:IndexSelectivity with the indicated arguments.
+ *
+ * 'indid' is the index OID
+ * 'classes' is a list of index key classes
+ * 'opnos' is a list of index key operator OIDs
+ * 'relid' is the OID of the relation indexed
+ * 'attnos' is a list of the relation attnos which the index keys over
+ * 'values' is a list of the values of the clause's constants
+ * 'flags' is a list of fixnums which describe the constants
+ * 'nkeys' is the number of index keys
+ *
+ * Returns two floats: index pages and index selectivity in 'idxPages' and
+ * 'idxSelec'.
+ *
+ */
+void
+index_selectivity(Oid indid,
+ Oid *classes,
+ List *opnos,
+ Oid relid,
+ List *attnos,
+ List *values,
+ List *flags,
+ int32 nkeys,
+ float *idxPages,
+ float *idxSelec)
+{
+ Oid *opno_array;
+ int *attno_array, *flag_array;
+ char **value_array;
+ int i = 0;
+ List *xopno, *xattno, *value, *flag;
+
+ if (length(opnos)!=nkeys || length(attnos)!=nkeys ||
+ length(values)!=nkeys || length(flags)!=nkeys) {
+
+ *idxPages = 0.0;
+ *idxSelec = 1.0;
+ return;
+ }
+
+ opno_array = (Oid *)palloc(nkeys*sizeof(Oid));
+ attno_array = (int *)palloc(nkeys*sizeof(int32));
+ value_array = (char **)palloc(nkeys*sizeof(char *));
+ flag_array = (int *)palloc(nkeys*sizeof(int32));
+
+ i = 0;
+ foreach(xopno, opnos) {
+ opno_array[i++] = (int)lfirst(xopno);
+ }
+
+ i = 0;
+ foreach(xattno,attnos) {
+ attno_array[i++] = (int)lfirst(xattno);
+ }
+
+ i = 0;
+ foreach(value, values) {
+ value_array[i++] = (char *)lfirst(value);
+ }
+
+ i = 0;
+ foreach(flag,flags) {
+ flag_array[i++] = (int)lfirst(flag);
+ }
+
+ IndexSelectivity(indid,
+ relid,
+ nkeys,
+ classes, /* not used */
+ opno_array,
+ attno_array,
+ value_array,
+ flag_array,
+ idxPages,
+ idxSelec);
+ return;
+}
+
+/*
+ * restriction_selectivity in lisp system.--
+ *
+ * NOTE: The routine is now merged with RestrictionClauseSelectivity
+ * as defined in plancat.c
+ *
+ * Returns the selectivity of a specified operator.
+ * This code executes registered procedures stored in the
+ * operator relation, by calling the function manager.
+ *
+ * XXX The assumption in the selectivity procedures is that if the
+ * relation OIDs or attribute numbers are -1, then the clause
+ * isn't of the form (op var const).
+ */
+Cost
+restriction_selectivity(Oid functionObjectId,
+ Oid operatorObjectId,
+ Oid relationObjectId,
+ AttrNumber attributeNumber,
+ char *constValue,
+ int32 constFlag)
+{
+ float64 result;
+
+ result = (float64) fmgr(functionObjectId,
+ (char *) operatorObjectId,
+ (char *) relationObjectId,
+ (char *) attributeNumber,
+ (char *) constValue,
+ (char *) constFlag,
+ NULL);
+ if (!PointerIsValid(result))
+ elog(WARN, "RestrictionClauseSelectivity: bad pointer");
+
+ if (*result < 0.0 || *result > 1.0)
+ elog(WARN, "RestrictionClauseSelectivity: bad value %lf",
+ *result);
+
+ return ((Cost)*result);
+}
+
+/*
+ * join_selectivity--
+ * Similarly, this routine is merged with JoinClauseSelectivity in
+ * plancat.c
+ *
+ * Returns the selectivity of an operator, given the join clause
+ * information.
+ *
+ * XXX The assumption in the selectivity procedures is that if the
+ * relation OIDs or attribute numbers are -1, then the clause
+ * isn't of the form (op var var).
+ */
+Cost
+join_selectivity (Oid functionObjectId,
+ Oid operatorObjectId,
+ Oid relationObjectId1,
+ AttrNumber attributeNumber1,
+ Oid relationObjectId2,
+ AttrNumber attributeNumber2)
+{
+ float64 result;
+
+ result = (float64) fmgr(functionObjectId,
+ (char *) operatorObjectId,
+ (char *) relationObjectId1,
+ (char *) attributeNumber1,
+ (char *) relationObjectId2,
+ (char *) attributeNumber2,
+ NULL);
+ if (!PointerIsValid(result))
+ elog(WARN, "JoinClauseSelectivity: bad pointer");
+
+ if (*result < 0.0 || *result > 1.0)
+ elog(WARN, "JoinClauseSelectivity: bad value %lf",
+ *result);
+
+ return((Cost)*result);
+}
+
+/*
+ * find_all_inheritors--
+ *
+ * Returns a LISP list containing the OIDs of all relations which
+ * inherits from the relation with OID 'inhparent'.
+ */
+List *
+find_inheritance_children(Oid inhparent)
+{
+ static ScanKeyData key[1] = {
+ { 0, Anum_pg_inherits_inhparent, F_OIDEQ }
+ };
+
+ HeapTuple inheritsTuple;
+ Relation relation;
+ HeapScanDesc scan;
+ List *list = NIL;
+ Oid inhrelid;
+
+ fmgr_info(F_OIDEQ, &key[0].sk_func, &key[0].sk_nargs);
+
+ key[0].sk_argument = ObjectIdGetDatum((Oid)inhparent);
+ relation = heap_openr(InheritsRelationName);
+ scan = heap_beginscan(relation, 0, NowTimeQual, 1, key);
+ while (HeapTupleIsValid(inheritsTuple =
+ heap_getnext(scan, 0,
+ (Buffer *) NULL))) {
+ inhrelid = ((InheritsTupleForm)GETSTRUCT(inheritsTuple))->inhrel;
+ list = lappendi(list, inhrelid);
+ }
+ heap_endscan(scan);
+ heap_close(relation);
+ return(list);
+}
+
+/*
+ * VersionGetParents--
+ *
+ * Returns a LISP list containing the OIDs of all relations which are
+ * base relations of the relation with OID 'verrelid'.
+ */
+List *
+VersionGetParents(Oid verrelid)
+{
+ static ScanKeyData key[1] = {
+ { 0, Anum_pg_version_verrelid, F_OIDEQ }
+ };
+
+ HeapTuple versionTuple;
+ Relation relation;
+ HeapScanDesc scan;
+ Oid verbaseid;
+ List *list= NIL;
+
+ fmgr_info(F_OIDEQ, &key[0].sk_func, &key[0].sk_nargs);
+ relation = heap_openr(VersionRelationName);
+ key[0].sk_argument = ObjectIdGetDatum(verrelid);
+ scan = heap_beginscan(relation, 0, NowTimeQual, 1, key);
+ for (;;) {
+ versionTuple = heap_getnext(scan, 0,
+ (Buffer *) NULL);
+ if (!HeapTupleIsValid(versionTuple))
+ break;
+ verbaseid = ((VersionTupleForm)
+ GETSTRUCT(versionTuple))->verbaseid;
+
+ list = lconsi(verbaseid, list);
+
+ key[0].sk_argument = ObjectIdGetDatum(verbaseid);
+ heap_rescan(scan, 0, key);
+ }
+ heap_endscan(scan);
+ heap_close(relation);
+ return(list);
+}
+
+/*****************************************************************************
+ *
+ *****************************************************************************/
+
+/*
+ * IdexSelectivity--
+ *
+ * Retrieves the 'amopnpages' and 'amopselect' parameters for each
+ * AM operator when a given index (specified by 'indexrelid') is used.
+ * These two parameters are returned by copying them to into an array of
+ * floats.
+ *
+ * Assumption: the attribute numbers and operator ObjectIds are in order
+ * WRT to each other (otherwise, you have no way of knowing which
+ * AM operator class or attribute number corresponds to which operator.
+ *
+ * 'varAttributeNumbers' contains attribute numbers for variables
+ * 'constValues' contains the constant values
+ * 'constFlags' describes how to treat the constants in each clause
+ * 'nIndexKeys' describes how many keys the index actually has
+ *
+ * Returns 'selectivityInfo' filled with the sum of all pages touched
+ * and the product of each clause's selectivity.
+ *
+ */
+static void
+IndexSelectivity(Oid indexrelid,
+ Oid indrelid,
+ int32 nIndexKeys,
+ Oid AccessMethodOperatorClasses[], /* XXX not used? */
+ Oid operatorObjectIds[],
+ int32 varAttributeNumbers[],
+ char *constValues[],
+ int32 constFlags[],
+ float *idxPages,
+ float *idxSelec)
+{
+ register i, n;
+ HeapTuple indexTuple, amopTuple, indRel;
+ IndexTupleForm index;
+ Form_pg_amop amop;
+ Oid indclass;
+ float64data npages, select;
+ float64 amopnpages, amopselect;
+ Oid relam;
+
+ indRel = SearchSysCacheTuple(RELOID,
+ ObjectIdGetDatum(indexrelid),
+ 0,0,0);
+ if (!HeapTupleIsValid(indRel))
+ elog(WARN, "IndexSelectivity: index %d not found",
+ indexrelid);
+ relam = ((Form_pg_class)GETSTRUCT(indRel))->relam;
+
+ indexTuple = SearchSysCacheTuple(INDEXRELID,
+ ObjectIdGetDatum(indexrelid),
+ 0,0,0);
+ if (!HeapTupleIsValid(indexTuple))
+ elog(WARN, "IndexSelectivity: index %d not found",
+ indexrelid);
+ index = (IndexTupleForm)GETSTRUCT(indexTuple);
+
+ npages = 0.0;
+ select = 1.0;
+ for (n = 0; n < nIndexKeys; ++n) {
+ /*
+ * Find the AM class for this key.
+ *
+ * If the first attribute number is invalid then we have a
+ * functional index, and AM class is the first one defined
+ * since functional indices have exactly one key.
+ */
+ indclass = (varAttributeNumbers[0] == InvalidAttrNumber) ?
+ index->indclass[0] : InvalidOid;
+ i = 0;
+ while ((i < nIndexKeys) && (indclass == InvalidOid)) {
+ if (varAttributeNumbers[n] == index->indkey[i]) {
+ indclass = index->indclass[i];
+ break;
+ }
+ i++;
+ }
+ if (!OidIsValid(indclass)) {
+ /*
+ * Presumably this means that we are using a functional
+ * index clause and so had no variable to match to
+ * the index key ... if not we are in trouble.
+ */
+ elog(NOTICE, "IndexSelectivity: no key %d in index %d",
+ varAttributeNumbers[n], indexrelid);
+ continue;
+ }
+
+ amopTuple = SearchSysCacheTuple(AMOPOPID,
+ ObjectIdGetDatum(indclass),
+ ObjectIdGetDatum(operatorObjectIds[n]),
+ ObjectIdGetDatum(relam),
+ 0);
+ if (!HeapTupleIsValid(amopTuple))
+ elog(WARN, "IndexSelectivity: no amop %d %d",
+ indclass, operatorObjectIds[n]);
+ amop = (Form_pg_amop)GETSTRUCT(amopTuple);
+ amopnpages = (float64) fmgr(amop->amopnpages,
+ (char *) operatorObjectIds[n],
+ (char *) indrelid,
+ (char *) varAttributeNumbers[n],
+ (char *) constValues[n],
+ (char *) constFlags[n],
+ (char *) nIndexKeys,
+ (char *) indexrelid);
+ npages += PointerIsValid(amopnpages) ? *amopnpages : 0.0;
+ if ((i = npages) < npages) /* ceil(npages)? */
+ npages += 1.0;
+ amopselect = (float64) fmgr(amop->amopselect,
+ (char *) operatorObjectIds[n],
+ (char *) indrelid,
+ (char *) varAttributeNumbers[n],
+ (char *) constValues[n],
+ (char *) constFlags[n],
+ (char *) nIndexKeys,
+ (char *) indexrelid);
+ select *= PointerIsValid(amopselect) ? *amopselect : 1.0;
+ }
+ *idxPages = npages;
+ *idxSelec = select;
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * relnode.c--
+ * Relation manipulation routines
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/relnode.c,v 1.1.1.1 1996/07/09 06:21:39 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/relation.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/pathnode.h" /* where the decls go */
+#include "optimizer/plancat.h"
+
+
+
+/*
+ * get_base_rel--
+ * Returns relation entry corresponding to 'relid', creating a new one if
+ * necessary. This is for base relations.
+ *
+ */
+Rel *get_base_rel(Query* root, int relid)
+{
+ List *relids;
+ Rel *rel;
+
+ relids = lconsi(relid, NIL);
+ rel = rel_member(relids, root->base_relation_list_);
+ if (rel==NULL) {
+ rel = makeNode(Rel);
+ rel->relids = relids;
+ rel->indexed = false;
+ rel->pages = 0;
+ rel->tuples = 0;
+ rel->width = 0;
+ rel->targetlist = NIL;
+ rel->pathlist = NIL;
+ rel->unorderedpath = (Path *)NULL;
+ rel->cheapestpath = (Path *)NULL;
+ rel->pruneable = true;
+ rel->classlist = NULL;
+ rel->ordering = NULL;
+ rel->relam = InvalidOid;
+ rel->clauseinfo = NIL;
+ rel->joininfo = NIL;
+ rel->innerjoin = NIL;
+ rel->superrels = NIL;
+
+ root->base_relation_list_ = lcons(rel,
+ root->base_relation_list_);
+
+ /*
+ * ??? the old lispy C code (get_rel) do a listp(relid) here but
+ * that can never happen since we already established relid is not
+ * a list. -ay 10/94
+ */
+ if(relid < 0) {
+ /*
+ * If the relation is a materialized relation, assume
+ * constants for sizes.
+ */
+ rel->pages = _TEMP_RELATION_PAGES_;
+ rel->tuples = _TEMP_RELATION_TUPLES_;
+
+ } else {
+ bool hasindex;
+ int pages, tuples;
+
+ /*
+ * Otherwise, retrieve relation characteristics from the
+ * system catalogs.
+ */
+ relation_info(root, relid, &hasindex, &pages, &tuples);
+ rel->indexed = hasindex;
+ rel->pages = pages;
+ rel->tuples = tuples;
+ }
+ }
+ return rel;
+}
+
+/*
+ * get_join_rel--
+ * Returns relation entry corresponding to 'relid' (a list of relids),
+ * creating a new one if necessary. This is for join relations.
+ *
+ */
+Rel *get_join_rel(Query *root, List *relid)
+{
+ return rel_member(relid, root->join_relation_list_);
+}
+
+/*
+ * rel-member--
+ * Determines whether a relation of id 'relid' is contained within a list
+ * 'rels'.
+ *
+ * Returns the corresponding entry in 'rels' if it is there.
+ *
+ */
+Rel *
+rel_member(List *relid, List *rels)
+{
+ List *temp = NIL;
+ List *temprelid = NIL;
+
+ if (relid!=NIL && rels!=NIL) {
+ foreach(temp,rels) {
+ temprelid = ((Rel*)lfirst(temp))->relids;
+ if(same(temprelid, relid))
+ return((Rel*)(lfirst(temp)));
+ }
+ }
+ return(NULL);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * tlist.c--
+ * Target list manipulation routines
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/tlist.c,v 1.1.1.1 1996/07/09 06:21:39 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "nodes/relation.h"
+#include "nodes/primnodes.h"
+#include "nodes/pg_list.h"
+#include "nodes/nodeFuncs.h"
+#include "utils/elog.h"
+#include "utils/lsyscache.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/var.h"
+#include "optimizer/tlist.h"
+#include "optimizer/clauses.h"
+
+#include "nodes/makefuncs.h"
+#include "parser/catalog_utils.h"
+
+static Node *flatten_tlistentry(Node *tlistentry, List *flat_tlist);
+
+/*****************************************************************************
+ * ---------- RELATION node target list routines ----------
+ *****************************************************************************/
+
+/*
+ * tlistentry-member--
+ *
+ * RETURNS: the leftmost member of sequence "targetlist" that satisfies
+ * the predicate "var_equal"
+ * MODIFIES: nothing
+ * REQUIRES: test = function which can operate on a lispval union
+ * var = valid var-node
+ * targetlist = valid sequence
+ */
+TargetEntry *
+tlistentry_member(Var *var, List *targetlist)
+{
+ if (var) {
+ List *temp = NIL;
+
+ foreach (temp,targetlist) {
+ if (var_equal(var,
+ get_expr(lfirst(temp))))
+ return((TargetEntry*)lfirst(temp));
+ }
+ }
+ return (NULL);
+}
+
+/*
+ * matching_tlvar--
+ *
+ * RETURNS: var node in a target list which is var_equal to 'var',
+ * if one exists.
+ * REQUIRES: "test" operates on lispval unions,
+ *
+ */
+Expr *
+matching_tlvar(Var *var, List *targetlist)
+{
+ TargetEntry *tlentry;
+
+ tlentry = tlistentry_member(var,targetlist);
+ if (tlentry)
+ return((Expr*)get_expr (tlentry) );
+
+ return((Expr*) NULL);
+}
+
+/*
+ * add_tl_element--
+ * Creates a targetlist entry corresponding to the supplied var node
+ *
+ * 'var' and adds the new targetlist entry to the targetlist field of
+ * 'rel'
+ *
+ * RETURNS: nothing
+ * MODIFIES: vartype and varid fields of leftmost varnode that matches
+ * argument "var" (sometimes).
+ * CREATES: new var-node iff no matching var-node exists in targetlist
+ */
+void
+add_tl_element(Rel *rel, Var *var)
+{
+ Expr *oldvar = (Expr *)NULL;
+
+ oldvar = matching_tlvar(var, rel->targetlist);
+
+ /*
+ * If 'var' is not already in 'rel's target list, add a new node.
+ */
+ if (oldvar==NULL) {
+ List *tlist = rel->targetlist;
+ Var *newvar = makeVar(var->varno,
+ var->varattno,
+ var->vartype,
+ var->varno,
+ var->varoattno);
+
+ rel->targetlist =
+ lappend (tlist,
+ create_tl_element(newvar,
+ length(tlist) + 1));
+
+ }
+}
+
+/*
+ * create_tl_element--
+ * Creates a target list entry node and its associated (resdom var) pair
+ * with its resdom number equal to 'resdomno' and the joinlist field set
+ * to 'joinlist'.
+ *
+ * RETURNS: newly created tlist-entry
+ * CREATES: new targetlist entry (always).
+ */
+TargetEntry*
+create_tl_element(Var *var, int resdomno)
+{
+ TargetEntry *tlelement= makeNode(TargetEntry);
+
+ tlelement->resdom =
+ makeResdom(resdomno,
+ var->vartype,
+ get_typlen(var->vartype),
+ NULL,
+ (Index)0,
+ (Oid)0,
+ 0);
+ tlelement->expr = (Node*)var;
+
+ return(tlelement);
+}
+
+/*
+ * get-actual-tlist--
+ * Returns the targetlist elements from a relation tlist.
+ *
+ */
+List *
+get_actual_tlist(List *tlist)
+{
+ /*
+ * this function is not making sense. - ay 10/94
+ */
+#if 0
+ List *element = NIL;
+ List *result = NIL;
+
+ if (tlist==NULL) {
+ elog(DEBUG,"calling get_actual_tlist with empty tlist");
+ return(NIL);
+ }
+ /* XXX - it is unclear to me what exactly get_entry
+ should be doing, as it is unclear to me the exact
+ relationship between "TL" "TLE" and joinlists */
+
+ foreach(element,tlist)
+ result = lappend(result, lfirst((List*)lfirst(element)));
+
+ return(result);
+#endif
+ return tlist;
+}
+
+/*****************************************************************************
+ * ---------- GENERAL target list routines ----------
+ *****************************************************************************/
+
+/*
+ * tlist-member--
+ * Determines whether a var node is already contained within a
+ * target list.
+ *
+ * 'var' is the var node
+ * 'tlist' is the target list
+ * 'dots' is t if we must match dotfields to determine uniqueness
+ *
+ * Returns the resdom entry of the matching var node.
+ *
+ */
+Resdom *
+tlist_member(Var *var, List *tlist)
+{
+ List *i = NIL;
+ TargetEntry *temp_tle = (TargetEntry *)NULL;
+ TargetEntry *tl_elt = (TargetEntry *)NULL;
+
+ if (var) {
+ foreach (i,tlist) {
+ temp_tle = (TargetEntry *)lfirst(i);
+ if (var_equal(var, get_expr(temp_tle))) {
+ tl_elt = temp_tle;
+ break;
+ }
+ }
+
+ if (tl_elt != NULL)
+ return(tl_elt->resdom);
+ else
+ return((Resdom*)NULL);
+ }
+ return ((Resdom*)NULL);
+}
+
+/*
+ * Routine to get the resdom out of a targetlist.
+ */
+Resdom *
+tlist_resdom(List *tlist, Resdom *resnode)
+{
+ Resdom *resdom = (Resdom*)NULL;
+ List *i = NIL;
+ TargetEntry *temp_tle = (TargetEntry *)NULL;
+
+ foreach(i,tlist) {
+ temp_tle = (TargetEntry *)lfirst(i);
+ resdom = temp_tle->resdom;
+ /* Since resnos are supposed to be unique */
+ if (resnode->resno == resdom->resno)
+ return(resdom);
+ }
+ return((Resdom*)NULL);
+}
+
+
+/*
+ * match_varid--
+ * Searches a target list for an entry with some desired varid.
+ *
+ * 'varid' is the desired id
+ * 'tlist' is the target list that is searched
+ *
+ * Returns the target list entry (resdom var) of the matching var.
+ *
+ * Now checks to make sure array references (in addition to range
+ * table indices) are identical - retrieve (a.b[1],a.b[2]) should
+ * not be turned into retrieve (a.b[1],a.b[1]).
+ *
+ * [what used to be varid is now broken up into two fields varnoold and
+ * varoattno. Also, nested attnos are long gone. - ay 2/95]
+ */
+TargetEntry *
+match_varid(Var *test_var, List *tlist)
+{
+ List *tl;
+ Oid type_var;
+
+ type_var = (Oid) test_var->vartype;
+
+ foreach (tl, tlist) {
+ TargetEntry *entry;
+ Var *tlvar;
+
+ entry = lfirst(tl);
+ tlvar = get_expr(entry);
+
+ /*
+ * we test the original varno (instead of varno which might
+ * be changed to INNER/OUTER.
+ */
+ if (tlvar->varnoold == test_var->varnoold &&
+ tlvar->varoattno == test_var->varoattno) {
+
+ if (tlvar->vartype == type_var)
+ return(entry);
+ }
+ }
+
+ return (NULL);
+}
+
+
+/*
+ * new-unsorted-tlist--
+ * Creates a copy of a target list by creating new resdom nodes
+ * without sort information.
+ *
+ * 'targetlist' is the target list to be copied.
+ *
+ * Returns the resulting target list.
+ *
+ */
+List *
+new_unsorted_tlist(List *targetlist)
+{
+ List *new_targetlist = (List*)copyObject ((Node*)targetlist);
+ List *x = NIL;
+
+ foreach (x, new_targetlist) {
+ TargetEntry *tle = (TargetEntry *)lfirst(x);
+ tle->resdom->reskey = 0;
+ tle->resdom->reskeyop = (Oid)0;
+ }
+ return(new_targetlist);
+}
+
+/*
+ * copy-vars--
+ * Replaces the var nodes in the first target list with those from
+ * the second target list. The two target lists are assumed to be
+ * identical except their actual resdoms and vars are different.
+ *
+ * 'target' is the target list to be replaced
+ * 'source' is the target list to be copied
+ *
+ * Returns a new target list.
+ *
+ */
+List *
+copy_vars(List *target, List *source)
+{
+ List *result = NIL;
+ List *src = NIL;
+ List *dest = NIL;
+
+ for ( src = source, dest = target; src != NIL &&
+ dest != NIL; src = lnext(src), dest = lnext(dest)) {
+ TargetEntry *temp = MakeTLE(((TargetEntry *)lfirst(dest))->resdom,
+ (Node*)get_expr(lfirst(src)));
+ result = lappend(result,temp);
+ }
+ return(result);
+}
+
+/*
+ * flatten-tlist--
+ * Create a target list that only contains unique variables.
+ *
+ *
+ * 'tlist' is the current target list
+ *
+ * Returns the "flattened" new target list.
+ *
+ */
+List *
+flatten_tlist(List *tlist)
+{
+ int last_resdomno = 1;
+ List *new_tlist = NIL;
+ List *tlist_vars = NIL;
+ List *temp;
+
+ foreach (temp, tlist) {
+ TargetEntry *temp_entry = NULL;
+ List *vars;
+
+ temp_entry = lfirst(temp);
+ vars = pull_var_clause((Node*)get_expr(temp_entry));
+ if(vars != NULL) {
+ tlist_vars = nconc(tlist_vars, vars);
+ }
+ }
+
+ foreach (temp, tlist_vars) {
+ Var *var = lfirst(temp);
+ if (!(tlist_member(var, new_tlist))) {
+ Resdom *r;
+
+ r = makeResdom(last_resdomno,
+ var->vartype,
+ get_typlen(var->vartype),
+ NULL,
+ (Index)0,
+ (Oid)0,
+ 0);
+ last_resdomno++;
+ new_tlist = lappend(new_tlist, MakeTLE (r, (Node*)var));
+ }
+ }
+
+ return new_tlist;
+}
+
+/*
+ * flatten-tlist-vars--
+ * Redoes the target list of a query with no nested attributes by
+ * replacing vars within computational expressions with vars from
+ * the 'flattened' target list of the query.
+ *
+ * 'full-tlist' is the actual target list
+ * 'flat-tlist' is the flattened (var-only) target list
+ *
+ * Returns the modified actual target list.
+ *
+ */
+List *
+flatten_tlist_vars(List *full_tlist, List *flat_tlist)
+{
+ List *x = NIL;
+ List *result = NIL;
+
+ foreach(x,full_tlist) {
+ TargetEntry *tle= lfirst(x);
+ result =
+ lappend(result,
+ MakeTLE(tle->resdom,
+ flatten_tlistentry((Node*)get_expr(tle),
+ flat_tlist)));
+ }
+
+ return(result);
+}
+
+/*
+ * flatten-tlistentry--
+ * Replaces vars within a target list entry with vars from a flattened
+ * target list.
+ *
+ * 'tlistentry' is the target list entry to be modified
+ * 'flat-tlist' is the flattened target list
+ *
+ * Returns the (modified) target_list entry from the target list.
+ *
+ */
+static Node *
+flatten_tlistentry(Node *tlistentry, List *flat_tlist)
+{
+ if (tlistentry==NULL) {
+
+ return NULL;
+
+ } else if (IsA (tlistentry,Var)) {
+
+ return
+ ((Node *)get_expr(match_varid((Var*)tlistentry,
+ flat_tlist)));
+ } else if (IsA (tlistentry,Iter)) {
+
+ ((Iter*)tlistentry)->iterexpr =
+ flatten_tlistentry((Node*)((Iter*)tlistentry)->iterexpr,
+ flat_tlist);
+ return tlistentry;
+
+ } else if (single_node(tlistentry)) {
+
+ return tlistentry;
+
+ } else if (is_funcclause (tlistentry)) {
+ Expr *expr = (Expr*)tlistentry;
+ List *temp_result = NIL;
+ List *elt = NIL;
+
+ foreach(elt, expr->args)
+ temp_result = lappend(temp_result,
+ flatten_tlistentry(lfirst(elt),flat_tlist));
+
+ return
+ ((Node *)make_funcclause((Func*)expr->oper, temp_result));
+
+ } else if (IsA(tlistentry,Aggreg)) {
+
+ return tlistentry;
+
+ } else if (IsA(tlistentry,ArrayRef)) {
+ ArrayRef *aref = (ArrayRef *)tlistentry;
+ List *temp = NIL;
+ List *elt = NIL;
+
+ foreach(elt, aref->refupperindexpr)
+ temp = lappend(temp, flatten_tlistentry(lfirst(elt), flat_tlist));
+ aref->refupperindexpr = temp;
+
+ temp = NIL;
+ foreach(elt, aref->reflowerindexpr)
+ temp = lappend(temp, flatten_tlistentry(lfirst(elt), flat_tlist));
+ aref->reflowerindexpr = temp;
+
+ aref->refexpr =
+ flatten_tlistentry(aref->refexpr, flat_tlist);
+
+ aref->refassgnexpr =
+ flatten_tlistentry(aref->refassgnexpr, flat_tlist);
+
+ return tlistentry;
+ } else {
+ Expr *expr = (Expr*)tlistentry;
+ Var *left =
+ (Var*)flatten_tlistentry((Node*)get_leftop(expr),
+ flat_tlist);
+ Var *right =
+ (Var*)flatten_tlistentry((Node*)get_rightop(expr),
+ flat_tlist);
+
+ return((Node *)
+ make_opclause((Oper*)expr->oper, left, right));
+ }
+}
+
+
+TargetEntry *
+MakeTLE(Resdom *resdom, Node *expr)
+{
+ TargetEntry *rt = makeNode(TargetEntry);
+
+ rt->resdom = resdom;
+ rt->expr = expr;
+ return rt;
+}
+
+Var *
+get_expr(TargetEntry *tle)
+{
+ Assert(tle!=NULL);
+ Assert(tle->expr!=NULL);
+
+ return ((Var *)tle->expr);
+}
+
+
+/*****************************************************************************
+ *
+ *****************************************************************************/
+
+/*
+ * AddGroupAttrToTlist -
+ * append the group attribute to the target list if it's not already
+ * in there.
+ */
+void
+AddGroupAttrToTlist(List *tlist, List *grpCl)
+{
+ List *gl;
+ int last_resdomno = length(tlist) + 1;
+
+ foreach (gl, grpCl) {
+ GroupClause *gc = (GroupClause*)lfirst(gl);
+ Var *var = gc->grpAttr;
+
+ if (!(tlist_member(var, tlist))) {
+ Resdom *r;
+
+ r = makeResdom(last_resdomno,
+ var->vartype,
+ get_typlen(var->vartype),
+ NULL,
+ (Index)0,
+ (Oid)0,
+ 0);
+ last_resdomno++;
+ tlist = lappend(tlist, MakeTLE(r, (Node*)var));
+ }
+ }
+}
+
+/* was ExecTargetListLength() in execQual.c,
+ moved here to reduce dependencies on the executor module */
+int
+exec_tlist_length(List *targetlist)
+{
+ int len;
+ List *tl;
+ TargetEntry *curTle;
+
+ len = 0;
+ foreach (tl, targetlist) {
+ curTle = lfirst(tl);
+
+ if (curTle->resdom != NULL)
+ len++;
+ }
+ return len;
+}
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * var.c--
+ * Var node manipulation routines
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.1.1.1 1996/07/09 06:21:39 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "nodes/primnodes.h"
+#include "nodes/nodeFuncs.h"
+
+#include "optimizer/internal.h"
+#include "optimizer/clauses.h"
+#include "optimizer/var.h"
+
+#include "parser/parsetree.h"
+
+/*
+ * find_varnos
+ *
+ * Descends down part of a parsetree (qual or tlist),
+ *
+ * XXX assumes varno's are always integers, which shouldn't be true...
+ * (though it currently is, see primnodes.h)
+ */
+List *
+pull_varnos(Node *me)
+{
+ List *i, *result = NIL;
+
+ if (me == NULL)
+ return (NIL);
+
+ switch (nodeTag(me)) {
+ case T_List:
+ foreach (i, (List*)me) {
+ result = nconc(result, pull_varnos(lfirst(i)));
+ }
+ break;
+ case T_ArrayRef:
+ foreach (i, ((ArrayRef*) me)->refupperindexpr)
+ result = nconc(result, pull_varnos(lfirst(i)));
+ foreach (i, ((ArrayRef*) me)->reflowerindexpr)
+ result = nconc(result, pull_varnos(lfirst(i)));
+ result = nconc(result, pull_varnos(((ArrayRef*) me)->refassgnexpr));
+ break;
+ case T_Var:
+ result = lconsi(((Var*) me)->varno, NIL);
+ break;
+ default:
+ break;
+ }
+ return(result);
+}
+
+/*
+ * contain_var_clause--
+ * Recursively find var nodes from a clause by pulling vars from the
+ * left and right operands of the clause.
+ *
+ * Returns true if any varnode found.
+ */
+bool contain_var_clause(Node *clause)
+{
+ if (clause==NULL)
+ return FALSE;
+ else if (IsA(clause,Var))
+ return TRUE;
+ else if (IsA(clause,Iter))
+ return contain_var_clause(((Iter*)clause)->iterexpr);
+ else if (single_node(clause))
+ return FALSE;
+ else if (or_clause(clause)) {
+ List *temp;
+
+ foreach (temp, ((Expr*)clause)->args) {
+ if (contain_var_clause(lfirst(temp)))
+ return TRUE;
+ }
+ return FALSE;
+ } else if (is_funcclause (clause)) {
+ List *temp;
+
+ foreach(temp, ((Expr *)clause)->args) {
+ if (contain_var_clause(lfirst(temp)))
+ return TRUE;
+ }
+ return FALSE;
+ } else if (IsA(clause,ArrayRef)) {
+ List *temp;
+
+ foreach(temp, ((ArrayRef*)clause)->refupperindexpr) {
+ if (contain_var_clause(lfirst(temp)))
+ return TRUE;
+ }
+ foreach(temp, ((ArrayRef*)clause)->reflowerindexpr) {
+ if (contain_var_clause(lfirst(temp)))
+ return TRUE;
+ }
+ if (contain_var_clause(((ArrayRef*)clause)->refexpr))
+ return TRUE;
+ if (contain_var_clause(((ArrayRef*)clause)->refassgnexpr))
+ return TRUE;
+ return FALSE;
+ } else if (not_clause(clause))
+ return contain_var_clause((Node*)get_notclausearg((Expr*)clause));
+ else if (is_opclause(clause))
+ return (contain_var_clause((Node*)get_leftop((Expr*)clause)) ||
+ contain_var_clause((Node*)get_rightop((Expr*)clause)));
+
+ return FALSE;
+}
+
+/*
+ * pull_var_clause--
+ * Recursively pulls all var nodes from a clause by pulling vars from the
+ * left and right operands of the clause.
+ *
+ * Returns list of varnodes found.
+ */
+List *
+pull_var_clause(Node *clause)
+{
+ List *retval = NIL;
+
+ if (clause==NULL)
+ return(NIL);
+ else if (IsA(clause,Var))
+ retval = lcons(clause,NIL);
+ else if (IsA(clause,Iter))
+ retval = pull_var_clause(((Iter*)clause)->iterexpr);
+ else if (single_node(clause))
+ retval = NIL;
+ else if (or_clause(clause)) {
+ List *temp;
+
+ foreach (temp, ((Expr*)clause)->args)
+ retval = nconc(retval, pull_var_clause(lfirst(temp)));
+ } else if (is_funcclause (clause)) {
+ List *temp;
+
+ foreach(temp, ((Expr *)clause)->args)
+ retval = nconc (retval,pull_var_clause(lfirst(temp)));
+ } else if (IsA(clause,Aggreg)) {
+ retval = pull_var_clause(((Aggreg*)clause)->target);
+ } else if (IsA(clause,ArrayRef)) {
+ List *temp;
+
+ foreach(temp, ((ArrayRef*)clause)->refupperindexpr)
+ retval = nconc (retval,pull_var_clause(lfirst(temp)));
+ foreach(temp, ((ArrayRef*)clause)->reflowerindexpr)
+ retval = nconc (retval,pull_var_clause(lfirst(temp)));
+ retval = nconc(retval,
+ pull_var_clause(((ArrayRef*)clause)->refexpr));
+ retval = nconc(retval,
+ pull_var_clause(((ArrayRef*)clause)->refassgnexpr));
+ } else if (not_clause(clause))
+ retval = pull_var_clause((Node*)get_notclausearg((Expr*)clause));
+ else if (is_opclause(clause))
+ retval = nconc(pull_var_clause((Node*)get_leftop((Expr*)clause)),
+ pull_var_clause((Node*)get_rightop((Expr*)clause)));
+ else
+ retval = NIL;
+
+ return (retval);
+}
+
+/*
+ * var_equal
+ *
+ * Returns t iff two var nodes correspond to the same attribute.
+ */
+bool
+var_equal(Var *var1, Var *var2)
+{
+ if (IsA (var1,Var) && IsA (var2,Var) &&
+ (((Var*)var1)->varno == ((Var*)var2)->varno) &&
+ (((Var*)var1)->vartype == ((Var*)var2)->vartype) &&
+ (((Var*)var1)->varattno == ((Var*)var2)->varattno)) {
+
+ return(true);
+ } else
+ return(false);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * var.h--
+ * prototypes for var.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: var.h,v 1.1.1.1 1996/07/09 06:21:35 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef VAR_H
+#define VAR_H
+
+extern List *pull_varnos(Node *me);
+extern bool contain_var_clause(Node *clause);
+extern List *pull_var_clause(Node *clause);
+extern bool var_equal(Var *var1, Var *var2);
+
+#endif /* VAR_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * xfunc.h--
+ * prototypes for xfunc.c and predmig.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: xfunc.h,v 1.1.1.1 1996/07/09 06:21:35 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef XFUNC_H
+#define XFUNC_H
+
+#include "nodes/relation.h"
+
+/* command line arg flags */
+#define XFUNC_OFF -1 /* do no optimization of expensive preds */
+#define XFUNC_NOR 2 /* do no optimization of OR clauses */
+#define XFUNC_NOPULL 4 /* never pull restrictions above joins */
+#define XFUNC_NOPM 8 /* don't do predicate migration */
+#define XFUNC_WAIT 16 /* don't do pullup until predicate migration */
+#define XFUNC_PULLALL 32 /* pull all expensive restrictions up, always */
+
+/* constants for local and join predicates */
+#define XFUNC_LOCPRD 1
+#define XFUNC_JOINPRD 2
+#define XFUNC_UNKNOWN 0
+
+extern int XfuncMode; /* defined in tcop/postgres.c */
+
+/* defaults for function attributes used for expensive function calculations */
+#define BYTE_PCT 100
+#define PERBYTE_CPU 0
+#define PERCALL_CPU 0
+#define OUTIN_RATIO 100
+
+/* default width assumed for variable length attributes */
+#define VARLEN_DEFAULT 128;
+
+/* Macro to get group rank out of group cost and group sel */
+#define get_grouprank(a) ((get_groupsel(a) - 1) / get_groupcost(a))
+
+/* Macro to see if a path node is actually a Join */
+#define is_join(pathnode) (length(get_relids(get_parent(pathnode))) > 1 ? 1 : 0)
+
+/* function prototypes from planner/path/xfunc.c */
+extern void xfunc_trypullup(Rel *rel);
+extern int xfunc_shouldpull(Path *childpath, JoinPath *parentpath,
+ int whichchild, CInfo *maxcinfopt);
+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);
+extern Cost xfunc_join_expense(JoinPath *path, int whichchild);
+extern Cost xfunc_local_expense(Expr *clause);
+extern Cost xfunc_func_expense(Expr *node, List *args);
+extern int xfunc_width(Expr *clause);
+/* static, moved to xfunc.c */
+/* extern int xfunc_card_unreferenced(Expr *clause, Relid referenced); */
+extern int xfunc_card_product(Relid relids);
+extern List *xfunc_find_references(List *clause);
+extern List *xfunc_primary_join(JoinPath *pathnode);
+extern Cost xfunc_get_path_cost(Path *pathnode);
+extern Cost xfunc_total_path_cost(JoinPath *pathnode);
+extern Cost xfunc_expense_per_tuple(JoinPath *joinnode, int whichchild);
+extern void xfunc_fixvars(Expr *clause, Rel *rel, int varno);
+extern int xfunc_cinfo_compare(void *arg1, void *arg2);
+extern int xfunc_clause_compare(void *arg1, void *arg2);
+extern void xfunc_disjunct_sort(List *clause_list);
+extern int xfunc_disjunct_compare(void *arg1, void *arg2);
+extern int xfunc_func_width(RegProcedure funcid, List *args);
+extern int xfunc_tuple_width(Relation rd);
+extern int xfunc_num_join_clauses(JoinPath *path);
+extern List *xfunc_LispRemove(List *foo, List *bar);
+extern bool xfunc_copyrel(Rel *from, Rel **to);
+
+/*
+ * function prototypes for path/predmig.c
+ */
+extern bool xfunc_do_predmig(Path root);
+
+#endif /* XFUNC_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for the parser module
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/parser/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:39 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+VPATH:= $(VPATH):$(CURDIR)/parser
+
+#PARSEYACCS= gram.c parse.h
+PARSEYACCS= gram.c
+
+$(PARSEYACCS): gram.y
+ cd $(objdir); \
+ $(YACC) $(YFLAGS) $<; \
+ mv y.tab.c gram.c; \
+ mv y.tab.h parse.h
+
+$(objdir)/gram.o: gram.c
+ $(cc_inobjdir)
+
+
+scan.c: scan.l
+ cd $(objdir); $(LEX) $<; mv lex.yy.c scan.c
+
+$(objdir)/scan.o: scan.c
+ $(cc_inobjdir)
+
+
+SRCS_PARSER+= analyze.c catalog_utils.c dbcommands.c gram.c \
+ keywords.c parser.c parse_query.c scan.c scansup.c
+
+CLEANFILES+= scan.c ${PARSEYACCS}
+
+POSTGRES_DEPEND+= scan.c $(PARSEYACCS)
+
+HEADERS+= catalog_utils.h io.h parse_query.h parsetree.h \
+ dbcommands.h keywords.h
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * analyze.c--
+ * transform the parse tree into a query tree
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.1.1.1 1996/07/09 06:21:39 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include
+#include "postgres.h"
+#include "nodes/nodes.h"
+#include "nodes/primnodes.h"
+#include "nodes/parsenodes.h"
+#include "nodes/relation.h"
+#include "parse.h" /* for AND, OR, etc. */
+#include "catalog/pg_type.h" /* for INT4OID, etc. */
+#include "utils/elog.h"
+#include "utils/builtins.h" /* namecmp(), textout() */
+#include "utils/lsyscache.h"
+#include "utils/palloc.h"
+#include "utils/mcxt.h"
+#include "parser/parse_query.h"
+#include "parser/parse_state.h"
+#include "nodes/makefuncs.h" /* for makeResdom(), etc. */
+#include "nodes/nodeFuncs.h"
+
+#include "optimizer/clauses.h"
+#include "access/heapam.h"
+
+/* convert the parse tree into a query tree */
+static Query *transformStmt(ParseState *pstate, Node *stmt);
+
+static Query *transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt);
+static Query *transformInsertStmt(ParseState *pstate, AppendStmt *stmt);
+static Query *transformIndexStmt(ParseState *pstate, IndexStmt *stmt);
+static Query *transformExtendStmt(ParseState *pstate, ExtendStmt *stmt);
+static Query *transformRuleStmt(ParseState *query, RuleStmt *stmt);
+static Query *transformSelectStmt(ParseState *pstate, RetrieveStmt *stmt);
+static Query *transformUpdateStmt(ParseState *pstate, ReplaceStmt *stmt);
+static Query *transformCursorStmt(ParseState *pstate, CursorStmt *stmt);
+static Node *handleNestedDots(ParseState *pstate, Attr *attr, int *curr_resno);
+
+static Node *transformExpr(ParseState *pstate, Node *expr);
+
+static void makeRangeTable(ParseState *pstate, char *relname, List *frmList);
+static List *expandAllTables(ParseState *pstate);
+static char *figureColname(Node *expr, Node *resval);
+static List *makeTargetList(ParseState *pstate, List *cols, List *exprs);
+static List *transformTargetList(ParseState *pstate,
+ List *targetlist, bool isInsert,
+ bool isUpdate);
+static TargetEntry *make_targetlist_expr(ParseState *pstate,
+ char *name, Node *expr,
+ List *arrayRef,
+ bool ResdomNoIsAttrNo);
+static Node *transformWhereClause(ParseState *pstate, Node *a_expr);
+static List *transformGroupClause(ParseState *pstate, List *grouplist);
+static List *transformSortClause(List *orderlist, List *targetlist,
+ char* uniqueFlag);
+
+static void parseFromClause(ParseState *pstate, List *frmList);
+static Node *ParseFunc(ParseState *pstate, char *funcname,
+ List *fargs, int *curr_resno);
+static char *ParseColumnName(ParseState *pstate, char *name, bool *isRelName);
+static List *setup_tlist(char *attname, Oid relid);
+static List *setup_base_tlist(Oid typeid);
+static void make_arguments(int nargs, List *fargs, Oid *input_typeids, Oid *function_typeids);
+static void AddAggToParseState(ParseState *pstate, Aggreg *aggreg);
+static void finalizeAggregates(ParseState *pstate, Query *qry);
+static void parseCheckAggregates(ParseState *pstate, Query *qry);
+
+/*****************************************************************************
+ *
+ *****************************************************************************/
+
+/*
+ * makeParseState() --
+ * allocate and initialize a new ParseState.
+ * the CALLERS is responsible for freeing the ParseState* returned
+ *
+ */
+
+ParseState*
+makeParseState() {
+ ParseState *pstate;
+
+ pstate = malloc(sizeof(ParseState));
+ pstate->p_last_resno = 1;
+ pstate->p_target_resnos = NIL;
+ pstate->p_rtable = NIL;
+ pstate->p_query_is_rule = 0;
+ pstate->p_numAgg = 0;
+ pstate->p_aggs = NULL;
+
+ return (pstate);
+}
+/*
+ * parse_analyze -
+ * analyze a list of parse trees and transform them if necessary.
+ *
+ * Returns a list of transformed parse trees. Optimizable statements are
+ * all transformed to Query while the rest stays the same.
+ *
+ * CALLER is responsible for freeing the QueryTreeList* returned
+ */
+QueryTreeList *
+parse_analyze(List *pl)
+{
+ QueryTreeList *result;
+ ParseState *pstate;
+ int i = 0;
+
+ result = malloc(sizeof(QueryTreeList));
+ result->len = length(pl);
+ result->qtrees = (Query**)malloc(result->len * sizeof(Query*));
+
+ while(pl!=NIL) {
+ pstate = makeParseState();
+ result->qtrees[i++] = transformStmt(pstate, lfirst(pl));
+ pl = lnext(pl);
+ free(pstate);
+ }
+
+ return result;
+}
+
+/*
+ * transformStmt -
+ * transform a Parse tree. If it is an optimizable statement, turn it
+ * into a Query tree.
+ */
+static Query *
+transformStmt(ParseState* pstate, Node *parseTree)
+{
+ Query* result = NULL;
+
+ switch(nodeTag(parseTree)) {
+ /*------------------------
+ * Non-optimizable statements
+ *------------------------
+ */
+ case T_IndexStmt:
+ result = transformIndexStmt(pstate, (IndexStmt *)parseTree);
+ break;
+
+ case T_ExtendStmt:
+ result = transformExtendStmt(pstate, (ExtendStmt *)parseTree);
+ break;
+
+ case T_RuleStmt:
+ result = transformRuleStmt(pstate, (RuleStmt *)parseTree);
+ break;
+
+ case T_ViewStmt:
+ {
+ ViewStmt *n = (ViewStmt *)parseTree;
+ n->query = (Query *)transformStmt(pstate, (Node*)n->query);
+ result = makeNode(Query);
+ result->commandType = CMD_UTILITY;
+ result->utilityStmt = (Node*)n;
+ }
+ break;
+
+ case T_VacuumStmt:
+ {
+ MemoryContext oldcontext;
+ /* make sure that this Query is allocated in TopMemory context
+ because vacuum spans transactions and we don't want to lose
+ the vacuum Query due to end-of-transaction free'ing*/
+ oldcontext = MemoryContextSwitchTo(TopMemoryContext);
+ result = makeNode(Query);
+ result->commandType = CMD_UTILITY;
+ result->utilityStmt = (Node*)parseTree;
+ MemoryContextSwitchTo(oldcontext);
+ break;
+
+ }
+ case T_ExplainStmt:
+ {
+ ExplainStmt *n = (ExplainStmt *)parseTree;
+ result = makeNode(Query);
+ result->commandType = CMD_UTILITY;
+ n->query = transformStmt(pstate, (Node*)n->query);
+ result->utilityStmt = (Node*)parseTree;
+ }
+ break;
+
+ /*------------------------
+ * Optimizable statements
+ *------------------------
+ */
+ case T_AppendStmt:
+ result = transformInsertStmt(pstate, (AppendStmt *)parseTree);
+ break;
+
+ case T_DeleteStmt:
+ result = transformDeleteStmt(pstate, (DeleteStmt *)parseTree);
+ break;
+
+ case T_ReplaceStmt:
+ result = transformUpdateStmt(pstate, (ReplaceStmt *)parseTree);
+ break;
+
+ case T_CursorStmt:
+ result = transformCursorStmt(pstate, (CursorStmt *)parseTree);
+ break;
+
+ case T_RetrieveStmt:
+ result = transformSelectStmt(pstate, (RetrieveStmt *)parseTree);
+ break;
+
+ default:
+ /*
+ * other statments don't require any transformation-- just
+ * return the original parsetree
+ */
+ result = makeNode(Query);
+ result->commandType = CMD_UTILITY;
+ result->utilityStmt = (Node*)parseTree;
+ break;
+ }
+ return result;
+}
+
+/*
+ * transformDeleteStmt -
+ * transforms a Delete Statement
+ */
+static Query *
+transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt)
+{
+ Query *qry = makeNode(Query);
+
+ qry->commandType = CMD_DELETE;
+
+ /* set up a range table */
+ makeRangeTable(pstate, stmt->relname, NULL);
+
+/* qry->uniqueFlag = FALSE; */
+ qry->uniqueFlag = NULL;
+
+ /* fix where clause */
+ qry->qual = transformWhereClause(pstate, stmt->whereClause);
+
+ qry->rtable = pstate->p_rtable;
+ qry->resultRelation = RangeTablePosn(pstate->p_rtable, stmt->relname);
+
+ /* make sure we don't have aggregates in the where clause */
+ if (pstate->p_numAgg > 0)
+ parseCheckAggregates(pstate, qry);
+
+ return (Query *)qry;
+}
+
+/*
+ * transformInsertStmt -
+ * transform an Insert Statement
+ */
+static Query *
+transformInsertStmt(ParseState *pstate, AppendStmt *stmt)
+{
+ Query *qry = makeNode(Query); /* make a new query tree */
+ List *targetlist;
+
+ qry->commandType = CMD_INSERT;
+
+ /* set up a range table */
+ makeRangeTable(pstate, stmt->relname, stmt->fromClause);
+
+/* qry->uniqueFlag = FALSE; */
+ qry->uniqueFlag = NULL;
+
+ /* fix the target list */
+ targetlist = makeTargetList(pstate, stmt->cols, stmt->exprs);
+ qry->targetList = transformTargetList(pstate,
+ targetlist,
+ TRUE /* is insert */,
+ FALSE /*not update*/);
+
+ /* fix where clause */
+ qry->qual = transformWhereClause(pstate, stmt->whereClause);
+
+ /* now the range table will not change */
+ qry->rtable = pstate->p_rtable;
+ qry->resultRelation = RangeTablePosn(pstate->p_rtable, stmt->relname);
+
+ if (pstate->p_numAgg > 0)
+ finalizeAggregates(pstate, qry);
+
+ return (Query *)qry;
+}
+
+/*
+ * transformIndexStmt -
+ * transforms the qualification of the index statement
+ */
+static Query *
+transformIndexStmt(ParseState *pstate, IndexStmt *stmt)
+{
+ Query* q;
+
+ q = makeNode(Query);
+ q->commandType = CMD_UTILITY;
+
+ /* take care of the where clause */
+ stmt->whereClause = transformWhereClause(pstate,stmt->whereClause);
+ stmt->rangetable = pstate->p_rtable;
+
+ q->utilityStmt = (Node*)stmt;
+
+ return q;
+}
+
+/*
+ * transformExtendStmt -
+ * transform the qualifications of the Extend Index Statement
+ *
+ */
+static Query *
+transformExtendStmt(ParseState *pstate, ExtendStmt *stmt)
+{
+ Query *q;
+
+ q = makeNode(Query);
+ q->commandType = CMD_UTILITY;
+
+ /* take care of the where clause */
+ stmt->whereClause = transformWhereClause(pstate,stmt->whereClause);
+ stmt->rangetable = pstate->p_rtable;
+
+ q->utilityStmt = (Node*)stmt;
+ return q;
+}
+
+/*
+ * transformRuleStmt -
+ * transform a Create Rule Statement. The actions is a list of parse
+ * trees which is transformed into a list of query trees.
+ */
+static Query *
+transformRuleStmt(ParseState *pstate, RuleStmt *stmt)
+{
+ Query *q;
+ List *actions;
+
+ q = makeNode(Query);
+ q->commandType = CMD_UTILITY;
+
+ actions = stmt->actions;
+ /*
+ * transform each statment, like parse_analyze()
+ */
+ while (actions != NIL) {
+ RangeTblEntry *curEnt, *newEnt;
+
+ /*
+ * NOTE: 'CURRENT' must always have a varno equal to 1 and 'NEW'
+ * equal to 2.
+ */
+ curEnt = makeRangeTableEntry(stmt->object->relname, FALSE,
+ NULL, "*CURRENT*");
+ newEnt = makeRangeTableEntry(stmt->object->relname, FALSE,
+ NULL, "*NEW*");
+ pstate->p_rtable = makeList(curEnt, newEnt, -1);
+
+ pstate->p_last_resno = 1;
+ pstate->p_target_resnos = NIL;
+ pstate->p_query_is_rule = 1; /* for expand all */
+ pstate->p_numAgg = 0;
+ pstate->p_aggs = NULL;
+
+ lfirst(actions) = transformStmt(pstate, lfirst(actions));
+ actions = lnext(actions);
+ }
+
+ /* take care of the where clause */
+ stmt->whereClause = transformWhereClause(pstate,stmt->whereClause);
+
+ q->utilityStmt = (Node*)stmt;
+ return q;
+}
+
+
+/*
+ * transformSelectStmt -
+ * transforms a Select Statement
+ *
+ */
+static Query *
+transformSelectStmt(ParseState *pstate, RetrieveStmt *stmt)
+{
+ Query *qry = makeNode(Query);
+
+ qry->commandType = CMD_SELECT;
+
+ /* set up a range table */
+ makeRangeTable(pstate, NULL, stmt->fromClause);
+
+ qry->uniqueFlag = stmt->unique;
+
+ qry->into = stmt->into;
+ qry->isPortal = FALSE;
+
+ /* fix the target list */
+ qry->targetList = transformTargetList(pstate,
+ stmt->targetList,
+ FALSE, /*is insert */
+ FALSE /*not update*/);
+
+ /* fix where clause */
+ qry->qual = transformWhereClause(pstate,stmt->whereClause);
+
+ /* fix order clause */
+ qry->sortClause = transformSortClause(stmt->orderClause,
+ qry->targetList,
+ qry->uniqueFlag);
+
+ /* fix group by clause */
+ qry->groupClause = transformGroupClause(pstate,
+ stmt->groupClause);
+ qry->rtable = pstate->p_rtable;
+
+ if (pstate->p_numAgg > 0)
+ finalizeAggregates(pstate, qry);
+
+ return (Query *)qry;
+}
+
+/*
+ * transformUpdateStmt -
+ * transforms an update statement
+ *
+ */
+static Query *
+transformUpdateStmt(ParseState *pstate, ReplaceStmt *stmt)
+{
+ Query *qry = makeNode(Query);
+
+ qry->commandType = CMD_UPDATE;
+
+ /*
+ * the FROM clause is non-standard SQL syntax. We used to be able to
+ * do this with REPLACE in POSTQUEL so we keep the feature.
+ */
+ makeRangeTable(pstate, stmt->relname, stmt->fromClause);
+
+ /* fix the target list */
+ qry->targetList = transformTargetList(pstate,
+ stmt->targetList,
+ FALSE, /* not insert */
+ TRUE /* is update */);
+
+ /* fix where clause */
+ qry->qual = transformWhereClause(pstate,stmt->whereClause);
+
+ qry->rtable = pstate->p_rtable;
+ qry->resultRelation = RangeTablePosn(pstate->p_rtable, stmt->relname);
+
+ /* make sure we don't have aggregates in the where clause */
+ if (pstate->p_numAgg > 0)
+ parseCheckAggregates(pstate, qry);
+
+ return (Query *)qry;
+}
+
+/*
+ * transformCursorStmt -
+ * transform a Create Cursor Statement
+ *
+ */
+static Query *
+transformCursorStmt(ParseState *pstate, CursorStmt *stmt)
+{
+ Query *qry = makeNode(Query);
+
+ /*
+ * in the old days, a cursor statement is a 'retrieve into portal';
+ * If you change the following, make sure you also go through the code
+ * in various places that tests the kind of operation.
+ */
+ qry->commandType = CMD_SELECT;
+
+ /* set up a range table */
+ makeRangeTable(pstate, NULL, stmt->fromClause);
+
+ qry->uniqueFlag = stmt->unique;
+
+ qry->into = stmt->portalname;
+ qry->isPortal = TRUE;
+ qry->isBinary = stmt->binary; /* internal portal */
+
+ /* fix the target list */
+ qry->targetList = transformTargetList(pstate,
+ stmt->targetList,
+ FALSE, /*is insert */
+ FALSE /*not update*/);
+
+ /* fix where clause */
+ qry->qual = transformWhereClause(pstate,stmt->whereClause);
+
+ /* fix order clause */
+ qry->sortClause = transformSortClause(stmt->orderClause,
+ qry->targetList,
+ qry->uniqueFlag);
+ qry->rtable = pstate->p_rtable;
+
+ if (pstate->p_numAgg > 0)
+ finalizeAggregates(pstate, qry);
+
+ return (Query *)qry;
+}
+
+/*****************************************************************************
+ *
+ * Transform Exprs, Aggs, etc.
+ *
+ *****************************************************************************/
+
+/*
+ * transformExpr -
+ * analyze and transform expressions. Type checking and type casting is
+ * done here. The optimizer and the executor cannot handle the original
+ * (raw) expressions collected by the parse tree. Hence the transformation
+ * here.
+ */
+static Node *
+transformExpr(ParseState *pstate, Node *expr)
+{
+ Node *result;
+
+ if (expr==NULL)
+ return NULL;
+
+ switch(nodeTag(expr)) {
+ case T_Attr: {
+ Attr *att = (Attr *)expr;
+ Node *temp;
+
+ /* what if att.attrs == "*"?? */
+ temp = handleNestedDots(pstate, att, &pstate->p_last_resno);
+ if (att->indirection != NIL) {
+ List *idx = att->indirection;
+ while(idx!=NIL) {
+ A_Indices *ai = (A_Indices *)lfirst(idx);
+ Node *lexpr=NULL, *uexpr;
+ uexpr = transformExpr(pstate, ai->uidx); /* must exists */
+ if (exprType(uexpr) != INT4OID)
+ elog(WARN, "array index expressions must be int4's");
+ if (ai->lidx != NULL) {
+ lexpr = transformExpr(pstate, ai->lidx);
+ if (exprType(lexpr) != INT4OID)
+ elog(WARN, "array index expressions must be int4's");
+ }
+#if 0
+ pfree(ai->uidx);
+ if (ai->lidx!=NULL) pfree(ai->lidx);
+#endif
+ ai->lidx = lexpr;
+ ai->uidx = uexpr;
+ /* note we reuse the list of indices, make sure we don't free
+ them! Otherwise, make a new list here */
+ idx = lnext(idx);
+ }
+ result = (Node*)make_array_ref(temp, att->indirection);
+ }else {
+ result = temp;
+ }
+ break;
+ }
+ case T_A_Const: {
+ A_Const *con= (A_Const *)expr;
+ Value *val = &con->val;
+ if (con->typename != NULL) {
+ result = parser_typecast(val, con->typename, -1);
+ }else {
+ result = (Node *)make_const(val);
+ }
+ break;
+ }
+ case T_ParamNo: {
+ ParamNo *pno = (ParamNo *)expr;
+ Oid toid;
+ int paramno;
+ Param *param;
+
+ paramno = pno->number;
+ toid = param_type(paramno);
+ if (!OidIsValid(toid)) {
+ elog(WARN, "Parameter '$%d' is out of range",
+ paramno);
+ }
+ param = makeNode(Param);
+ param->paramkind = PARAM_NUM;
+ param->paramid = (AttrNumber) paramno;
+ param->paramname = "";
+ param->paramtype = (Oid)toid;
+ param->param_tlist = (List*) NULL;
+
+ result = (Node *)param;
+ break;
+ }
+ case T_A_Expr: {
+ A_Expr *a = (A_Expr *)expr;
+
+ switch(a->oper) {
+ case OP:
+ {
+ Node *lexpr = transformExpr(pstate, a->lexpr);
+ Node *rexpr = transformExpr(pstate, a->rexpr);
+ result = (Node *)make_op(a->opname, lexpr, rexpr);
+ }
+ break;
+ case ISNULL:
+ {
+ Node *lexpr = transformExpr(pstate, a->lexpr);
+ result = ParseFunc(pstate,
+ "NullValue", lcons(lexpr, NIL),
+ &pstate->p_last_resno);
+ }
+ break;
+ case NOTNULL:
+ {
+ Node *lexpr = transformExpr(pstate, a->lexpr);
+ result = ParseFunc(pstate,
+ "NonNullValue", lcons(lexpr, NIL),
+ &pstate->p_last_resno);
+ }
+ break;
+ case AND:
+ {
+ Expr *expr = makeNode(Expr);
+ Node *lexpr = transformExpr(pstate, a->lexpr);
+ Node *rexpr = transformExpr(pstate, a->rexpr);
+ if (exprType(lexpr) != BOOLOID)
+ elog(WARN,
+ "left-hand side of AND is type '%s', not bool",
+ tname(get_id_type(exprType(lexpr))));
+ if (exprType(rexpr) != BOOLOID)
+ elog(WARN,
+ "right-hand side of AND is type '%s', not bool",
+ tname(get_id_type(exprType(rexpr))));
+ expr->typeOid = BOOLOID;
+ expr->opType = AND_EXPR;
+ expr->args = makeList(lexpr, rexpr, -1);
+ result = (Node *)expr;
+ }
+ break;
+ case OR:
+ {
+ Expr *expr = makeNode(Expr);
+ Node *lexpr = transformExpr(pstate, a->lexpr);
+ Node *rexpr = transformExpr(pstate, a->rexpr);
+ if (exprType(lexpr) != BOOLOID)
+ elog(WARN,
+ "left-hand side of OR is type '%s', not bool",
+ tname(get_id_type(exprType(lexpr))));
+ if (exprType(rexpr) != BOOLOID)
+ elog(WARN,
+ "right-hand side of OR is type '%s', not bool",
+ tname(get_id_type(exprType(rexpr))));
+ expr->typeOid = BOOLOID;
+ expr->opType = OR_EXPR;
+ expr->args = makeList(lexpr, rexpr, -1);
+ result = (Node *)expr;
+ }
+ break;
+ case NOT:
+ {
+ Expr *expr = makeNode(Expr);
+ Node *rexpr = transformExpr(pstate, a->rexpr);
+ if (exprType(rexpr) != BOOLOID)
+ elog(WARN,
+ "argument to NOT is type '%s', not bool",
+ tname(get_id_type(exprType(rexpr))));
+ expr->typeOid = BOOLOID;
+ expr->opType = NOT_EXPR;
+ expr->args = makeList(rexpr, -1);
+ result = (Node *)expr;
+ }
+ break;
+ }
+ break;
+ }
+ case T_Ident: {
+ Ident *ident = (Ident*)expr;
+ bool isrel;
+ char *reln= ParseColumnName(pstate,ident->name, &isrel);
+
+ /* could be a column name or a relation_name */
+ if (reln==NULL) {
+ /*
+ * may be a relation_name
+ *
+ * ??? in fact, every ident left after transfromExpr() is called
+ * will be assumed to be a relation.
+ */
+ if (isrel) {
+ ident->isRel = TRUE;
+ result = (Node*)ident;
+ } else {
+ elog(WARN, "attribute \"%s\" not found", ident->name);
+ }
+ }else {
+ Attr *att = makeNode(Attr);
+ att->relname = reln;
+ att->attrs = lcons(makeString(ident->name), NIL);
+ /*
+ * a column name
+ */
+ result =
+ (Node*)handleNestedDots(pstate, att, &pstate->p_last_resno);
+ }
+ break;
+ }
+ case T_FuncCall: {
+ FuncCall *fn = (FuncCall *)expr;
+ List *args;
+
+ /* transform the list of arguments */
+ foreach(args, fn->args) {
+ lfirst(args) = transformExpr(pstate, (Node*)lfirst(args));
+ }
+ result = ParseFunc(pstate,
+ fn->funcname, fn->args, &pstate->p_last_resno);
+ break;
+ }
+ default:
+ /* should not reach here */
+ elog(WARN, "transformExpr: does not know how to transform %d\n",
+ nodeTag(expr));
+ break;
+ }
+
+ return result;
+}
+
+/*****************************************************************************
+ *
+ * From Clause
+ *
+ *****************************************************************************/
+
+/*
+ * parseFromClause -
+ * turns the table references specified in the from-clause into a
+ * range table. The range table may grow as we transform the expressions
+ * in the target list. (Note that this happens because in POSTQUEL, we
+ * allow references to relations not specified in the from-clause. We
+ * also allow that in our POST-SQL)
+ *
+ */
+static void
+parseFromClause(ParseState *pstate, List *frmList)
+{
+ List *fl= frmList;
+
+ while(fl!=NIL) {
+ RangeVar *r = lfirst(fl);
+ RelExpr *baserel = r->relExpr;
+ RangeTblEntry *ent;
+ char *relname = baserel->relname;
+ char *refname = r->name;
+
+ if (refname==NULL) {
+ refname = relname;
+ } else {
+ /*
+ * check whether refname exists already
+ */
+ if (RangeTablePosn(pstate->p_rtable, refname) != 0)
+ elog(WARN, "parser: range variable \"%s\" duplicated",
+ refname);
+ }
+
+ ent = makeRangeTableEntry(relname, baserel->inh,
+ baserel->timeRange, refname);
+ /*
+ * marks this entry to indicate it comes from the from clause. In
+ * SQL, the target list can only refer to range variables specified
+ * in the from clause but we follow the more powerful POSTQUEL
+ * semantics and automatically generate the range variable if not
+ * specified. However there are times we need to know whether the
+ * entries are legitimate.
+ *
+ * eg. select * from foo f where f.x = 1; will generate wrong answer
+ * if we expand * to foo.x.
+ */
+ ent->inFromCl = true;
+
+ pstate->p_rtable = lappend(pstate->p_rtable, ent);
+ fl= lnext(fl);
+ }
+}
+
+/*
+ * makeRangeTable -
+ * make a range table with the specified relation (optional) and the
+ * from-clause.
+ */
+static void
+makeRangeTable(ParseState *pstate, char *relname, List *frmList)
+{
+ int x;
+
+ parseFromClause(pstate, frmList);
+
+ if (relname == NULL)
+ return;
+
+ if (RangeTablePosn(pstate->p_rtable, relname) < 1) {
+ RangeTblEntry *ent;
+
+ ent = makeRangeTableEntry(relname, FALSE, NULL, relname);
+ pstate->p_rtable = lappend(pstate->p_rtable, ent);
+ }
+ x = RangeTablePosn(pstate->p_rtable, relname);
+ pstate->parser_current_rel = heap_openr(VarnoGetRelname(pstate,x));
+ if (pstate->parser_current_rel == NULL)
+ elog(WARN,"invalid relation name");
+}
+
+/*
+ * exprType -
+ * returns the Oid of the type of the expression. (Used for typechecking.)
+ */
+Oid
+exprType(Node *expr)
+{
+ Oid type;
+
+ switch(nodeTag(expr)) {
+ case T_Func:
+ type = ((Func*)expr)->functype;
+ break;
+ case T_Iter:
+ type = ((Iter*)expr)->itertype;
+ break;
+ case T_Var:
+ type = ((Var*)expr)->vartype;
+ break;
+ case T_Expr:
+ type = ((Expr*)expr)->typeOid;
+ break;
+ case T_Const:
+ type = ((Const*)expr)->consttype;
+ break;
+ case T_ArrayRef:
+ type = ((ArrayRef*)expr)->refelemtype;
+ break;
+ case T_Aggreg:
+ type = ((Aggreg*)expr)->aggtype;
+ break;
+ case T_Param:
+ type = ((Param*)expr)->paramtype;
+ break;
+ case T_Ident:
+ /* is this right? */
+ type = UNKNOWNOID;
+ break;
+ default:
+ elog(WARN, "exprType: don't know how to get type for %d node",
+ nodeTag(expr));
+ break;
+ }
+ return type;
+}
+
+/*
+ * expandAllTables -
+ * turns '*' (in the target list) into a list of attributes (of all
+ * relations in the range table)
+ */
+static List *
+expandAllTables(ParseState *pstate)
+{
+ List *target= NIL;
+ List *legit_rtable=NIL;
+ List *rt, *rtable;
+
+ rtable = pstate->p_rtable;
+ if (pstate->p_query_is_rule) {
+ /*
+ * skip first two entries, "*new*" and "*current*"
+ */
+ rtable = lnext(lnext(pstate->p_rtable));
+ }
+
+ /* this should not happen */
+ if (rtable==NULL)
+ elog(WARN, "cannot expand: null p_rtable");
+
+ /*
+ * go through the range table and make a list of range table entries
+ * which we will expand.
+ */
+ foreach(rt, rtable) {
+ RangeTblEntry *rte = lfirst(rt);
+
+ /*
+ * we only expand those specify in the from clause. (This will
+ * also prevent us from using the wrong table in inserts: eg. tenk2
+ * in "insert into tenk2 select * from tenk1;")
+ */
+ if (!rte->inFromCl)
+ continue;
+ legit_rtable = lappend(legit_rtable, rte);
+ }
+
+ foreach(rt, legit_rtable) {
+ RangeTblEntry *rte = lfirst(rt);
+ char *rt_name= rte->refname; /* use refname here so that we
+ refer to the right entry */
+ List *temp = target;
+
+ if(temp == NIL )
+ target = expandAll(pstate, rt_name, &pstate->p_last_resno);
+ else {
+ while (temp != NIL && lnext(temp) != NIL)
+ temp = lnext(temp);
+ lnext(temp) = expandAll(pstate, rt_name, &pstate->p_last_resno);
+ }
+ }
+ return target;
+}
+
+
+/*
+ * figureColname -
+ * if the name of the resulting column is not specified in the target
+ * list, we have to guess.
+ *
+ */
+static char *
+figureColname(Node *expr, Node *resval)
+{
+ switch (nodeTag(expr)) {
+ case T_Aggreg:
+ return (char*) /* XXX */
+ ((Aggreg *)expr)->aggname;
+ case T_Expr:
+ if (((Expr*)expr)->opType == FUNC_EXPR) {
+ if (nodeTag(resval)==T_FuncCall)
+ return ((FuncCall*)resval)->funcname;
+ }
+ break;
+ default:
+ break;
+ }
+
+ return "?column?";
+}
+
+/*****************************************************************************
+ *
+ * Target list
+ *
+ *****************************************************************************/
+
+/*
+ * makeTargetList -
+ * turn a list of column names and expressions (in the same order) into
+ * a target list (used exclusively for inserts)
+ */
+static List *
+makeTargetList(ParseState *pstate, List *cols, List *exprs)
+{
+ List *tlist, *tl=NULL;
+ if (cols != NIL) {
+ /* has to transform colElem too (opt_indirection can be exprs) */
+ while(cols!=NIL) {
+ ResTarget *res = makeNode(ResTarget);
+ Ident *id = lfirst(cols);
+ /* Id opt_indirection */
+ res->name = id->name;
+ res->indirection = id->indirection;
+ if (exprs == NIL) {
+ elog(WARN, "insert: number of expressions less than columns");
+ }else {
+ res->val = (Node *)lfirst(exprs);
+ }
+ if (tl==NIL) {
+ tlist = tl = lcons(res, NIL);
+ }else {
+ lnext(tl) = lcons(res,NIL);
+ tl = lnext(tl);
+ }
+ cols = lnext(cols);
+ exprs = lnext(exprs);
+ }
+ if (cols != NIL) {
+ elog(WARN, "insert: number of columns more than expressions");
+ }
+ }else {
+ bool has_star = false;
+
+ if (exprs==NIL)
+ return NIL;
+ if (IsA(lfirst(exprs),Attr)) {
+ Attr *att = lfirst(exprs);
+
+ if ((att->relname!=NULL && !strcmp(att->relname,"*")) ||
+ (att->attrs!=NIL && !strcmp(strVal(lfirst(att->attrs)),"*")))
+ has_star = true;
+ }
+ if (has_star) {
+ /*
+ * right now, these better be 'relname.*' or '*' (this can happen
+ * in eg. insert into tenk2 values (tenk1.*); or
+ * insert into tenk2 select * from tenk1;
+ */
+ while(exprs!=NIL) {
+ ResTarget *res = makeNode(ResTarget);
+ res->name = NULL;
+ res->indirection = NULL;
+ res->val = (Node *)lfirst(exprs);
+ if (tl==NIL) {
+ tlist = tl = lcons(res, NIL);
+ }else {
+ lnext(tl) = lcons(res,NIL);
+ tl = lnext(tl);
+ }
+ exprs = lnext(exprs);
+ }
+ } else {
+ Relation insertRel = pstate->parser_current_rel;
+ int numcol;
+ int i;
+ AttributeTupleForm *attr = insertRel->rd_att->attrs;
+
+ numcol = Min(length(exprs), insertRel->rd_rel->relnatts);
+ for(i=0; i < numcol; i++) {
+ ResTarget *res = makeNode(ResTarget);
+
+ res->name = palloc(NAMEDATALEN+1);
+ strncpy(res->name, attr[i]->attname.data, NAMEDATALEN);
+ res->name[NAMEDATALEN]='\0';
+ res->indirection = NULL;
+ res->val = (Node *)lfirst(exprs);
+ if (tl==NIL) {
+ tlist = tl = lcons(res, NIL);
+ }else {
+ lnext(tl) = lcons(res,NIL);
+ tl = lnext(tl);
+ }
+ exprs = lnext(exprs);
+ }
+ }
+ }
+ return tlist;
+}
+
+/*
+ * transformTargetList -
+ * turns a list of ResTarget's into a list of TargetEntry's
+ */
+static List *
+transformTargetList(ParseState *pstate,
+ List *targetlist,
+ bool isInsert,
+ bool isUpdate)
+{
+ List *p_target= NIL;
+ List *temp = NIL;
+
+ while(targetlist != NIL) {
+ ResTarget *res= (ResTarget *)lfirst(targetlist);
+ TargetEntry *tent = makeNode(TargetEntry);
+
+ switch(nodeTag(res->val)) {
+ case T_Ident: {
+ Node *expr;
+ Oid type_id;
+ int type_len;
+ char *identname;
+ char *resname;
+
+ identname = ((Ident*)res->val)->name;
+ expr = transformExpr(pstate, (Node*)res->val);
+ type_id = exprType(expr);
+ type_len = tlen(get_id_type(type_id));
+ resname = (res->name) ? res->name : identname;
+ tent->resdom = makeResdom((AttrNumber)pstate->p_last_resno++,
+ (Oid)type_id,
+ (Size)type_len,
+ resname,
+ (Index)0,
+ (Oid)0,
+ 0);
+
+ tent->expr = expr;
+ break;
+ }
+ case T_ParamNo:
+ case T_FuncCall:
+ case T_A_Const:
+ case T_A_Expr: {
+ Node *expr = transformExpr(pstate, (Node *)res->val);
+
+ if (isInsert && res->name==NULL)
+ elog(WARN, "Sorry, have to specify the column list");
+
+ /* note indirection has not been transformed */
+ if (isInsert && res->indirection!=NIL) {
+ /* this is an array assignment */
+ char *val;
+ char *str, *save_str;
+ List *elt;
+ int i = 0, ndims;
+ int lindx[MAXDIM], uindx[MAXDIM];
+ int resdomno;
+ Relation rd;
+ Value *constval;
+
+ if (exprType(expr) != UNKNOWNOID ||
+ !IsA(expr,Const))
+ elog(WARN, "yyparse: string constant expected");
+
+ val = (char *) textout((struct varlena *)
+ ((Const *)expr)->constvalue);
+ str = save_str = (char*)palloc(strlen(val) + MAXDIM * 25 + 2);
+ foreach(elt, res->indirection) {
+ A_Indices *aind = (A_Indices *)lfirst(elt);
+ aind->uidx = transformExpr(pstate, aind->uidx);
+ if (!IsA(aind->uidx,Const))
+ elog(WARN,
+ "Array Index for Append should be a constant");
+ uindx[i] = ((Const *)aind->uidx)->constvalue;
+ if (aind->lidx!=NULL) {
+ aind->lidx = transformExpr(pstate, aind->lidx);
+ if (!IsA(aind->lidx,Const))
+ elog(WARN,
+ "Array Index for Append should be a constant");
+ lindx[i] = ((Const*)aind->lidx)->constvalue;
+ }else {
+ lindx[i] = 1;
+ }
+ if (lindx[i] > uindx[i])
+ elog(WARN, "yyparse: lower index cannot be greater than upper index");
+ sprintf(str, "[%d:%d]", lindx[i], uindx[i]);
+ str += strlen(str);
+ i++;
+ }
+ sprintf(str, "=%s", val);
+ rd = pstate->parser_current_rel;
+ Assert(rd != NULL);
+ resdomno = varattno(rd, res->name);
+ ndims = att_attnelems(rd, resdomno);
+ if (i != ndims)
+ elog(WARN, "yyparse: array dimensions do not match");
+ constval = makeNode(Value);
+ constval->type = T_String;
+ constval->val.str = save_str;
+ tent = make_targetlist_expr(pstate, res->name,
+ (Node*)make_const(constval),
+ NULL,
+ (isInsert||isUpdate));
+ pfree(save_str);
+ } else {
+ char *colname= res->name;
+ /* this is not an array assignment */
+ if (colname==NULL) {
+ /* if you're wondering why this is here, look at
+ * the yacc grammar for why a name can be missing. -ay
+ */
+ colname = figureColname(expr, res->val);
+ }
+ if (res->indirection) {
+ List *ilist = res->indirection;
+ while (ilist!=NIL) {
+ A_Indices *ind = lfirst(ilist);
+ ind->lidx = transformExpr(pstate, ind->lidx);
+ ind->uidx = transformExpr(pstate, ind->uidx);
+ ilist = lnext(ilist);
+ }
+ }
+ tent = make_targetlist_expr(pstate, colname, expr,
+ res->indirection,
+ (isInsert||isUpdate));
+ }
+ break;
+ }
+ case T_Attr: {
+ Oid type_id;
+ int type_len;
+ Attr *att = (Attr *)res->val;
+ Node *result;
+ char *attrname;
+ char *resname;
+ Resdom *resnode;
+ List *attrs = att->attrs;
+
+
+ /*
+ * Target item is a single '*', expand all tables
+ * (eg. SELECT * FROM emp)
+ */
+ if (att->relname!=NULL && !strcmp(att->relname, "*")) {
+ if(lnext(targetlist)!=NULL)
+ elog(WARN, "cannot expand target list *, ...");
+ p_target = expandAllTables(pstate);
+
+ /*
+ * skip rest of while loop
+ */
+ targetlist = lnext(targetlist);
+ continue;
+ }
+
+ /*
+ * Target item is relation.*, expand the table
+ * (eg. SELECT emp.*, dname FROM emp, dept)
+ */
+ attrname = strVal(lfirst(att->attrs));
+ if (att->attrs!=NIL && !strcmp(attrname,"*")) {
+ /* temp is the target list we're building in the while
+ * loop. Make sure we fix it after appending more nodes.
+ */
+ if (temp == NIL) {
+ p_target = temp =
+ expandAll(pstate, att->relname, &pstate->p_last_resno);
+ } else {
+ lnext(temp) =
+ expandAll(pstate, att->relname, &pstate->p_last_resno);
+ }
+ while(lnext(temp)!=NIL)
+ temp = lnext(temp); /* make sure we point to the last
+ target entry */
+ /*
+ * skip the rest of the while loop
+ */
+ targetlist = lnext(targetlist);
+ continue;
+ }
+
+
+ /*
+ * Target item is fully specified: ie. relation.attribute
+ */
+ result = handleNestedDots(pstate, att, &pstate->p_last_resno);
+ if (att->indirection != NIL) {
+ List *ilist = att->indirection;
+ while (ilist!=NIL) {
+ A_Indices *ind = lfirst(ilist);
+ ind->lidx = transformExpr(pstate, ind->lidx);
+ ind->uidx = transformExpr(pstate, ind->uidx);
+ ilist = lnext(ilist);
+ }
+ result = (Node*)make_array_ref(result, att->indirection);
+ }
+ type_id = exprType(result);
+ type_len = tlen(get_id_type(type_id));
+ while(lnext(attrs)!=NIL)
+ attrs=lnext(attrs);
+ resname = (res->name) ? res->name : strVal(lfirst(attrs));
+ resnode = makeResdom((AttrNumber)pstate->p_last_resno++,
+ (Oid)type_id,
+ (Size)type_len,
+ resname,
+ (Index)0,
+ (Oid)0,
+ 0);
+ tent->resdom = resnode;
+ tent->expr = result;
+ break;
+ }
+ default:
+ /* internal error */
+ elog(WARN,
+ "internal error: do not know how to transform targetlist");
+ break;
+ }
+
+ if (p_target==NIL) {
+ p_target = temp = lcons(tent, NIL);
+ }else {
+ lnext(temp) = lcons(tent, NIL);
+ temp = lnext(temp);
+ }
+ targetlist = lnext(targetlist);
+ }
+ return p_target;
+}
+
+
+/*
+ * make_targetlist_expr -
+ * make a TargetEntry
+ *
+ * arrayRef is a list of transformed A_Indices
+ */
+static TargetEntry *
+make_targetlist_expr(ParseState *pstate,
+ char *name,
+ Node *expr,
+ List *arrayRef,
+ bool ResdomNoIsAttrNo)
+{
+ int type_id, type_len, attrtype, attrlen;
+ int resdomno;
+ Relation rd;
+ bool attrisset;
+ TargetEntry *tent;
+ Resdom *resnode;
+
+ if (expr == NULL)
+ elog(WARN, "make_targetlist_expr: invalid use of NULL expression");
+
+ type_id = exprType(expr);
+ type_len = tlen(get_id_type(type_id));
+
+ /* I have no idea what the following does! */
+ if (ResdomNoIsAttrNo) {
+ /*
+ * append or replace query --
+ * append, replace work only on one relation,
+ * so multiple occurence of same resdomno is bogus
+ */
+ rd = pstate->parser_current_rel;
+ Assert(rd != NULL);
+ resdomno = varattno(rd,name);
+ attrisset = varisset(rd,name);
+ attrtype = att_typeid(rd,resdomno);
+ if ((arrayRef != NIL) && (lfirst(arrayRef) == NIL))
+ attrtype = GetArrayElementType(attrtype);
+ if (attrtype==BPCHAROID || attrtype==VARCHAROID) {
+ attrlen = rd->rd_att->attrs[resdomno-1]->attlen;
+ } else {
+ attrlen = tlen(get_id_type(attrtype));
+ }
+#if 0
+ if(Input_is_string && Typecast_ok){
+ Datum val;
+ if (type_id == typeid(type("unknown"))){
+ val = (Datum)textout((struct varlena *)
+ ((Const)lnext(expr))->constvalue);
+ }else{
+ val = ((Const)lnext(expr))->constvalue;
+ }
+ if (attrisset) {
+ lnext(expr) = makeConst(attrtype,
+ attrlen,
+ val,
+ false,
+ true,
+ true /* is set */);
+ } else {
+ lnext(expr) =
+ makeConst(attrtype,
+ attrlen,
+ (Datum)fmgr(typeid_get_retinfunc(attrtype),
+ val,get_typelem(attrtype),-1),
+ false,
+ true /* Maybe correct-- 80% chance */,
+ false /* is not a set */);
+ }
+ } else if((Typecast_ok) && (attrtype != type_id)){
+ lnext(expr) =
+ parser_typecast2(expr, get_id_type((long)attrtype));
+ } else
+ if (attrtype != type_id) {
+ if ((attrtype == INT2OID) && (type_id == INT4OID))
+ lfirst(expr) = lispInteger (INT2OID);
+ else if ((attrtype == FLOAT4OID) && (type_id == FLOAT8OID))
+ lfirst(expr) = lispInteger (FLOAT4OID);
+ else
+ elog(WARN, "unequal type in tlist : %s \n",
+ name));
+ }
+
+ Input_is_string = false;
+ Input_is_integer = false;
+ Typecast_ok = true;
+#endif
+ if (attrtype != type_id) {
+ if (IsA(expr,Const)) {
+ /* try to cast the constant */
+ expr = (Node*)parser_typecast2(expr,
+ type_id,
+ get_id_type((long)attrtype),
+ attrlen);
+ } else {
+ /* currently, we can't handle casting of expressions */
+ elog(WARN, "parser: attribute '%s' is of type '%.*s' but expression is of type '%.*s'",
+ name,
+ NAMEDATALEN, get_id_typname(attrtype),
+ NAMEDATALEN, get_id_typname(type_id));
+ }
+ }
+
+ if (intMember(resdomno, pstate->p_target_resnos)) {
+ elog(WARN,"two or more occurrences of same attr");
+ } else {
+ pstate->p_target_resnos = lconsi(resdomno,
+ pstate->p_target_resnos);
+ }
+ if (arrayRef != NIL) {
+ Expr *target_expr;
+ Attr *att = makeNode(Attr);
+ List *ar = arrayRef;
+ List *upperIndexpr = NIL;
+ List *lowerIndexpr = NIL;
+
+ att->relname = pstrdup(RelationGetRelationName(rd)->data);
+ att->attrs = lcons(makeString(name), NIL);
+ target_expr = (Expr*)handleNestedDots(pstate, att,
+ &pstate->p_last_resno);
+ while(ar!=NIL) {
+ A_Indices *ind = lfirst(ar);
+ if (lowerIndexpr) {
+ /* XXX assume all lowerIndexpr is non-null in
+ * this case
+ */
+ lowerIndexpr = lappend(lowerIndexpr, ind->lidx);
+ }
+ upperIndexpr = lappend(upperIndexpr, ind->uidx);
+ ar = lnext(ar);
+ }
+
+ expr = (Node*)make_array_set(target_expr,
+ upperIndexpr,
+ lowerIndexpr,
+ (Expr*)expr);
+ attrtype = att_typeid(rd,resdomno);
+ attrlen = tlen(get_id_type(attrtype));
+ }
+ } else {
+ resdomno = pstate->p_last_resno++;
+ attrtype = type_id;
+ attrlen = type_len;
+ }
+ tent = makeNode(TargetEntry);
+
+ resnode = makeResdom((AttrNumber)resdomno,
+ (Oid) attrtype,
+ (Size) attrlen,
+ name,
+ (Index)0,
+ (Oid)0,
+ 0);
+
+ tent->resdom = resnode;
+ tent->expr = expr;
+
+ return tent;
+ }
+
+
+/*****************************************************************************
+ *
+ * Where Clause
+ *
+ *****************************************************************************/
+
+/*
+ * transformWhereClause -
+ * transforms the qualification and make sure it is of type Boolean
+ *
+ */
+static Node *
+transformWhereClause(ParseState *pstate, Node *a_expr)
+{
+ Node *qual;
+
+ if (a_expr == NULL)
+ return (Node *)NULL; /* no qualifiers */
+
+ qual = transformExpr(pstate, a_expr);
+ if (exprType(qual) != BOOLOID) {
+ elog(WARN,
+ "where clause must return type bool, not %s",
+ tname(get_id_type(exprType(qual))));
+ }
+ return qual;
+}
+
+/*****************************************************************************
+ *
+ * Sort Clause
+ *
+ *****************************************************************************/
+
+/*
+ * find_tl_elt -
+ * returns the Resdom in the target list matching the specified varname
+ *
+ */
+static Resdom *
+find_tl_elt(char *varname, List *tlist)
+{
+ List *i;
+
+ foreach(i, tlist) {
+ TargetEntry *target = (TargetEntry *)lfirst(i);
+ Resdom *resnode = target->resdom;
+ char *resname = resnode->resname;
+
+ if (!strcmp(resname, varname))
+ return (resnode);
+ }
+ return ((Resdom *)NULL);
+}
+
+static Oid
+any_ordering_op(int restype)
+{
+ Operator order_op;
+ Oid order_opid;
+
+ order_op = oper("<",restype,restype);
+ order_opid = (Oid)oprid(order_op);
+
+ return order_opid;
+}
+
+/*
+ * transformGroupClause -
+ * transform an Group By clause
+ *
+ */
+static List *
+transformGroupClause(ParseState *pstate, List *grouplist)
+{
+ List *glist = NIL, *gl;
+
+ while (grouplist != NIL) {
+ GroupClause *grpcl = makeNode(GroupClause);
+ Var *groupAttr = (Var*)transformExpr(pstate, (Node*)lfirst(grouplist));
+
+ if (nodeTag(groupAttr) != T_Var) {
+ elog(WARN, "parser: can only specify attribute in group by");
+ }
+ grpcl->grpAttr = groupAttr;
+ grpcl->grpOpoid = any_ordering_op(groupAttr->vartype);
+ if (glist == NIL) {
+ gl = glist = lcons(grpcl, NIL);
+ } else {
+ lnext(gl) = lcons(grpcl, NIL);
+ gl = lnext(gl);
+ }
+ grouplist = lnext(grouplist);
+ }
+
+ return glist;
+}
+
+/*
+ * transformSortClause -
+ * transform an Order By clause
+ *
+ */
+static List *
+transformSortClause(List *orderlist, List *targetlist,
+ char* uniqueFlag)
+{
+ List *sortlist = NIL;
+ List *s, *i;
+
+ while(orderlist != NIL) {
+ SortBy *sortby = lfirst(orderlist);
+ SortClause *sortcl = makeNode(SortClause);
+ Resdom *resdom;
+
+ resdom = find_tl_elt(sortby->name, targetlist);
+ if (resdom == NULL)
+ elog(WARN,"The field being sorted by must appear in the target list");
+
+ sortcl->resdom = resdom;
+ sortcl->opoid = oprid(oper(sortby->useOp,
+ resdom->restype,
+ resdom->restype));
+ if (sortlist == NIL) {
+ s = sortlist = lcons(sortcl, NIL);
+ }else {
+ lnext(s) = lcons(sortcl, NIL);
+ s = lnext(s);
+ }
+ orderlist = lnext(orderlist);
+ }
+
+ if (uniqueFlag) {
+ if (uniqueFlag[0] == '*') {
+ /* concatenate all elements from target list
+ that are not already in the sortby list */
+ foreach (i,targetlist) {
+ TargetEntry *tlelt = (TargetEntry *)lfirst(i);
+
+ s = sortlist;
+ while(s != NIL) {
+ SortClause *sortcl = lfirst(s);
+ if (sortcl->resdom==tlelt->resdom)
+ break;
+ s = lnext(s);
+ }
+ if (s == NIL) {
+ /* not a member of the sortclauses yet */
+ SortClause *sortcl = makeNode(SortClause);
+
+ sortcl->resdom = tlelt->resdom;
+ sortcl->opoid = any_ordering_op(tlelt->resdom->restype);
+
+ sortlist = lappend(sortlist, sortcl);
+ }
+ }
+ }
+ else {
+ TargetEntry *tlelt;
+ char* uniqueAttrName = uniqueFlag;
+
+ /* only create sort clause with the specified unique attribute */
+ foreach (i, targetlist) {
+ tlelt = (TargetEntry*)lfirst(i);
+ if (strcmp(tlelt->resdom->resname, uniqueAttrName) == 0)
+ break;
+ }
+ if (i == NIL) {
+ elog(WARN, "The field specified in the UNIQUE ON clause is not in the targetlist");
+ }
+ s = sortlist;
+ foreach (s, sortlist) {
+ SortClause *sortcl = lfirst(s);
+ if (sortcl->resdom == tlelt->resdom)
+ break;
+ }
+ if (s == NIL) {
+ /* not a member of the sortclauses yet */
+ SortClause *sortcl = makeNode(SortClause);
+
+ sortcl->resdom = tlelt->resdom;
+ sortcl->opoid = any_ordering_op(tlelt->resdom->restype);
+
+ sortlist = lappend(sortlist, sortcl);
+ }
+ }
+
+ }
+
+ return sortlist;
+}
+
+/*
+ ** HandleNestedDots --
+ ** Given a nested dot expression (i.e. (relation func ... attr), build up
+ ** a tree with of Iter and Func nodes.
+ */
+static Node*
+handleNestedDots(ParseState *pstate, Attr *attr, int *curr_resno)
+{
+ List *mutator_iter;
+ Node *retval = NULL;
+
+ if (attr->paramNo != NULL) {
+ Param *param = (Param *)transformExpr(pstate, (Node*)attr->paramNo);
+
+ retval =
+ ParseFunc(pstate, strVal(lfirst(attr->attrs)),
+ lcons(param, NIL),
+ curr_resno);
+ } else {
+ Ident *ident = makeNode(Ident);
+
+ ident->name = attr->relname;
+ ident->isRel = TRUE;
+ retval =
+ ParseFunc(pstate, strVal(lfirst(attr->attrs)),
+ lcons(ident, NIL),
+ curr_resno);
+ }
+
+ foreach (mutator_iter, lnext(attr->attrs)) {
+ retval = ParseFunc(pstate,strVal(lfirst(mutator_iter)),
+ lcons(retval, NIL),
+ curr_resno);
+ }
+
+ return(retval);
+}
+
+/*
+ ** make_arguments --
+ ** Given the number and types of arguments to a function, and the
+ ** actual arguments and argument types, do the necessary typecasting.
+ */
+static void
+make_arguments(int nargs,
+ List *fargs,
+ Oid *input_typeids,
+ Oid *function_typeids)
+{
+ /*
+ * there are two ways an input typeid can differ from a function typeid :
+ * either the input type inherits the function type, so no typecasting is
+ * necessary, or the input type can be typecast into the function type.
+ * right now, we only typecast unknowns, and that is all we check for.
+ */
+
+ List *current_fargs;
+ int i;
+
+ for (i=0, current_fargs = fargs;
+ i
+ i++, current_fargs = lnext(current_fargs)) {
+
+ if (input_typeids[i] == UNKNOWNOID && function_typeids[i] != 0) {
+ lfirst(current_fargs) =
+ parser_typecast2(lfirst(current_fargs),
+ input_typeids[i],
+ get_id_type(function_typeids[i]),
+ -1);
+ }
+ }
+}
+
+/*
+ ** setup_tlist --
+ ** Build a tlist that says which attribute to project to.
+ ** This routine is called by ParseFunc() to set up a target list
+ ** on a tuple parameter or return value. Due to a bug in 4.0,
+ ** it's not possible to refer to system attributes in this case.
+ */
+static List *
+setup_tlist(char *attname, Oid relid)
+{
+ TargetEntry *tle;
+ Resdom *resnode;
+ Var *varnode;
+ Oid typeid;
+ int attno;
+
+ attno = get_attnum(relid, attname);
+ if (attno < 0)
+ elog(WARN, "cannot reference attribute %s of tuple params/return values for functions", attname);
+
+ typeid = find_atttype(relid, attname);
+ resnode = makeResdom(1,
+ typeid,
+ tlen(get_id_type(typeid)),
+ get_attname(relid, attno),
+ 0,
+ (Oid)0,
+ 0);
+ varnode = makeVar(-1, attno, typeid, -1, attno);
+
+ tle = makeNode(TargetEntry);
+ tle->resdom = resnode;
+ tle->expr = (Node*)varnode;
+ return (lcons(tle, NIL));
+}
+
+/*
+ ** setup_base_tlist --
+ ** Build a tlist that extracts a base type from the tuple
+ ** returned by the executor.
+ */
+static List *
+setup_base_tlist(Oid typeid)
+{
+ TargetEntry *tle;
+ Resdom *resnode;
+ Var *varnode;
+
+ resnode = makeResdom(1,
+ typeid,
+ tlen(get_id_type(typeid)),
+ "",
+ 0,
+ (Oid)0,
+ 0);
+ varnode = makeVar(-1, 1, typeid, -1, 1);
+ tle = makeNode(TargetEntry);
+ tle->resdom = resnode;
+ tle->expr = (Node*)varnode;
+
+ return (lcons(tle, NIL));
+}
+
+/*
+ * ParseComplexProjection -
+ * handles function calls with a single argument that is of complex type.
+ * This routine returns NULL if it can't handle the projection (eg. sets).
+ */
+static Node *
+ParseComplexProjection(ParseState *pstate,
+ char *funcname,
+ Node *first_arg,
+ bool *attisset)
+{
+ Oid argtype;
+ Oid argrelid;
+ Name relname;
+ Relation rd;
+ Oid relid;
+ int attnum;
+
+ switch (nodeTag(first_arg)) {
+ case T_Iter:
+ {
+ Func *func;
+ Iter *iter;
+
+ iter = (Iter*)first_arg;
+ func = (Func *)((Expr*)iter->iterexpr)->oper;
+ argtype = funcid_get_rettype(func->funcid);
+ argrelid = typeid_get_relid(argtype);
+ if (argrelid &&
+ ((attnum = get_attnum(argrelid, funcname))
+ != InvalidAttrNumber)) {
+
+ /* the argument is a function returning a tuple, so funcname
+ may be a projection */
+
+ /* add a tlist to the func node and return the Iter */
+ rd = heap_openr(tname(get_id_type(argtype)));
+ if (RelationIsValid(rd)) {
+ relid = RelationGetRelationId(rd);
+ relname = RelationGetRelationName(rd);
+ heap_close(rd);
+ }
+ if (RelationIsValid(rd)) {
+ func->func_tlist =
+ setup_tlist(funcname, argrelid);
+ iter->itertype = att_typeid(rd,attnum);
+ return ((Node*)iter);
+ }else {
+ elog(WARN,
+ "Function %s has bad returntype %d",
+ funcname, argtype);
+ }
+ }else {
+ /* drop through */
+ ;
+ }
+ break;
+ }
+ case T_Var:
+ {
+ /*
+ * The argument is a set, so this is either a projection
+ * or a function call on this set.
+ */
+ *attisset = true;
+ break;
+ }
+ case T_Expr:
+ {
+ Expr *expr = (Expr*)first_arg;
+ Func *funcnode;
+
+ if (expr->opType != FUNC_EXPR)
+ break;
+
+ funcnode= (Func *) expr->oper;
+ argtype = funcid_get_rettype(funcnode->funcid);
+ argrelid = typeid_get_relid(argtype);
+ /*
+ * the argument is a function returning a tuple, so funcname
+ * may be a projection
+ */
+ if (argrelid &&
+ (attnum = get_attnum(argrelid, funcname))
+ != InvalidAttrNumber) {
+
+ /* add a tlist to the func node */
+ rd = heap_openr(tname(get_id_type(argtype)));
+ if (RelationIsValid(rd)) {
+ relid = RelationGetRelationId(rd);
+ relname = RelationGetRelationName(rd);
+ heap_close(rd);
+ }
+ if (RelationIsValid(rd)) {
+ Expr *newexpr;
+
+ funcnode->func_tlist =
+ setup_tlist(funcname, argrelid);
+ funcnode->functype = att_typeid(rd,attnum);
+
+ newexpr = makeNode(Expr);
+ newexpr->typeOid = funcnode->functype;
+ newexpr->opType = FUNC_EXPR;
+ newexpr->oper = (Node *)funcnode;
+ newexpr->args = lcons(first_arg, NIL);
+
+ return ((Node*)newexpr);
+ }
+
+ }
+
+ elog(WARN, "Function %s has bad returntype %d",
+ funcname, argtype);
+ break;
+ }
+ case T_Param:
+ {
+ Param *param = (Param*)first_arg;
+ /*
+ * If the Param is a complex type, this could be a projection
+ */
+ rd = heap_openr(tname(get_id_type(param->paramtype)));
+ if (RelationIsValid(rd)) {
+ relid = RelationGetRelationId(rd);
+ relname = RelationGetRelationName(rd);
+ heap_close(rd);
+ }
+ if (RelationIsValid(rd) &&
+ (attnum = get_attnum(relid, funcname))
+ != InvalidAttrNumber) {
+
+ param->paramtype = att_typeid(rd, attnum);
+ param->param_tlist = setup_tlist(funcname, relid);
+ return ((Node*)param);
+ }
+ break;
+ }
+ default:
+ break;
+ }
+
+ return NULL;
+}
+
+static Node *
+ParseFunc(ParseState *pstate, char *funcname, List *fargs, int *curr_resno)
+{
+ Oid rettype = (Oid)0;
+ Oid argrelid;
+ Oid funcid = (Oid)0;
+ List *i = NIL;
+ Node *first_arg= NULL;
+ char *relname, *oldname;
+ Relation rd;
+ Oid relid;
+ int nargs;
+ Func *funcnode;
+ Oid oid_array[8];
+ Oid *true_oid_array;
+ Node *retval;
+ bool retset;
+ bool exists;
+ bool attisset = false;
+ Oid toid;
+ Expr *expr;
+
+ if (fargs) {
+ first_arg = lfirst(fargs);
+ if (first_arg == NULL)
+ elog (WARN,"function %s does not allow NULL input",funcname);
+ }
+
+ /*
+ ** check for projection methods: if function takes one argument, and
+ ** that argument is a relation, param, or PQ function returning a complex
+ ** type, then the function could be a projection.
+ */
+ if (length(fargs) == 1) {
+ if (nodeTag(first_arg)==T_Ident && ((Ident*)first_arg)->isRel) {
+ Ident *ident = (Ident*)first_arg;
+
+ /*
+ * first arg is a relation. This could be a projection.
+ */
+ relname = ident->name;
+ if (RangeTablePosn(pstate->p_rtable, relname)== 0) {
+ RangeTblEntry *ent;
+
+ ent =
+ makeRangeTableEntry(relname,
+ FALSE, NULL, relname);
+ pstate->p_rtable = lappend(pstate->p_rtable, ent);
+ }
+ oldname = relname;
+ relname = VarnoGetRelname(pstate,
+ RangeTablePosn(pstate->p_rtable,
+ oldname));
+ rd = heap_openr(relname);
+ relid = RelationGetRelationId(rd);
+ heap_close(rd);
+ /* If the attr isn't a set, just make a var for it. If
+ * it is a set, treat it like a function and drop through.
+ */
+ if (get_attnum(relid, funcname) != InvalidAttrNumber) {
+ int dummyTypeId;
+
+ return
+ ((Node*)make_var(pstate,
+ oldname,
+ funcname,
+ &dummyTypeId));
+ } else {
+ /* drop through - attr is a set */
+ ;
+ }
+ } else if (ISCOMPLEX(exprType(first_arg))) {
+ /*
+ * Attempt to handle projection of a complex argument. If
+ * ParseComplexProjection can't handle the projection, we
+ * have to keep going.
+ */
+ retval = ParseComplexProjection(pstate,
+ funcname,
+ first_arg,
+ &attisset);
+ if (attisset) {
+ toid = exprType(first_arg);
+ rd = heap_openr(tname(get_id_type(toid)));
+ if (RelationIsValid(rd)) {
+ relname = RelationGetRelationName(rd)->data;
+ heap_close(rd);
+ } else
+ elog(WARN,
+ "Type %s is not a relation type",
+ tname(get_id_type(toid)));
+ argrelid = typeid_get_relid(toid);
+ /* A projection contains either an attribute name or the
+ * word "all".
+ */
+ if ((get_attnum(argrelid, funcname) == InvalidAttrNumber)
+ && strcmp(funcname, "all")) {
+ elog(WARN, "Functions on sets are not yet supported");
+ }
+ }
+
+ if (retval)
+ return retval;
+ } else {
+ /*
+ * Parsing aggregates.
+ */
+ Oid basetype;
+ /* the aggregate count is a special case,
+ ignore its base type. Treat it as zero */
+ if (strcmp(funcname, "count") == 0)
+ basetype = 0;
+ else
+ basetype = exprType(lfirst(fargs));
+ if (SearchSysCacheTuple(AGGNAME,
+ PointerGetDatum(funcname),
+ ObjectIdGetDatum(basetype),
+ 0, 0)) {
+ Aggreg *aggreg = ParseAgg(funcname, basetype, lfirst(fargs));
+
+ AddAggToParseState(pstate, aggreg);
+ return (Node*)aggreg;
+ }
+ }
+ }
+
+
+ /*
+ ** If we dropped through to here it's really a function (or a set, which
+ ** is implemented as a function.)
+ ** extract arg type info and transform relation name arguments into
+ ** varnodes of the appropriate form.
+ */
+ memset(&oid_array[0], 0, 8 * sizeof(Oid));
+
+ nargs=0;
+ foreach ( i , fargs ) {
+ int vnum;
+ Node *pair = lfirst(i);
+
+ if (nodeTag(pair)==T_Ident && ((Ident*)pair)->isRel) {
+ /*
+ * a relation
+ */
+ relname = ((Ident*)pair)->name;
+
+ /* get the range table entry for the var node */
+ vnum = RangeTablePosn(pstate->p_rtable, relname);
+ if (vnum == 0) {
+ pstate->p_rtable =
+ lappend(pstate->p_rtable ,
+ makeRangeTableEntry(relname, FALSE,
+ NULL, relname));
+ vnum = RangeTablePosn (pstate->p_rtable, relname);
+ }
+
+ /*
+ * We have to do this because the relname in the pair
+ * may have been a range table variable name, rather
+ * than a real relation name.
+ */
+ relname = VarnoGetRelname(pstate, vnum);
+
+ rd = heap_openr(relname);
+ relid = RelationGetRelationId(rd);
+ heap_close(rd);
+
+ /*
+ * for func(relname), the param to the function
+ * is the tuple under consideration. we build a special
+ * VarNode to reflect this -- it has varno set to the
+ * correct range table entry, but has varattno == 0 to
+ * signal that the whole tuple is the argument.
+ */
+ toid = typeid(type(relname));
+ /* replace it in the arg list */
+ lfirst(fargs) =
+ makeVar(vnum, 0, toid, vnum, 0);
+ }else if (!attisset) { /* set functions don't have parameters */
+
+ /* any functiona args which are typed "unknown", but aren't
+ constants, we don't know what to do with, because we
+ can't cast them - jolly*/
+ if (exprType(pair) == UNKNOWNOID &&
+ !IsA(pair, Const))
+ {
+ elog(WARN, "ParseFunc: no function named %s that takes in an unknown type as argument #%d", funcname, nargs);
+ }
+ else
+ toid = exprType(pair);
+ }
+
+ oid_array[nargs++] = toid;
+ }
+
+ /*
+ * func_get_detail looks up the function in the catalogs, does
+ * disambiguation for polymorphic functions, handles inheritance,
+ * and returns the funcid and type and set or singleton status of
+ * the function's return value. it also returns the true argument
+ * types to the function. if func_get_detail returns true,
+ * the function exists. otherwise, there was an error.
+ */
+ if (attisset) { /* we know all of these fields already */
+ /* We create a funcnode with a placeholder function SetEval.
+ * SetEval() never actually gets executed. When the function
+ * evaluation routines see it, they use the funcid projected
+ * out from the relation as the actual function to call.
+ * Example: retrieve (emp.mgr.name)
+ * The plan for this will scan the emp relation, projecting
+ * out the mgr attribute, which is a funcid. This function
+ * is then called (instead of SetEval) and "name" is projected
+ * from its result.
+ */
+ funcid = SetEvalRegProcedure;
+ rettype = toid;
+ retset = true;
+ true_oid_array = oid_array;
+ exists = true;
+ } else {
+ exists = func_get_detail(funcname, nargs, oid_array, &funcid,
+ &rettype, &retset, &true_oid_array);
+ }
+
+ if (!exists)
+ elog(WARN, "no such attribute or function %s", funcname);
+
+ /* got it */
+ funcnode = makeNode(Func);
+ funcnode->funcid = funcid;
+ funcnode->functype = rettype;
+ funcnode->funcisindex = false;
+ funcnode->funcsize = 0;
+ funcnode->func_fcache = NULL;
+ funcnode->func_tlist = NIL;
+ funcnode->func_planlist = NIL;
+
+ /* perform the necessary typecasting */
+ make_arguments(nargs, fargs, oid_array, true_oid_array);
+
+ /*
+ * for functions returning base types, we want to project out the
+ * return value. set up a target list to do that. the executor
+ * will ignore these for c functions, and do the right thing for
+ * postquel functions.
+ */
+
+ if (typeid_get_relid(rettype) == InvalidOid)
+ funcnode->func_tlist = setup_base_tlist(rettype);
+
+ /* For sets, we want to make a targetlist to project out this
+ * attribute of the set tuples.
+ */
+ if (attisset) {
+ if (!strcmp(funcname, "all")) {
+ funcnode->func_tlist =
+ expandAll(pstate, (char*)relname, curr_resno);
+ } else {
+ funcnode->func_tlist = setup_tlist(funcname,argrelid);
+ rettype = find_atttype(argrelid, funcname);
+ }
+ }
+
+ expr = makeNode(Expr);
+ expr->typeOid = rettype;
+ expr->opType = FUNC_EXPR;
+ expr->oper = (Node *)funcnode;
+ expr->args = fargs;
+ retval = (Node*)expr;
+
+ /*
+ * if the function returns a set of values, then we need to iterate
+ * over all the returned values in the executor, so we stick an
+ * iter node here. if it returns a singleton, then we don't need
+ * the iter node.
+ */
+
+ if (retset) {
+ Iter *iter = makeNode(Iter);
+ iter->itertype = rettype;
+ iter->iterexpr = retval;
+ retval = (Node*)iter;
+ }
+
+ return(retval);
+}
+
+/*
+ * returns (relname) if found, NIL if not a column
+ */
+static char*
+ParseColumnName(ParseState *pstate, char *name, bool *isRelName)
+{
+ List *et;
+ Relation rd;
+ List *rtable;
+
+ /*
+ * see if it is a relation name. If so, leave it as it is
+ */
+ if (RangeTablePosn(pstate->p_rtable, name)!=0) {
+ *isRelName = TRUE;
+ return NULL;
+ }
+
+ if (pstate->p_query_is_rule) {
+ rtable = lnext(lnext(pstate->p_rtable));
+ } else {
+ rtable = pstate->p_rtable;
+ }
+ /*
+ * search each relation in the FROM list and see if we have a match
+ */
+ foreach(et, rtable) {
+ RangeTblEntry *rte = lfirst(et);
+ char *relname= rte->relname;
+ char *refname= rte->refname;
+ Oid relid;
+
+ rd= heap_openr(relname);
+ relid = RelationGetRelationId(rd);
+ heap_close(rd);
+ if (get_attnum(relid, name) != InvalidAttrNumber) {
+ /* found */
+ *isRelName = FALSE;
+ return refname;
+ }
+
+ }
+
+ /* attribute not found */
+ *isRelName = FALSE;
+ return NULL;
+}
+
+
+/*****************************************************************************
+ *
+ *****************************************************************************/
+
+/*
+ * AddAggToParseState -
+ * add the aggregate to the list of unique aggregates in pstate.
+ *
+ * SIDE EFFECT: aggno in target list entry will be modified
+ */
+static void
+AddAggToParseState(ParseState *pstate, Aggreg *aggreg)
+{
+ List *ag;
+ int i;
+
+ /*
+ * see if we have the aggregate already (we only need to record
+ * the aggregate once)
+ */
+ i = 0;
+ foreach(ag, pstate->p_aggs) {
+ Aggreg *a = lfirst(ag);
+
+ if (!strcmp(a->aggname, aggreg->aggname) &&
+ equal(a->target, aggreg->target)) {
+
+ /* fill in the aggno and we're done */
+ aggreg->aggno = i;
+ return;
+ }
+ i++;
+ }
+
+ /* not found, new aggregate */
+ aggreg->aggno = i;
+ pstate->p_numAgg++;
+ pstate->p_aggs = lappend(pstate->p_aggs, aggreg);
+ return;
+}
+
+/*
+ * finalizeAggregates -
+ * fill in qry_aggs from pstate. Also checks to make sure that aggregates
+ * are used in the proper place.
+ */
+static void
+finalizeAggregates(ParseState *pstate, Query *qry)
+{
+ List *l;
+ int i;
+
+ parseCheckAggregates(pstate, qry);
+
+ qry->qry_numAgg = pstate->p_numAgg;
+ qry->qry_aggs =
+ (Aggreg **)palloc(sizeof(Aggreg *) * qry->qry_numAgg);
+ i = 0;
+ foreach(l, pstate->p_aggs) {
+ qry->qry_aggs[i++] = (Aggreg*)lfirst(l);
+ }
+}
+
+/*
+ * contain_agg_clause--
+ * Recursively find aggreg nodes from a clause.
+ *
+ * Returns true if any aggregate found.
+ */
+static bool
+contain_agg_clause(Node *clause)
+{
+ if (clause==NULL)
+ return FALSE;
+ else if (IsA(clause,Aggreg))
+ return TRUE;
+ else if (IsA(clause,Iter))
+ return contain_agg_clause(((Iter*)clause)->iterexpr);
+ else if (single_node(clause))
+ return FALSE;
+ else if (or_clause(clause)) {
+ List *temp;
+
+ foreach (temp, ((Expr*)clause)->args) {
+ if (contain_agg_clause(lfirst(temp)))
+ return TRUE;
+ }
+ return FALSE;
+ } else if (is_funcclause (clause)) {
+ List *temp;
+
+ foreach(temp, ((Expr *)clause)->args) {
+ if (contain_agg_clause(lfirst(temp)))
+ return TRUE;
+ }
+ return FALSE;
+ } else if (IsA(clause,ArrayRef)) {
+ List *temp;
+
+ foreach(temp, ((ArrayRef*)clause)->refupperindexpr) {
+ if (contain_agg_clause(lfirst(temp)))
+ return TRUE;
+ }
+ foreach(temp, ((ArrayRef*)clause)->reflowerindexpr) {
+ if (contain_agg_clause(lfirst(temp)))
+ return TRUE;
+ }
+ if (contain_agg_clause(((ArrayRef*)clause)->refexpr))
+ return TRUE;
+ if (contain_agg_clause(((ArrayRef*)clause)->refassgnexpr))
+ return TRUE;
+ return FALSE;
+ } else if (not_clause(clause))
+ return contain_agg_clause((Node*)get_notclausearg((Expr*)clause));
+ else if (is_opclause(clause))
+ return (contain_agg_clause((Node*)get_leftop((Expr*)clause)) ||
+ contain_agg_clause((Node*)get_rightop((Expr*)clause)));
+
+ return FALSE;
+}
+
+/*
+ * exprIsAggOrGroupCol -
+ * returns true if the expression does not contain non-group columns.
+ */
+static bool
+exprIsAggOrGroupCol(Node *expr, List *groupClause)
+{
+ if (expr==NULL)
+ return TRUE;
+ else if (IsA(expr,Const))
+ return TRUE;
+ else if (IsA(expr,Var)) {
+ List *gl;
+ Var *var = (Var*)expr;
+ /*
+ * only group columns are legal
+ */
+ foreach (gl, groupClause) {
+ GroupClause *grpcl = lfirst(gl);
+ if ((grpcl->grpAttr->varno == var->varno) &&
+ (grpcl->grpAttr->varattno == var->varattno))
+ return TRUE;
+ }
+ return FALSE;
+ } else if (IsA(expr,Aggreg))
+ /* aggregates can take group column or non-group column as argument,
+ no further check necessary. */
+ return TRUE;
+ else if (IsA(expr,Expr)) {
+ List *temp;
+
+ foreach (temp, ((Expr*)expr)->args) {
+ if (!exprIsAggOrGroupCol(lfirst(temp),groupClause))
+ return FALSE;
+ }
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+/*
+ * parseCheckAggregates -
+ * this should really be done earlier but the current grammar
+ * cannot differentiate functions from aggregates. So we have do check
+ * here when the target list and the qualifications are finalized.
+ */
+static void
+parseCheckAggregates(ParseState *pstate, Query *qry)
+{
+ List *tl;
+ Assert(pstate->p_numAgg > 0);
+
+ /*
+ * aggregates never appear in WHERE clauses. (we have to check where
+ * clause first because if there is an aggregate, the check for
+ * non-group column in target list may fail.)
+ */
+ if (contain_agg_clause(qry->qual))
+ elog(WARN, "parser: aggregates not allowed in WHERE clause");
+
+ /*
+ * the target list can only contain aggregates, group columns and
+ * functions thereof.
+ */
+ foreach (tl, qry->targetList) {
+ TargetEntry *tle = lfirst(tl);
+ if (!exprIsAggOrGroupCol(tle->expr, qry->groupClause))
+ elog(WARN,
+ "parser: illegal use of aggregates or non-group column in target list");
+ }
+
+ /*
+ * the expression specified in the HAVING clause has the same restriction
+ * as those in the target list.
+ */
+ if (!exprIsAggOrGroupCol(qry->havingQual, qry->groupClause))
+ elog(WARN,
+ "parser: illegal use of aggregates or non-group column in HAVING clause");
+
+ return;
+}
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * catalog_utils.c--
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/parser/Attic/catalog_utils.c,v 1.1.1.1 1996/07/09 06:21:40 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "lib/dllist.h"
+#include "utils/datum.h"
+
+#include "utils/builtins.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "fmgr.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/parsenodes.h"
+#include "utils/syscache.h"
+#include "catalog/catname.h"
+
+#include "catalog_utils.h"
+#include "catalog/pg_inherits.h"
+#include "catalog/pg_type.h"
+#include "catalog/indexing.h"
+#include "catalog/catname.h"
+
+#include "access/skey.h"
+#include "access/relscan.h"
+#include "access/tupdesc.h"
+#include "access/htup.h"
+#include "access/heapam.h"
+#include "access/genam.h"
+#include "access/itup.h"
+#include "access/tupmacs.h"
+
+#include "storage/buf.h"
+#include "storage/bufmgr.h"
+#include "utils/lsyscache.h"
+#include "storage/lmgr.h"
+
+struct {
+ char *field;
+ int code;
+} special_attr[] = {
+ { "ctid", SelfItemPointerAttributeNumber },
+ { "oid", ObjectIdAttributeNumber },
+ { "xmin", MinTransactionIdAttributeNumber },
+ { "cmin", MinCommandIdAttributeNumber },
+ { "xmax", MaxTransactionIdAttributeNumber },
+ { "cmax", MaxCommandIdAttributeNumber },
+ { "chain", ChainItemPointerAttributeNumber },
+ { "anchor", AnchorItemPointerAttributeNumber },
+ { "tmin", MinAbsoluteTimeAttributeNumber },
+ { "tmax", MaxAbsoluteTimeAttributeNumber },
+ { "vtype", VersionTypeAttributeNumber }
+};
+
+#define SPECIALS (sizeof(special_attr)/sizeof(*special_attr))
+
+static char *attnum_type[SPECIALS] = {
+ "tid",
+ "oid",
+ "xid",
+ "cid",
+ "xid",
+ "cid",
+ "tid",
+ "tid",
+ "abstime",
+ "abstime",
+ "char"
+ };
+
+#define MAXFARGS 8 /* max # args to a c or postquel function */
+
+static Oid **argtype_inherit();
+static Oid **genxprod();
+
+static int findsupers(Oid relid, Oid **supervec);
+/*
+ * This structure is used to explore the inheritance hierarchy above
+ * nodes in the type tree in order to disambiguate among polymorphic
+ * functions.
+ */
+
+typedef struct _InhPaths {
+ int nsupers; /* number of superclasses */
+ Oid self; /* this class */
+ Oid *supervec; /* vector of superclasses */
+} InhPaths;
+
+/*
+ * This structure holds a list of possible functions or operators that
+ * agree with the known name and argument types of the function/operator.
+ */
+typedef struct _CandidateList {
+ Oid *args;
+ struct _CandidateList *next;
+} *CandidateList;
+
+/* check to see if a type id is valid,
+ * returns true if it is. By using this call before calling
+ * get_id_type or get_id_typname, more meaningful error messages
+ * can be produced because the caller typically has more context of
+ * what's going on - jolly
+ */
+bool
+check_typeid(long id)
+{
+ return (SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(id),
+ 0,0,0) != NULL);
+}
+
+
+/* return a Type structure, given an typid */
+Type
+get_id_type(long id)
+{
+ HeapTuple tup;
+
+ if (!(tup = SearchSysCacheTuple(TYPOID, ObjectIdGetDatum(id),
+ 0,0,0))) {
+ elog ( WARN, "type id lookup of %d failed", id);
+ return(NULL);
+ }
+ return((Type) tup);
+}
+
+/* return a type name, given a typeid */
+char*
+get_id_typname(long id)
+{
+ HeapTuple tup;
+ TypeTupleForm typetuple;
+
+ if (!(tup = SearchSysCacheTuple(TYPOID, ObjectIdGetDatum(id),
+ 0,0,0))) {
+ elog ( WARN, "type id lookup of %d failed", id);
+ return(NULL);
+ }
+ typetuple = (TypeTupleForm)GETSTRUCT(tup);
+ return (typetuple->typname).data;
+}
+
+/* return a Type structure, given type name */
+Type
+type(char *s)
+{
+ HeapTuple tup;
+
+ if (s == NULL) {
+ elog ( WARN , "type(): Null type" );
+ }
+
+ if (!(tup = SearchSysCacheTuple(TYPNAME, PointerGetDatum(s), 0,0,0))) {
+ elog (WARN , "type name lookup of %s failed", s);
+ }
+ return((Type) tup);
+}
+
+/* given attribute id, return type of that attribute */
+/* XXX Special case for pseudo-attributes is a hack */
+Oid
+att_typeid(Relation rd, int attid)
+{
+
+ if (attid < 0) {
+ return(typeid(type(attnum_type[-attid-1])));
+ }
+ /* -1 because varattno (where attid comes from) returns one
+ more than index */
+ return(rd->rd_att->attrs[attid-1]->atttypid);
+}
+
+
+int
+att_attnelems(Relation rd, int attid)
+{
+ return(rd->rd_att->attrs[attid-1]->attnelems);
+}
+
+/* given type, return the type OID */
+Oid
+typeid(Type tp)
+{
+ if (tp == NULL) {
+ elog ( WARN , "typeid() called with NULL type struct");
+ }
+ return(tp->t_oid);
+}
+
+/* given type (as type struct), return the length of type */
+int16
+tlen(Type t)
+{
+ TypeTupleForm typ;
+
+ typ = (TypeTupleForm)GETSTRUCT(t);
+ return(typ->typlen);
+}
+
+/* given type (as type struct), return the value of its 'byval' attribute.*/
+bool
+tbyval(Type t)
+{
+ TypeTupleForm typ;
+
+ typ = (TypeTupleForm)GETSTRUCT(t);
+ return(typ->typbyval);
+}
+
+/* given type (as type struct), return the name of type */
+char*
+tname(Type t)
+{
+ TypeTupleForm typ;
+
+ typ = (TypeTupleForm)GETSTRUCT(t);
+ return (typ->typname).data;
+}
+
+/* given type (as type struct), return wether type is passed by value */
+int
+tbyvalue(Type t)
+{
+ TypeTupleForm typ;
+
+ typ = (TypeTupleForm) GETSTRUCT(t);
+ return(typ->typbyval);
+}
+
+/* given a type, return its typetype ('c' for 'c'atalog types) */
+char
+typetypetype(Type t)
+{
+ TypeTupleForm typ;
+
+ typ = (TypeTupleForm) GETSTRUCT(t);
+ return(typ->typtype);
+}
+
+/* given operator, return the operator OID */
+Oid
+oprid(Operator op)
+{
+ return(op->t_oid);
+}
+
+/*
+ * given opname, leftTypeId and rightTypeId,
+ * find all possible (arg1, arg2) pairs for which an operator named
+ * opname exists, such that leftTypeId can be coerced to arg1 and
+ * rightTypeId can be coerced to arg2
+ */
+static int
+binary_oper_get_candidates(char *opname,
+ int leftTypeId,
+ int rightTypeId,
+ CandidateList *candidates)
+{
+ CandidateList current_candidate;
+ Relation pg_operator_desc;
+ HeapScanDesc pg_operator_scan;
+ HeapTuple tup;
+ OperatorTupleForm oper;
+ Buffer buffer;
+ int nkeys;
+ int ncandidates = 0;
+ ScanKeyData opKey[3];
+
+ *candidates = NULL;
+
+ ScanKeyEntryInitialize(&opKey[0], 0,
+ Anum_pg_operator_oprname,
+ NameEqualRegProcedure,
+ NameGetDatum(opname));
+
+ ScanKeyEntryInitialize(&opKey[1], 0,
+ Anum_pg_operator_oprkind,
+ CharacterEqualRegProcedure,
+ CharGetDatum('b'));
+
+
+ if (leftTypeId == UNKNOWNOID) {
+ if (rightTypeId == UNKNOWNOID) {
+ nkeys = 2;
+ } else {
+ nkeys = 3;
+
+ ScanKeyEntryInitialize(&opKey[2], 0,
+ Anum_pg_operator_oprright,
+ ObjectIdEqualRegProcedure,
+ ObjectIdGetDatum(rightTypeId));
+ }
+ } else if (rightTypeId == UNKNOWNOID) {
+ nkeys = 3;
+
+ ScanKeyEntryInitialize(&opKey[2], 0,
+ Anum_pg_operator_oprleft,
+ ObjectIdEqualRegProcedure,
+ ObjectIdGetDatum(leftTypeId));
+ } else {
+ /* currently only "unknown" can be coerced */
+ return 0;
+ }
+
+ pg_operator_desc = heap_openr(OperatorRelationName);
+ pg_operator_scan = heap_beginscan(pg_operator_desc,
+ 0,
+ SelfTimeQual,
+ nkeys,
+ opKey);
+
+ do {
+ tup = heap_getnext(pg_operator_scan, 0, &buffer);
+ if (HeapTupleIsValid(tup)) {
+ current_candidate = (CandidateList)palloc(sizeof(struct _CandidateList));
+ current_candidate->args = (Oid *)palloc(2 * sizeof(Oid));
+
+ oper = (OperatorTupleForm)GETSTRUCT(tup);
+ current_candidate->args[0] = oper->oprleft;
+ current_candidate->args[1] = oper->oprright;
+ current_candidate->next = *candidates;
+ *candidates = current_candidate;
+ ncandidates++;
+ ReleaseBuffer(buffer);
+ }
+ } while(HeapTupleIsValid(tup));
+
+ heap_endscan(pg_operator_scan);
+ heap_close(pg_operator_desc);
+
+ return ncandidates;
+}
+
+/*
+ * equivalentOpersAfterPromotion -
+ * checks if a list of candidate operators obtained from
+ * binary_oper_get_candidates() contain equivalent operators. If
+ * this routine is called, we have more than 1 candidate and need to
+ * decided whether to pick one of them. This routine returns true if
+ * the all the candidates operate on the same data types after
+ * promotion (int2, int4, float4 -> float8).
+ */
+static bool
+equivalentOpersAfterPromotion(CandidateList candidates)
+{
+ CandidateList result;
+ CandidateList promotedCandidates = NULL;
+ int leftarg, rightarg;
+
+ for (result = candidates; result != NULL; result = result->next) {
+ CandidateList c;
+ c = (CandidateList)palloc(sizeof(*c));
+ c->args = (Oid *)palloc(2 * sizeof(Oid));
+ switch (result->args[0]) {
+ case FLOAT4OID:
+ case INT4OID:
+ case INT2OID:
+ c->args[0] = FLOAT8OID;
+ break;
+ default:
+ c->args[0] = result->args[0];
+ break;
+ }
+ switch (result->args[1]) {
+ case FLOAT4OID:
+ case INT4OID:
+ case INT2OID:
+ c->args[1] = FLOAT8OID;
+ break;
+ default:
+ c->args[1] = result->args[1];
+ break;
+ }
+ c->next = promotedCandidates;
+ promotedCandidates = c;
+ }
+
+ /* if we get called, we have more than 1 candidates so we can do the
+ following safely */
+ leftarg = promotedCandidates->args[0];
+ rightarg = promotedCandidates->args[1];
+
+ for (result=promotedCandidates->next; result!=NULL; result=result->next) {
+ if (result->args[0]!=leftarg || result->args[1]!=rightarg)
+ /*
+ * this list contains operators that operate on different
+ * data types even after promotion. Hence we can't decide on
+ * which one to pick. The user must do explicit type casting.
+ */
+ return FALSE;
+ }
+
+ /* all the candidates are equivalent in the following sense: they operate
+ on equivalent data types and picking any one of them is as good. */
+ return TRUE;
+}
+
+
+/*
+ * given a choice of argument type pairs for a binary operator,
+ * try to choose a default pair
+ */
+static CandidateList
+binary_oper_select_candidate(int arg1,
+ int arg2,
+ CandidateList candidates)
+{
+ CandidateList result;
+
+ /*
+ * if both are "unknown", there is no way to select a candidate
+ *
+ * current wisdom holds that the default operator should be one
+ * in which both operands have the same type (there will only
+ * be one such operator)
+ *
+ * 7.27.93 - I have decided not to do this; it's too hard to
+ * justify, and it's easy enough to typecast explicitly -avi
+ * [the rest of this routine were commented out since then -ay]
+ */
+
+ if (arg1 == UNKNOWNOID && arg2 == UNKNOWNOID)
+ return (NULL);
+
+ /*
+ * 6/23/95 - I don't complete agree with avi. In particular, casting
+ * floats is a pain for users. Whatever the rationale behind not doing
+ * this is, I need the following special case to work.
+ *
+ * In the WHERE clause of a query, if a float is specified without
+ * quotes, we treat it as float8. I added the float48* operators so
+ * that we can operate on float4 and float8. But now we have more
+ * than one matching operator if the right arg is unknown (eg. float
+ * specified with quotes). This break some stuff in the regression
+ * test where there are floats in quotes not properly casted. Below
+ * is the solution. In addition to requiring the operator operates
+ * on the same type for both operands [as in the code Avi originally
+ * commented out], we also require that the operators be equivalent
+ * in some sense. (see equivalentOpersAfterPromotion for details.)
+ * - ay 6/95
+ */
+ if (!equivalentOpersAfterPromotion(candidates))
+ return NULL;
+
+ /* if we get here, any one will do but we're more picky and require
+ both operands be the same. */
+ for (result = candidates; result != NULL; result = result->next) {
+ if (result->args[0] == result->args[1])
+ return result;
+ }
+
+ return (NULL);
+}
+
+/* Given operator, types of arg1, and arg2, return oper struct */
+/* arg1, arg2 --typeids */
+Operator
+oper(char *op, int arg1, int arg2)
+{
+ HeapTuple tup;
+ CandidateList candidates;
+ int ncandidates;
+
+ if (!(tup = SearchSysCacheTuple(OPRNAME,
+ PointerGetDatum(op),
+ ObjectIdGetDatum(arg1),
+ ObjectIdGetDatum(arg2),
+ Int8GetDatum('b')))) {
+ ncandidates = binary_oper_get_candidates(op, arg1, arg2, &candidates);
+ if (ncandidates == 0) {
+ /*
+ * no operators of the desired types found
+ */
+ op_error(op, arg1, arg2);
+ return(NULL);
+ } else if (ncandidates == 1) {
+ /*
+ * exactly one operator of the desired types found
+ */
+ tup = SearchSysCacheTuple(OPRNAME,
+ PointerGetDatum(op),
+ ObjectIdGetDatum(candidates->args[0]),
+ ObjectIdGetDatum(candidates->args[1]),
+ Int8GetDatum('b'));
+ Assert(HeapTupleIsValid(tup));
+ } else {
+ /*
+ * multiple operators of the desired types found
+ */
+ candidates = binary_oper_select_candidate(arg1, arg2, candidates);
+ if (candidates != NULL) {
+ /* we chose one of them */
+ tup = SearchSysCacheTuple(OPRNAME,
+ PointerGetDatum(op),
+ ObjectIdGetDatum(candidates->args[0]),
+ ObjectIdGetDatum(candidates->args[1]),
+ Int8GetDatum('b'));
+ Assert(HeapTupleIsValid(tup));
+ } else {
+ Type tp1, tp2;
+
+ /* we chose none of them */
+ tp1 = get_id_type(arg1);
+ tp2 = get_id_type(arg2);
+ elog(NOTICE, "there is more than one operator %s for types", op);
+ elog(NOTICE, "%s and %s. You will have to retype this query",
+ tname(tp1), tname(tp2));
+ elog(WARN, "using an explicit cast");
+
+ return(NULL);
+ }
+ }
+ }
+ return((Operator) tup);
+}
+
+/*
+ * given opname and typeId, find all possible types for which
+ * a right/left unary operator named opname exists,
+ * such that typeId can be coerced to it
+ */
+static int
+unary_oper_get_candidates(char *op,
+ int typeId,
+ CandidateList *candidates,
+ char rightleft)
+{
+ CandidateList current_candidate;
+ Relation pg_operator_desc;
+ HeapScanDesc pg_operator_scan;
+ HeapTuple tup;
+ OperatorTupleForm oper;
+ Buffer buffer;
+ int ncandidates = 0;
+
+ static ScanKeyData opKey[2] = {
+ { 0, Anum_pg_operator_oprname, NameEqualRegProcedure },
+ { 0, Anum_pg_operator_oprkind, CharacterEqualRegProcedure } };
+
+ *candidates = NULL;
+
+ fmgr_info(NameEqualRegProcedure, (func_ptr *) &opKey[0].sk_func,
+ &opKey[0].sk_nargs);
+ opKey[0].sk_argument = NameGetDatum(op);
+ fmgr_info(CharacterEqualRegProcedure, (func_ptr *) &opKey[1].sk_func,
+ &opKey[1].sk_nargs);
+ opKey[1].sk_argument = CharGetDatum(rightleft);
+
+ /* currently, only "unknown" can be coerced */
+ if (typeId != UNKNOWNOID) {
+ return 0;
+ }
+
+ pg_operator_desc = heap_openr(OperatorRelationName);
+ pg_operator_scan = heap_beginscan(pg_operator_desc,
+ 0,
+ SelfTimeQual,
+ 2,
+ opKey);
+
+ do {
+ tup = heap_getnext(pg_operator_scan, 0, &buffer);
+ if (HeapTupleIsValid(tup)) {
+ current_candidate = (CandidateList)palloc(sizeof(struct _CandidateList));
+ current_candidate->args = (Oid *)palloc(sizeof(Oid));
+
+ oper = (OperatorTupleForm)GETSTRUCT(tup);
+ if (rightleft == 'r')
+ current_candidate->args[0] = oper->oprleft;
+ else
+ current_candidate->args[0] = oper->oprright;
+ current_candidate->next = *candidates;
+ *candidates = current_candidate;
+ ncandidates++;
+ ReleaseBuffer(buffer);
+ }
+ } while(HeapTupleIsValid(tup));
+
+ heap_endscan(pg_operator_scan);
+ heap_close(pg_operator_desc);
+
+ return ncandidates;
+}
+
+/* Given unary right-side operator (operator on right), return oper struct */
+/* arg-- type id */
+Operator
+right_oper(char *op, int arg)
+{
+ HeapTuple tup;
+ CandidateList candidates;
+ int ncandidates;
+
+ /*
+ if (!OpCache) {
+ init_op_cache();
+ }
+ */
+ if (!(tup = SearchSysCacheTuple(OPRNAME,
+ PointerGetDatum(op),
+ ObjectIdGetDatum(arg),
+ ObjectIdGetDatum(InvalidOid),
+ Int8GetDatum('r')))) {
+ ncandidates = unary_oper_get_candidates(op, arg, &candidates, 'r');
+ if (ncandidates == 0) {
+ elog ( WARN ,
+ "Can't find right op: %s for type %d", op, arg );
+ return(NULL);
+ }
+ else if (ncandidates == 1) {
+ tup = SearchSysCacheTuple(OPRNAME,
+ PointerGetDatum(op),
+ ObjectIdGetDatum(candidates->args[0]),
+ ObjectIdGetDatum(InvalidOid),
+ Int8GetDatum('r'));
+ Assert(HeapTupleIsValid(tup));
+ }
+ else {
+ elog(NOTICE, "there is more than one right operator %s", op);
+ elog(NOTICE, "you will have to retype this query");
+ elog(WARN, "using an explicit cast");
+ return(NULL);
+ }
+ }
+ return((Operator) tup);
+}
+
+/* Given unary left-side operator (operator on left), return oper struct */
+/* arg--type id */
+Operator
+left_oper(char *op, int arg)
+{
+ HeapTuple tup;
+ CandidateList candidates;
+ int ncandidates;
+
+ /*
+ if (!OpCache) {
+ init_op_cache();
+ }
+ */
+ if (!(tup = SearchSysCacheTuple(OPRNAME,
+ PointerGetDatum(op),
+ ObjectIdGetDatum(InvalidOid),
+ ObjectIdGetDatum(arg),
+ Int8GetDatum('l')))) {
+ ncandidates = unary_oper_get_candidates(op, arg, &candidates, 'l');
+ if (ncandidates == 0) {
+ elog ( WARN ,
+ "Can't find left op: %s for type %d", op, arg );
+ return(NULL);
+ }
+ else if (ncandidates == 1) {
+ tup = SearchSysCacheTuple(OPRNAME,
+ PointerGetDatum(op),
+ ObjectIdGetDatum(InvalidOid),
+ ObjectIdGetDatum(candidates->args[0]),
+ Int8GetDatum('l'));
+ Assert(HeapTupleIsValid(tup));
+ }
+ else {
+ elog(NOTICE, "there is more than one left operator %s", op);
+ elog(NOTICE, "you will have to retype this query");
+ elog(WARN, "using an explicit cast");
+ return(NULL);
+ }
+ }
+ return((Operator) tup);
+}
+
+/* given range variable, return id of variable */
+
+int
+varattno(Relation rd, char *a)
+{
+ int i;
+
+ for (i = 0; i < rd->rd_rel->relnatts; i++) {
+ if (!namestrcmp(&(rd->rd_att->attrs[i]->attname), a)) {
+ return(i+1);
+ }
+ }
+ for (i = 0; i < SPECIALS; i++) {
+ if (!strcmp(special_attr[i].field, a)) {
+ return(special_attr[i].code);
+ }
+ }
+
+ elog(WARN,"Relation %s does not have attribute %s\n",
+ RelationGetRelationName(rd), a );
+ return(-1);
+}
+
+/* Given range variable, return whether attribute of this name
+ * is a set.
+ * NOTE the ASSUMPTION here that no system attributes are, or ever
+ * will be, sets.
+ */
+bool
+varisset(Relation rd, char *name)
+{
+ int i;
+
+ /* First check if this is a system attribute */
+ for (i = 0; i < SPECIALS; i++) {
+ if (! strcmp(special_attr[i].field, name)) {
+ return(false); /* no sys attr is a set */
+ }
+ }
+ return (get_attisset(rd->rd_id, name));
+}
+
+/* given range variable, return id of variable */
+int
+nf_varattno(Relation rd, char *a)
+{
+ int i;
+
+ for (i = 0; i < rd->rd_rel->relnatts; i++) {
+ if (!namestrcmp(&(rd->rd_att->attrs[i]->attname), a)) {
+ return(i+1);
+ }
+ }
+ for (i = 0; i < SPECIALS; i++) {
+ if (!strcmp(special_attr[i].field, a)) {
+ return(special_attr[i].code);
+ }
+ }
+ return InvalidAttrNumber;
+}
+
+/*-------------
+ * given an attribute number and a relation, return its relation name
+ */
+char*
+getAttrName(Relation rd, int attrno)
+{
+ char *name;
+ int i;
+
+ if (attrno<0) {
+ for (i = 0; i < SPECIALS; i++) {
+ if (special_attr[i].code == attrno) {
+ name = special_attr[i].field;
+ return(name);
+ }
+ }
+ elog(WARN, "Illegal attr no %d for relation %s\n",
+ attrno, RelationGetRelationName(rd));
+ } else if (attrno >=1 && attrno<= RelationGetNumberOfAttributes(rd)) {
+ name = (rd->rd_att->attrs[attrno-1]->attname).data;
+ return(name);
+ } else {
+ elog(WARN, "Illegal attr no %d for relation %s\n",
+ attrno, RelationGetRelationName(rd));
+ }
+
+ /*
+ * Shouldn't get here, but we want lint to be happy...
+ */
+
+ return(NULL);
+}
+
+/* Given a typename and value, returns the ascii form of the value */
+
+char *
+outstr(char *typename, /* Name of type of value */
+ char *value) /* Could be of any type */
+{
+ TypeTupleForm tp;
+ Oid op;
+
+ tp = (TypeTupleForm ) GETSTRUCT(type(typename));
+ op = tp->typoutput;
+ return((char *) fmgr(op, value));
+}
+
+/* Given a Type and a string, return the internal form of that string */
+char *
+instr2(Type tp, char *string, int typlen)
+{
+ return(instr1((TypeTupleForm ) GETSTRUCT(tp), string, typlen));
+}
+
+/* Given a type structure and a string, returns the internal form of
+ that string */
+char *
+instr1(TypeTupleForm tp, char *string, int typlen)
+{
+ Oid op;
+ Oid typelem;
+
+ op = tp->typinput;
+ typelem = tp->typelem; /* XXX - used for array_in */
+ /* typlen is for bpcharin() and varcharin() */
+ return((char *) fmgr(op, string, typelem, typlen));
+}
+
+/* Given the attribute type of an array return the arrtribute type of
+ an element of the array */
+
+Oid
+GetArrayElementType(Oid typearray)
+{
+ HeapTuple type_tuple;
+ TypeTupleForm type_struct_array;
+
+ type_tuple = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(typearray),
+ 0,0,0);
+
+ if (!HeapTupleIsValid(type_tuple))
+ elog(WARN, "GetArrayElementType: Cache lookup failed for type %d\n",
+ typearray);
+
+ /* get the array type struct from the type tuple */
+ type_struct_array = (TypeTupleForm) GETSTRUCT(type_tuple);
+
+ if (type_struct_array->typelem == InvalidOid) {
+ elog(WARN, "GetArrayElementType: type %s is not an array",
+ (Name)&(type_struct_array->typname.data[0]));
+ }
+
+ return(type_struct_array->typelem);
+}
+
+Oid
+funcid_get_rettype(Oid funcid)
+{
+ HeapTuple func_tuple = NULL;
+ Oid funcrettype = (Oid)0;
+
+ func_tuple = SearchSysCacheTuple(PROOID, ObjectIdGetDatum(funcid),
+ 0,0,0);
+
+ if ( !HeapTupleIsValid ( func_tuple ))
+ elog (WARN, "function %d does not exist", funcid);
+
+ funcrettype = (Oid)
+ ((Form_pg_proc)GETSTRUCT(func_tuple))->prorettype ;
+
+ return (funcrettype);
+}
+
+/*
+ * get a list of all argument type vectors for which a function named
+ * funcname taking nargs arguments exists
+ */
+static CandidateList
+func_get_candidates(char *funcname, int nargs)
+{
+ Relation heapRelation;
+ Relation idesc;
+ ScanKeyData skey;
+ HeapTuple tuple;
+ IndexScanDesc sd;
+ RetrieveIndexResult indexRes;
+ Buffer buffer;
+ Form_pg_proc pgProcP;
+ bool bufferUsed = FALSE;
+ CandidateList candidates = NULL;
+ CandidateList current_candidate;
+ int i;
+
+ heapRelation = heap_openr(ProcedureRelationName);
+ ScanKeyEntryInitialize(&skey,
+ (bits16)0x0,
+ (AttrNumber)1,
+ (RegProcedure)NameEqualRegProcedure,
+ (Datum)funcname);
+
+ idesc = index_openr(ProcedureNameIndex);
+
+ sd = index_beginscan(idesc, false, 1, &skey);
+
+ do {
+ tuple = (HeapTuple)NULL;
+ if (bufferUsed) {
+ ReleaseBuffer(buffer);
+ bufferUsed = FALSE;
+ }
+
+ indexRes = index_getnext(sd, ForwardScanDirection);
+ if (indexRes) {
+ ItemPointer iptr;
+
+ iptr = &indexRes->heap_iptr;
+ tuple = heap_fetch(heapRelation, NowTimeQual, iptr, &buffer);
+ pfree(indexRes);
+ if (HeapTupleIsValid(tuple)) {
+ pgProcP = (Form_pg_proc)GETSTRUCT(tuple);
+ bufferUsed = TRUE;
+ if (pgProcP->pronargs == nargs) {
+ current_candidate = (CandidateList)
+ palloc(sizeof(struct _CandidateList));
+ current_candidate->args = (Oid *)
+ palloc(8 * sizeof(Oid));
+ memset(current_candidate->args, 0, 8 * sizeof(Oid));
+ for (i=0; i
+ current_candidate->args[i] =
+ pgProcP->proargtypes[i];
+ }
+
+ current_candidate->next = candidates;
+ candidates = current_candidate;
+ }
+ }
+ }
+ } while (indexRes);
+
+ index_endscan(sd);
+ index_close(idesc);
+ heap_close(heapRelation);
+
+ return candidates;
+}
+
+/*
+ * can input_typeids be coerced to func_typeids?
+ */
+static bool
+can_coerce(int nargs, Oid *input_typeids, Oid *func_typeids)
+{
+ int i;
+ Type tp;
+
+ /*
+ * right now, we only coerce "unknown", and we cannot coerce it to a
+ * relation type
+ */
+ for (i=0; i
+ if (input_typeids[i] != func_typeids[i]) {
+ if (input_typeids[i] != UNKNOWNOID || func_typeids[i] == 0)
+ return false;
+
+ tp = get_id_type(input_typeids[i]);
+ if (typetypetype(tp) == 'c' )
+ return false;
+ }
+ }
+
+ return true;
+}
+
+/*
+ * given a list of possible typeid arrays to a function and an array of
+ * input typeids, produce a shortlist of those function typeid arrays
+ * that match the input typeids (either exactly or by coercion), and
+ * return the number of such arrays
+ */
+static int
+match_argtypes(int nargs,
+ Oid *input_typeids,
+ CandidateList function_typeids,
+ CandidateList *candidates) /* return value */
+{
+ CandidateList current_candidate;
+ CandidateList matching_candidate;
+ Oid *current_typeids;
+ int ncandidates = 0;
+
+ *candidates = NULL;
+
+ for (current_candidate = function_typeids;
+ current_candidate != NULL;
+ current_candidate = current_candidate->next) {
+ current_typeids = current_candidate->args;
+ if (can_coerce(nargs, input_typeids, current_typeids)) {
+ matching_candidate = (CandidateList)
+ palloc(sizeof(struct _CandidateList));
+ matching_candidate->args = current_typeids;
+ matching_candidate->next = *candidates;
+ *candidates = matching_candidate;
+ ncandidates++;
+ }
+ }
+
+ return ncandidates;
+}
+
+/*
+ * given the input argtype array and more than one candidate
+ * for the function argtype array, attempt to resolve the conflict.
+ * returns the selected argtype array if the conflict can be resolved,
+ * otherwise returns NULL
+ */
+static Oid *
+func_select_candidate(int nargs,
+ Oid *input_typeids,
+ CandidateList candidates)
+{
+ /* XXX no conflict resolution implemeneted yet */
+ return (NULL);
+}
+
+bool
+func_get_detail(char *funcname,
+ int nargs,
+ Oid *oid_array,
+ Oid *funcid, /* return value */
+ Oid *rettype, /* return value */
+ bool *retset, /* return value */
+ Oid **true_typeids) /* return value */
+{
+ Oid **input_typeid_vector;
+ Oid *current_input_typeids;
+ CandidateList function_typeids;
+ CandidateList current_function_typeids;
+ HeapTuple ftup;
+ Form_pg_proc pform;
+
+ /*
+ * attempt to find named function in the system catalogs
+ * with arguments exactly as specified - so that the normal
+ * case is just as quick as before
+ */
+ ftup = SearchSysCacheTuple(PRONAME,
+ PointerGetDatum(funcname),
+ Int32GetDatum(nargs),
+ PointerGetDatum(oid_array),
+ 0);
+ *true_typeids = oid_array;
+
+ /*
+ * If an exact match isn't found :
+ * 1) get a vector of all possible input arg type arrays constructed
+ * from the superclasses of the original input arg types
+ * 2) get a list of all possible argument type arrays to the
+ * function with given name and number of arguments
+ * 3) for each input arg type array from vector #1 :
+ * a) find how many of the function arg type arrays from list #2
+ * it can be coerced to
+ * b) - if the answer is one, we have our function
+ * - if the answer is more than one, attempt to resolve the
+ * conflict
+ * - if the answer is zero, try the next array from vector #1
+ */
+ if (!HeapTupleIsValid(ftup)) {
+ function_typeids = func_get_candidates(funcname, nargs);
+
+ if (function_typeids != NULL) {
+ int ncandidates = 0;
+
+ input_typeid_vector = argtype_inherit(nargs, oid_array);
+ current_input_typeids = oid_array;
+
+ do {
+ ncandidates = match_argtypes(nargs, current_input_typeids,
+ function_typeids,
+ ¤t_function_typeids);
+ if (ncandidates == 1) {
+ *true_typeids = current_function_typeids->args;
+ ftup = SearchSysCacheTuple(PRONAME,
+ PointerGetDatum(funcname),
+ Int32GetDatum(nargs),
+ PointerGetDatum(*true_typeids),
+ 0);
+ Assert(HeapTupleIsValid(ftup));
+ }
+ else if (ncandidates > 1) {
+ *true_typeids =
+ func_select_candidate(nargs,
+ current_input_typeids,
+ current_function_typeids);
+ if (*true_typeids == NULL) {
+ elog(NOTICE, "there is more than one function named \"%s\"",
+ funcname);
+ elog(NOTICE, "that satisfies the given argument types. you will have to");
+ elog(NOTICE, "retype your query using explicit typecasts.");
+ func_error("func_get_detail", funcname, nargs, (int*)oid_array);
+ }
+ else {
+ ftup = SearchSysCacheTuple(PRONAME,
+ PointerGetDatum(funcname),
+ Int32GetDatum(nargs),
+ PointerGetDatum(*true_typeids),
+ 0);
+ Assert(HeapTupleIsValid(ftup));
+ }
+ }
+ current_input_typeids = *input_typeid_vector++;
+ }
+ while (current_input_typeids !=
+ InvalidOid && ncandidates == 0);
+ }
+ }
+
+ if (!HeapTupleIsValid(ftup)) {
+ Type tp;
+
+ if (nargs == 1) {
+ tp = get_id_type(oid_array[0]);
+ if (typetypetype(tp) == 'c')
+ elog(WARN, "no such attribute or function \"%s\"",
+ funcname);
+ }
+ func_error("func_get_detail", funcname, nargs, (int*)oid_array);
+ } else {
+ pform = (Form_pg_proc) GETSTRUCT(ftup);
+ *funcid = ftup->t_oid;
+ *rettype = (Oid) pform->prorettype;
+ *retset = (Oid) pform->proretset;
+
+ return (true);
+ }
+/* shouldn't reach here */
+ return (false);
+
+}
+
+/*
+ * argtype_inherit() -- Construct an argtype vector reflecting the
+ * inheritance properties of the supplied argv.
+ *
+ * This function is used to disambiguate among functions with the
+ * same name but different signatures. It takes an array of eight
+ * type ids. For each type id in the array that's a complex type
+ * (a class), it walks up the inheritance tree, finding all
+ * superclasses of that type. A vector of new Oid type arrays
+ * is returned to the caller, reflecting the structure of the
+ * inheritance tree above the supplied arguments.
+ *
+ * The order of this vector is as follows: all superclasses of the
+ * rightmost complex class are explored first. The exploration
+ * continues from right to left. This policy means that we favor
+ * keeping the leftmost argument type as low in the inheritance tree
+ * as possible. This is intentional; it is exactly what we need to
+ * do for method dispatch. The last type array we return is all
+ * zeroes. This will match any functions for which return types are
+ * not defined. There are lots of these (mostly builtins) in the
+ * catalogs.
+ */
+static Oid **
+argtype_inherit(int nargs, Oid *oid_array)
+{
+ Oid relid;
+ int i;
+ InhPaths arginh[MAXFARGS];
+
+ for (i = 0; i < MAXFARGS; i++) {
+ if (i < nargs) {
+ arginh[i].self = oid_array[i];
+ if ((relid = typeid_get_relid(oid_array[i])) != InvalidOid) {
+ arginh[i].nsupers = findsupers(relid, &(arginh[i].supervec));
+ } else {
+ arginh[i].nsupers = 0;
+ arginh[i].supervec = (Oid *) NULL;
+ }
+ } else {
+ arginh[i].self = InvalidOid;
+ arginh[i].nsupers = 0;
+ arginh[i].supervec = (Oid *) NULL;
+ }
+ }
+
+ /* return an ordered cross-product of the classes involved */
+ return (genxprod(arginh, nargs));
+}
+
+typedef struct _SuperQE {
+ Oid sqe_relid;
+} SuperQE;
+
+static int
+findsupers(Oid relid, Oid **supervec)
+{
+ Oid *relidvec;
+ Relation inhrel;
+ HeapScanDesc inhscan;
+ ScanKeyData skey;
+ HeapTuple inhtup;
+ TupleDesc inhtupdesc;
+ int nvisited;
+ SuperQE *qentry, *vnode;
+ Dllist *visited, *queue;
+ Dlelem *qe, *elt;
+
+ Relation rd;
+ Buffer buf;
+ Datum d;
+ bool newrelid;
+ char isNull;
+
+ nvisited = 0;
+ queue = DLNewList();
+ visited = DLNewList();
+
+
+ inhrel = heap_openr(InheritsRelationName);
+ RelationSetLockForRead(inhrel);
+ inhtupdesc = RelationGetTupleDescriptor(inhrel);
+
+ /*
+ * Use queue to do a breadth-first traversal of the inheritance
+ * graph from the relid supplied up to the root.
+ */
+ do {
+ ScanKeyEntryInitialize(&skey, 0x0, Anum_pg_inherits_inhrel,
+ ObjectIdEqualRegProcedure,
+ ObjectIdGetDatum(relid));
+
+ inhscan = heap_beginscan(inhrel, 0, NowTimeQual, 1, &skey);
+
+ while (HeapTupleIsValid(inhtup = heap_getnext(inhscan, 0, &buf))) {
+ qentry = (SuperQE *) palloc(sizeof(SuperQE));
+
+ d = (Datum) fastgetattr(inhtup, Anum_pg_inherits_inhparent,
+ inhtupdesc, &isNull);
+ qentry->sqe_relid = DatumGetObjectId(d);
+
+ /* put this one on the queue */
+ DLAddTail(queue, DLNewElem(qentry));
+
+ ReleaseBuffer(buf);
+ }
+
+ heap_endscan(inhscan);
+
+ /* pull next unvisited relid off the queue */
+ do {
+ qe = DLRemHead(queue);
+ qentry = qe ? (SuperQE*)DLE_VAL(qe) : NULL;
+
+ if (qentry == (SuperQE *) NULL)
+ break;
+
+ relid = qentry->sqe_relid;
+ newrelid = true;
+
+ for (elt = DLGetHead(visited); elt; elt = DLGetSucc(elt)) {
+ vnode = (SuperQE*)DLE_VAL(elt);
+ if (vnode && (qentry->sqe_relid == vnode->sqe_relid)) {
+ newrelid = false;
+ break;
+ }
+ }
+ } while (!newrelid);
+
+ if (qentry != (SuperQE *) NULL) {
+
+ /* save the type id, rather than the relation id */
+ if ((rd = heap_open(qentry->sqe_relid)) == (Relation) NULL)
+ elog(WARN, "relid %d does not exist", qentry->sqe_relid);
+ qentry->sqe_relid = typeid(type(RelationGetRelationName(rd)->data));
+ heap_close(rd);
+
+ DLAddTail(visited, qe);
+
+ nvisited++;
+ }
+ } while (qentry != (SuperQE *) NULL);
+
+ RelationUnsetLockForRead(inhrel);
+ heap_close(inhrel);
+
+ if (nvisited > 0) {
+ relidvec = (Oid *) palloc(nvisited * sizeof(Oid));
+ *supervec = relidvec;
+
+ for (elt = DLGetHead(visited); elt; elt = DLGetSucc(elt)) {
+ vnode = (SuperQE*)DLE_VAL(elt);
+ *relidvec++ = vnode->sqe_relid;
+ }
+
+ } else {
+ *supervec = (Oid *) NULL;
+ }
+
+ return (nvisited);
+}
+
+static Oid **
+genxprod(InhPaths *arginh, int nargs)
+{
+ int nanswers;
+ Oid **result, **iter;
+ Oid *oneres;
+ int i, j;
+ int cur[MAXFARGS];
+
+ nanswers = 1;
+ for (i = 0; i < nargs; i++) {
+ nanswers *= (arginh[i].nsupers + 2);
+ cur[i] = 0;
+ }
+
+ iter = result = (Oid **) palloc(sizeof(Oid *) * nanswers);
+
+ /* compute the cross product from right to left */
+ for (;;) {
+ oneres = (Oid *) palloc(MAXFARGS * sizeof(Oid));
+ memset(oneres, 0, MAXFARGS * sizeof(Oid));
+
+ for (i = nargs - 1; i >= 0 && cur[i] > arginh[i].nsupers; i--)
+ continue;
+
+ /* if we're done, terminate with NULL pointer */
+ if (i < 0) {
+ *iter = NULL;
+ return (result);
+ }
+
+ /* no, increment this column and zero the ones after it */
+ cur[i] = cur[i] + 1;
+ for (j = nargs - 1; j > i; j--)
+ cur[j] = 0;
+
+ for (i = 0; i < nargs; i++) {
+ if (cur[i] == 0)
+ oneres[i] = arginh[i].self;
+ else if (cur[i] > arginh[i].nsupers)
+ oneres[i] = 0; /* wild card */
+ else
+ oneres[i] = arginh[i].supervec[cur[i] - 1];
+ }
+
+ *iter++ = oneres;
+ }
+}
+
+/* Given a type id, returns the in-conversion function of the type */
+Oid
+typeid_get_retinfunc(int type_id)
+{
+ HeapTuple typeTuple;
+ TypeTupleForm type;
+ Oid infunc;
+ typeTuple = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(type_id),
+ 0,0,0);
+ if ( !HeapTupleIsValid ( typeTuple ))
+ elog(WARN,
+ "typeid_get_retinfunc: Invalid type - oid = %d",
+ type_id);
+
+ type = (TypeTupleForm) GETSTRUCT(typeTuple);
+ infunc = type->typinput;
+ return(infunc);
+}
+
+Oid
+typeid_get_relid(int type_id)
+{
+ HeapTuple typeTuple;
+ TypeTupleForm type;
+ Oid infunc;
+ typeTuple = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(type_id),
+ 0,0,0);
+ if ( !HeapTupleIsValid ( typeTuple ))
+ elog(WARN, "typeid_get_relid: Invalid type - oid = %d ", type_id);
+
+ type = (TypeTupleForm) GETSTRUCT(typeTuple);
+ infunc = type->typrelid;
+ return(infunc);
+}
+
+Oid get_typrelid(Type typ)
+{
+ TypeTupleForm typtup;
+
+ typtup = (TypeTupleForm) GETSTRUCT(typ);
+
+ return (typtup->typrelid);
+}
+
+Oid
+get_typelem(Oid type_id)
+{
+ HeapTuple typeTuple;
+ TypeTupleForm type;
+
+ if (!(typeTuple = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(type_id),
+ 0,0,0))) {
+ elog (WARN , "type id lookup of %d failed", type_id);
+ }
+ type = (TypeTupleForm) GETSTRUCT(typeTuple);
+
+ return (type->typelem);
+}
+
+char
+FindDelimiter(char *typename)
+{
+ char delim;
+ HeapTuple typeTuple;
+ TypeTupleForm type;
+
+
+ if (!(typeTuple = SearchSysCacheTuple(TYPNAME,
+ PointerGetDatum(typename),
+ 0,0,0))) {
+ elog (WARN , "type name lookup of %s failed", typename);
+ }
+ type = (TypeTupleForm) GETSTRUCT(typeTuple);
+
+ delim = type->typdelim;
+ return (delim);
+}
+
+/*
+ * Give a somewhat useful error message when the operator for two types
+ * is not found.
+ */
+void
+op_error(char *op, int arg1, int arg2)
+{
+ Type tp1, tp2;
+
+ if (check_typeid(arg1)) {
+ tp1 = get_id_type(arg1);
+ } else {
+ elog(WARN, "left hand side of operator %s has an unknown type, probably a bad attribute name", op);
+ }
+
+ if (check_typeid(arg2)) {
+ tp2 = get_id_type(arg2);
+ } else {
+ elog(WARN, "right hand side of operator %s has an unknown type, probably a bad attribute name", op);
+ }
+
+ elog(NOTICE, "there is no operator %s for types %s and %s",
+ op, tname(tp1),tname(tp2));
+ elog(NOTICE, "You will either have to retype this query using an");
+ elog(NOTICE, "explicit cast, or you will have to define the operator");
+ elog(WARN, "%s for %s and %s using DEFINE OPERATOR",
+ op, tname(tp1),tname(tp2));
+}
+
+/*
+ * Error message when function lookup fails that gives details of the
+ * argument types
+ */
+void
+func_error(char *caller, char *funcname, int nargs, int *argtypes)
+{
+ Type get_id_type();
+ char p[(NAMEDATALEN+2)*MAXFMGRARGS], *ptr;
+ int i;
+
+ ptr = p;
+ *ptr = '\0';
+ for (i=0; i
+ if (i) {
+ *ptr++ = ',';
+ *ptr++ = ' ';
+ }
+ if (argtypes[i] != 0) {
+ (void) strcpy(ptr, tname(get_id_type(argtypes[i])));
+ *(ptr + NAMEDATALEN) = '\0';
+ } else
+ strcpy(ptr, "opaque");
+ ptr += strlen(ptr);
+ }
+
+ elog(WARN, "%s: function %s(%s) does not exist", caller, funcname, p);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * catalog_utils.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: catalog_utils.h,v 1.1.1.1 1996/07/09 06:21:40 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CATALOG_UTILS_H
+#define CATALOG_UTILS_H
+
+
+#include "postgres.h"
+
+#include "access/htup.h"
+#include "utils/rel.h"
+#include "catalog/pg_proc.h"
+#include "catalog/pg_type.h"
+#include "utils/syscache.h"
+
+typedef HeapTuple Type;
+typedef HeapTuple Operator;
+
+extern Oid typeid_get_relid();
+
+extern bool check_typeid(long id);
+extern Type get_id_type(long id);
+extern char *get_id_typname(long id);
+extern Type type(char *);
+extern Oid att_typeid(Relation rd, int attid);
+extern int att_attnelems(Relation rd, int attid);
+extern Oid typeid(Type tp);
+extern int16 tlen(Type t);
+extern bool tbyval(Type t);
+extern char *tname(Type t);
+extern int tbyvalue(Type t);
+extern Oid oprid(Operator op);
+extern Operator oper(char *op, int arg1, int arg2);
+extern Operator right_oper(char *op, int arg);
+extern Operator left_oper(char *op, int arg);
+extern int varattno(Relation rd, char *a);
+extern bool varisset(Relation rd, char *name);
+extern int nf_varattno(Relation rd, char *a);
+extern char *getAttrName(Relation rd, int attrno);
+extern char *outstr(char *typename, char *value);
+extern char *instr2(Type tp, char *string, int typlen);
+extern char *instr1(TypeTupleForm tp, char *string, int typlen);
+extern Oid GetArrayElementType(Oid typearray);
+extern Oid funcid_get_rettype(Oid funcid);
+extern bool func_get_detail(char *funcname, int nargs, Oid *oid_array,
+ Oid *funcid, Oid *rettype, bool *retset, Oid **true_typeids);
+extern Oid typeid_get_retinfunc(int type_id);
+extern Oid typeid_get_relid(int type_id);
+extern Oid get_typrelid(Type typ);
+extern Oid get_typelem(Oid type_id);
+extern char FindDelimiter(char *typename);
+extern void op_error(char *op, int arg1, int arg2);
+extern void func_error(char *caller, char *funcname, int nargs, int *argtypes);
+
+#endif /* CATALOG_UTILS_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * dbcommands.c--
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/parser/Attic/dbcommands.c,v 1.1.1.1 1996/07/09 06:21:40 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+
+#include "postgres.h"
+#include "miscadmin.h" /* for DataDir */
+#include "access/heapam.h"
+#include "access/htup.h"
+#include "access/relscan.h"
+#include "utils/rel.h"
+#include "utils/elog.h"
+#include "catalog/catname.h"
+#include "catalog/pg_proc.h"
+#include "catalog/pg_user.h"
+#include "catalog/pg_database.h"
+#include "utils/syscache.h"
+#include "parser/dbcommands.h"
+#include "tcop/tcopprot.h"
+#include "storage/bufmgr.h"
+#include "storage/lmgr.h"
+
+
+/* non-export function prototypes */
+static void check_permissions(char *command, char *dbname,
+ Oid *dbIdP, Oid *userIdP);
+static HeapTuple get_pg_dbtup(char *command, char *dbname, Relation dbrel);
+
+void
+createdb(char *dbname)
+{
+ Oid db_id, user_id;
+ char buf[512];
+
+ /*
+ * If this call returns, the database does not exist and we're allowed
+ * to create databases.
+ */
+ check_permissions("createdb", dbname, &db_id, &user_id);
+
+ /* close virtual file descriptors so we can do system() calls */
+ closeAllVfds();
+
+ sprintf(buf, "mkdir %s%cbase%c%s", DataDir, SEP_CHAR, SEP_CHAR, dbname);
+ system(buf);
+ sprintf(buf, "%s %s%cbase%ctemplate1%c* %s%cbase%c%s",
+ COPY_CMD, DataDir, SEP_CHAR, SEP_CHAR, SEP_CHAR, DataDir,
+ SEP_CHAR, SEP_CHAR, dbname);
+ system(buf);
+
+/* sprintf(buf, "insert into pg_database (datname, datdba, datpath) \
+ values (\'%s\'::char16, \'%d\'::oid, \'%s\'::text);",
+ dbname, user_id, dbname);
+*/
+ sprintf(buf, "insert into pg_database (datname, datdba, datpath) \
+ values (\'%s\', \'%d\', \'%s\');",
+ dbname, user_id, dbname);
+
+ pg_eval(buf, (char **) NULL, (Oid *) NULL, 0);
+}
+
+void
+destroydb(char *dbname)
+{
+ Oid user_id, db_id;
+ char buf[512];
+
+ /*
+ * If this call returns, the database exists and we're allowed to
+ * remove it.
+ */
+ check_permissions("destroydb", dbname, &db_id, &user_id);
+
+ if (!OidIsValid(db_id)) {
+ elog(FATAL, "impossible: pg_database instance with invalid OID.");
+ }
+
+ /* stop the vacuum daemon */
+ stop_vacuum(dbname);
+
+ /* remove the pg_database tuple FIRST,
+ this may fail due to permissions problems*/
+ sprintf(buf, "delete from pg_database where pg_database.oid = \'%d\'::oid",
+ db_id);
+ pg_eval(buf, (char **) NULL, (Oid *) NULL, 0);
+
+ /* remove the data directory. If the DELETE above failed, this will
+ not be reached */
+ sprintf(buf, "rm -r %s/base/%s", DataDir, dbname);
+ system(buf);
+
+ /* drop pages for this database that are in the shared buffer cache */
+ DropBuffers(db_id);
+}
+
+static HeapTuple
+get_pg_dbtup(char *command, char *dbname, Relation dbrel)
+{
+ HeapTuple dbtup;
+ HeapTuple tup;
+ Buffer buf;
+ HeapScanDesc scan;
+ ScanKeyData scanKey;
+
+ ScanKeyEntryInitialize(&scanKey, 0, Anum_pg_database_datname,
+ NameEqualRegProcedure, NameGetDatum(dbname));
+
+ scan = heap_beginscan(dbrel, 0, NowTimeQual, 1, &scanKey);
+ if (!HeapScanIsValid(scan))
+ elog(WARN, "%s: cannot begin scan of pg_database.", command);
+
+ /*
+ * since we want to return the tuple out of this proc, and we're
+ * going to close the relation, copy the tuple and return the copy.
+ */
+ tup = heap_getnext(scan, 0, &buf);
+
+ if (HeapTupleIsValid(tup)) {
+ dbtup = heap_copytuple(tup);
+ ReleaseBuffer(buf);
+ } else
+ dbtup = tup;
+
+ heap_endscan(scan);
+ return (dbtup);
+}
+
+/*
+ * check_permissions() -- verify that the user is permitted to do this.
+ *
+ * If the user is not allowed to carry out this operation, this routine
+ * elog(WARN, ...)s, which will abort the xact. As a side effect, the
+ * user's pg_user tuple OID is returned in userIdP and the target database's
+ * OID is returned in dbIdP.
+ */
+
+static void
+check_permissions(char *command,
+ char *dbname,
+ Oid *dbIdP,
+ Oid *userIdP)
+{
+ Relation dbrel;
+ HeapTuple dbtup, utup;
+ Oid dbowner;
+ char use_createdb;
+ bool dbfound;
+ bool use_super;
+ char *userName;
+
+ userName = GetPgUserName();
+ utup = SearchSysCacheTuple(USENAME, PointerGetDatum(userName),
+ 0,0,0);
+ *userIdP = ((Form_pg_user)GETSTRUCT(utup))->usesysid;
+ use_super = ((Form_pg_user)GETSTRUCT(utup))->usesuper;
+ use_createdb = ((Form_pg_user)GETSTRUCT(utup))->usecreatedb;
+
+ /* Check to make sure user has permission to use createdb */
+ if (!use_createdb) {
+ elog(WARN, "user \"%-.*s\" is not allowed to create/destroy databases",
+ NAMEDATALEN, userName);
+ }
+
+ /* Make sure we are not mucking with the template database */
+ if (!strcmp(dbname, "template1")) {
+ elog(WARN, "%s cannot be executed on the template database.", command);
+ }
+
+ /* Check to make sure database is not the currently open database */
+ if (!strcmp(dbname, GetDatabaseName())) {
+ elog(WARN, "%s cannot be executed on an open database", command);
+ }
+
+ /* Check to make sure database is owned by this user */
+
+ /*
+ * need the reldesc to get the database owner out of dbtup
+ * and to set a write lock on it.
+ */
+ dbrel = heap_openr(DatabaseRelationName);
+
+ if (!RelationIsValid(dbrel))
+ elog(FATAL, "%s: cannot open relation \"%-.*s\"",
+ command, DatabaseRelationName);
+
+ /*
+ * Acquire a write lock on pg_database from the beginning to avoid
+ * upgrading a read lock to a write lock. Upgrading causes long delays
+ * when multiple 'createdb's or 'destroydb's are run simult. -mer 7/3/91
+ */
+ RelationSetLockForWrite(dbrel);
+ dbtup = get_pg_dbtup(command, dbname, dbrel);
+ dbfound = HeapTupleIsValid(dbtup);
+
+ if (dbfound) {
+ dbowner = (Oid) heap_getattr(dbtup, InvalidBuffer,
+ Anum_pg_database_datdba,
+ RelationGetTupleDescriptor(dbrel),
+ (char *) NULL);
+ *dbIdP = dbtup->t_oid;
+ } else {
+ *dbIdP = InvalidOid;
+ }
+
+ heap_close(dbrel);
+
+ /*
+ * Now be sure that the user is allowed to do this.
+ */
+
+ if (dbfound && !strcmp(command, "createdb")) {
+
+ elog(WARN, "createdb: database %s already exists.", dbname);
+
+ } else if (!dbfound && !strcmp(command, "destroydb")) {
+
+ elog(WARN, "destroydb: database %s does not exist.", dbname);
+
+ } else if (dbfound && !strcmp(command, "destroydb")
+ && dbowner != *userIdP && use_super == false) {
+
+ elog(WARN, "%s: database %s is not owned by you.", command, dbname);
+
+ }
+}
+
+/*
+ * stop_vacuum() -- stop the vacuum daemon on the database, if one is
+ * running.
+ */
+void
+stop_vacuum(char *dbname)
+{
+ char filename[256];
+ FILE *fp;
+ int pid;
+
+ sprintf(filename, "%s%cbase%c%s%c%s.vacuum", DataDir, SEP_CHAR, SEP_CHAR,
+ dbname, SEP_CHAR, dbname);
+ if ((fp = fopen(filename, "r")) != (FILE *) NULL) {
+ fscanf(fp, "%d", &pid);
+ fclose(fp);
+ if (kill(pid, SIGKILLDAEMON1) < 0) {
+ elog(WARN, "can't kill vacuum daemon (pid %d) on %s",
+ pid, dbname);
+ }
+ }
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * dbcommands.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: dbcommands.h,v 1.1.1.1 1996/07/09 06:21:40 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef DBCOMMANDS_H
+#define DBCOMMANDS_H
+
+/*
+ * Originally from tmp/daemon.h. The functions declared in daemon.h does not
+ * exist; hence removed. -- AY 7/29/94
+ */
+#define SIGKILLDAEMON1 SIGINT
+#define SIGKILLDAEMON2 SIGTERM
+
+extern void createdb(char *dbname);
+extern void destroydb(char *dbname);
+void stop_vacuum(char *dbname);
+
+#endif /* DBCOMMANDS_H */
+
--- /dev/null
+%{ /* -*-text-*- */
+
+#define YYDEBUG 1
+/*-------------------------------------------------------------------------
+ *
+ * gram.y--
+ * POSTGRES SQL YACC rules/actions
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 1.1.1.1 1996/07/09 06:21:40 scrappy Exp $
+ *
+ * HISTORY
+ * AUTHOR DATE MAJOR EVENT
+ * Andrew Yu Sept, 1994 POSTQUEL to SQL conversion
+ * Andrew Yu Oct, 1994 lispy code conversion
+ *
+ * NOTES
+ * CAPITALS are used to represent terminal symbols.
+ * non-capitals are used to represent non-terminals.
+ *
+ * if you use list, make sure the datum is a node so that the printing
+ * routines work
+ *
+ * WARNING
+ * sometimes we assign constants to makeStrings. Make sure we don't free
+ * those.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include "postgres.h"
+#include "nodes/parsenodes.h"
+#include "parser/catalog_utils.h"
+#include "parser/parse_query.h"
+#include "utils/acl.h"
+#include "catalog/catname.h"
+#include "utils/elog.h"
+#include "access/xact.h"
+
+static char saved_relname[BUFSIZ]; /* need this for complex attributes */
+static bool QueryIsRule = FALSE;
+
+extern List *parsetree;
+
+/*
+ * If you need access to certain yacc-generated variables and find that
+ * they're static by default, uncomment the next line. (this is not a
+ * problem, yet.)
+ */
+/*#define __YYSCLASS*/
+
+extern void yyerror(char message[]);
+
+static char *xlateSqlType(char *);
+static Node *makeA_Expr(int op, char *opname, Node *lexpr, Node *rexpr);
+
+/* old versions of flex define this as a macro */
+#if defined(yywrap)
+#undef yywrap
+#endif /* yywrap */
+%}
+
+
+%union {
+ double dval;
+ int ival;
+ char chr;
+ char *str;
+ bool boolean;
+ List *list;
+ Node *node;
+ Value *value;
+
+ Attr *attr;
+
+ ColumnDef *coldef;
+ TypeName *typnam;
+ DefElem *defelt;
+ ParamString *param;
+ SortBy *sortby;
+ IndexElem *ielem;
+ RangeVar *range;
+ RelExpr *relexp;
+ TimeRange *trange;
+ A_Indices *aind;
+ ResTarget *target;
+ ParamNo *paramno;
+
+ VersionStmt *vstmt;
+ DefineStmt *dstmt;
+ PurgeStmt *pstmt;
+ RuleStmt *rstmt;
+ AppendStmt *astmt;
+}
+
+%type query, stmt, AddAttrStmt, ClosePortalStmt,
+ CopyStmt, CreateStmt, DefineStmt, DestroyStmt,
+ ExtendStmt, FetchStmt, GrantStmt,
+ IndexStmt, MoveStmt, ListenStmt, OptimizableStmt,
+ ProcedureStmt, PurgeStmt,
+ RecipeStmt, RemoveOperStmt, RemoveFuncStmt, RemoveStmt, RenameStmt,
+ RevokeStmt, RuleStmt, TransactionStmt, ViewStmt, LoadStmt,
+ CreatedbStmt, DestroydbStmt, VacuumStmt, RetrieveStmt, CursorStmt,
+ ReplaceStmt, AppendStmt, NotifyStmt, DeleteStmt, ClusterStmt,
+ ExplainStmt
+
+%type relation_name, copy_file_name, copy_delimiter, def_name,
+ database_name, access_method, attr_name, class, index_name,
+ var_name, name, file_name, recipe_name
+
+%type opt_id, opt_portal_name,
+ before_clause, after_clause, all_Op, MathOp, opt_name, opt_unique
+ result, OptUseOp, opt_class, opt_range_start, opt_range_end,
+ SpecialRuleRelation
+
+%type privileges, operation_commalist, grantee
+%type operation
+
+%type queryblock, relation_name_list, OptTableElementList,
+ tableElementList, OptInherit, definition,
+ opt_with, def_args, def_name_list, func_argtypes, oper_argtypes,
+ OptStmtList, OptStmtBlock, opt_column_list, columnList,
+ exprList, sort_clause, sortby_list, index_params,
+ name_list, from_clause, from_list, opt_array_bounds, nest_array_bounds,
+ expr_list, attrs, res_target_list, res_target_list2, def_list,
+ opt_indirection, group_clause, groupby_list, explain_options
+
+%type opt_inh_star, opt_binary, opt_instead
+
+%type copy_dirn, archive_type, OptArchiveType, OptArchiveLocation,
+ def_type, opt_direction, remove_type, opt_column, event
+
+%type OptLocation, opt_move_where, fetch_how_many
+
+%type def_rest
+
+%type Typename, typname
+%type columnDef
+%type def_elem
+%type def_arg, columnElem, exprElem, where_clause,
+ a_expr, AexprConst, having_clause, groupby
+%type NumConst
+%type
event_object, attr+%type sortby
+%type index_elem, func_index
+%type from_val
+%type relation_expr
+%type time_range
+%type res_target_el, res_target_el2
+
+%type Iconst
+%type Sconst
+%type Id, date
+
+
+/*
+ * If you make any token changes, remember to:
+ * - use "yacc -d" and update parse.h
+ * - update the keyword table in parser/keywords.c
+ */
+
+/* Keywords */
+%token ABORT_TRANS, ACL, ADD, AFTER, AGGREGATE, ALL, ALTER, AND, APPEND,
+ ARCHIVE, ARCH_STORE, AS, ASC, BACKWARD, BEFORE, BEGIN_TRANS, BINARY,
+ BY, CAST, CHANGE, CLOSE, CLUSTER, COLUMN, COMMIT, COPY, CREATE, CURRENT,
+ CURSOR, DATABASE, DECLARE, DELETE, DELIMITERS, DESC, DISTINCT, DO,
+ DROP, END_TRANS,
+ EXTEND, FETCH, FOR, FORWARD, FROM, FUNCTION, GRANT, GROUP,
+ HAVING, HEAVY, IN, INDEX, INHERITS, INSERT, INSTEAD, INTO,
+ ISNULL, LANGUAGE, LIGHT, LISTEN, LOAD, MERGE, MOVE, NEW,
+ NONE, NOT, NOTHING, NOTIFY, NOTNULL,
+ ON, OPERATOR, OPTION, OR, ORDER,
+ PNULL, PRIVILEGES, PUBLIC, PURGE, P_TYPE,
+ RENAME, REPLACE, RETRIEVE, RETURNS, REVOKE, ROLLBACK, RULE,
+ SELECT, SET, SETOF, STDIN, STDOUT, STORE,
+ TABLE, TO, TRANSACTION, UPDATE, USING, VACUUM, VALUES
+ VERSION, VIEW, WHERE, WITH, WORK
+%token EXECUTE, RECIPE, EXPLAIN, LIKE
+
+/* Special keywords, not in the query language - see the "lex" file */
+%token IDENT, SCONST, Op
+%token ICONST, PARAM
+%token FCONST
+
+/* these are not real. they are here so that they gets generated as #define's*/
+%token OP
+
+/* precedence */
+%left OR
+%left AND
+%right NOT
+%right '='
+%nonassoc LIKE
+%nonassoc Op
+%nonassoc NOTNULL
+%nonassoc ISNULL
+%left '+' '-'
+%left '*' '/'
+%left '|' /* this is the relation union op, not logical or */
+%right ';' ':' /* Unary Operators */
+%nonassoc '<' '>'
+%right UMINUS
+%left '.'
+%left '[' ']'
+%nonassoc TYPECAST
+%nonassoc REDUCE
+%%
+
+queryblock: query queryblock
+ { parsetree = lcons($1, parsetree); }
+ | query
+ { parsetree = lcons($1, NIL); }
+ ;
+
+query: stmt
+ | stmt ';' { $$ = $1; }
+ ;
+
+stmt : AddAttrStmt
+ | ClosePortalStmt
+ | CopyStmt
+ | CreateStmt
+ | ClusterStmt
+ | DefineStmt
+ | DestroyStmt
+ | ExtendStmt
+ | ExplainStmt
+ | FetchStmt
+ | GrantStmt
+ | IndexStmt
+ | MoveStmt
+ | ListenStmt
+ | ProcedureStmt
+ | PurgeStmt
+ | RecipeStmt
+ | RemoveOperStmt
+ | RemoveFuncStmt
+ | RemoveStmt
+ | RenameStmt
+ | RevokeStmt
+ | OptimizableStmt
+ | RuleStmt
+ | TransactionStmt
+ | ViewStmt
+ | LoadStmt
+ | CreatedbStmt
+ | DestroydbStmt
+ | VacuumStmt
+ ;
+
+/*****************************************************************************
+ *
+ * QUERY :
+ * addattr ( attr1 = type1 .. attrn = typen ) to [*]
+ *
+ *****************************************************************************/
+
+AddAttrStmt: ALTER TABLE relation_name opt_inh_star ADD COLUMN columnDef
+ {
+ AddAttrStmt *n = makeNode(AddAttrStmt);
+ n->relname = $3;
+ n->inh = $4;
+ n->colDef = $7;
+ $$ = (Node *)n;
+ }
+ ;
+
+columnDef: Id Typename
+ {
+ $$ = makeNode(ColumnDef);
+ $$->colname = $1;
+ $$->typename = $2;
+ }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY :
+ * close
+ *
+ *****************************************************************************/
+
+ClosePortalStmt: CLOSE opt_id
+ {
+ ClosePortalStmt *n = makeNode(ClosePortalStmt);
+ n->portalname = $2;
+ $$ = (Node *)n;
+ }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY :
+ * COPY [BINARY] FROM/TO
+ * [USING DELIMITERS ]
+ *
+ *****************************************************************************/
+
+CopyStmt: COPY opt_binary relation_name copy_dirn copy_file_name copy_delimiter
+ {
+ CopyStmt *n = makeNode(CopyStmt);
+ n->binary = $2;
+ n->relname = $3;
+ n->direction = $4;
+ n->filename = $5;
+ n->delimiter = $6;
+ $$ = (Node *)n;
+ }
+ ;
+
+copy_dirn: TO
+ { $$ = TO; }
+ | FROM
+ { $$ = FROM; }
+ ;
+
+/*
+ * copy_file_name NULL indicates stdio is used. Whether stdin or stdout is
+ * used depends on the direction. (It really doesn't make sense to copy from
+ * stdout. We silently correct the "typo". - AY 9/94
+ */
+copy_file_name: Sconst { $$ = $1; }
+ | STDIN { $$ = NULL; }
+ | STDOUT { $$ = NULL; }
+ ;
+
+opt_binary: BINARY { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = FALSE; }
+ ;
+
+/*
+ * the default copy delimiter is tab but the user can configure it
+ */
+copy_delimiter: USING DELIMITERS Sconst { $$ = $3;}
+ | /* EMPTY */ { $$ = "\t"; }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY :
+ * CREATE relname
+ *
+ *****************************************************************************/
+
+CreateStmt: CREATE TABLE relation_name '(' OptTableElementList ')'
+ OptInherit OptArchiveType OptLocation OptArchiveLocation
+ {
+ CreateStmt *n = makeNode(CreateStmt);
+ n->relname = $3;
+ n->tableElts = $5;
+ n->inhRelnames = $7;
+ n->archiveType = $8;
+ n->location = $9;
+ n->archiveLoc = $10;
+ $$ = (Node *)n;
+ }
+ ;
+
+OptTableElementList: tableElementList { $$ = $1; }
+ | /* EMPTY */ { $$ = NULL; }
+ ;
+
+tableElementList :
+ tableElementList ',' columnDef
+ { $$ = lappend($1, $3); }
+ | columnDef
+ { $$ = lcons($1, NIL); }
+ ;
+
+
+OptArchiveType: ARCHIVE '=' archive_type { $$ = $3; }
+ | /*EMPTY*/ { $$ = ARCH_NONE; }
+ ;
+
+archive_type: HEAVY { $$ = ARCH_HEAVY; }
+ | LIGHT { $$ = ARCH_LIGHT; }
+ | NONE { $$ = ARCH_NONE; }
+ ;
+
+OptLocation: STORE '=' Sconst
+ { $$ = smgrin($3); }
+ | /*EMPTY*/
+ { $$ = -1; }
+ ;
+
+OptArchiveLocation: ARCH_STORE '=' Sconst
+ { $$ = smgrin($3); }
+ | /*EMPTY*/
+ { $$ = -1; }
+ ;
+
+OptInherit: INHERITS '(' relation_name_list ')' { $$ = $3; }
+ | /*EMPTY*/ { $$ = NIL; }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY :
+ * define (type,operator,aggregate)
+ *
+ *****************************************************************************/
+
+DefineStmt: CREATE def_type def_rest
+ {
+ $3->defType = $2;
+ $$ = (Node *)$3;
+ }
+ ;
+
+def_rest: def_name definition
+ {
+ $$ = makeNode(DefineStmt);
+ $$->defname = $1;
+ $$->definition = $2;
+ }
+ ;
+
+def_type: OPERATOR { $$ = OPERATOR; }
+ | Type { $$ = P_TYPE; }
+ | AGGREGATE { $$ = AGGREGATE; }
+ ;
+
+def_name: Id | MathOp | Op
+ ;
+
+
+definition: '(' def_list ')' { $$ = $2; }
+ ;
+
+
+def_list: def_elem
+ { $$ = lcons($1, NIL); }
+ | def_list ',' def_elem
+ { $$ = lappend($1, $3); }
+ ;
+
+def_elem: def_name '=' def_arg
+ {
+ $$ = makeNode(DefElem);
+ $$->defname = $1;
+ $$->arg = (Node *)$3;
+ }
+ | def_name
+ {
+ $$ = makeNode(DefElem);
+ $$->defname = $1;
+ $$->arg = (Node *)NULL;
+ }
+ ;
+
+def_arg: Id { $$ = (Node *)makeString($1); }
+ | all_Op { $$ = (Node *)makeString($1); }
+ | NumConst { $$ = (Node *)$1; /* already a Value */ }
+ | Sconst { $$ = (Node *)makeString($1); }
+ | SETOF Id {
+ TypeName *n = makeNode(TypeName);
+ n->name = $2;
+ n->setof = TRUE;
+ n->arrayBounds = NULL;
+ $$ = (Node *)n;
+ }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * destroy [, .. ]
+ *
+ *****************************************************************************/
+
+DestroyStmt: DROP TABLE relation_name_list
+ {
+ DestroyStmt *n = makeNode(DestroyStmt);
+ n->relNames = $3;
+ $$ = (Node *)n;
+ }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * fetch [forward | backward] [number | all ] [ in
]+ *
+ *****************************************************************************/
+
+FetchStmt: FETCH opt_direction fetch_how_many opt_portal_name
+ {
+ FetchStmt *n = makeNode(FetchStmt);
+ n->direction = $2;
+ n->howMany = $3;
+ n->portalname = $4;
+ $$ = (Node *)n;
+ }
+ ;
+
+opt_direction: FORWARD { $$ = FORWARD; }
+ | BACKWARD { $$ = BACKWARD; }
+ | /*EMPTY*/ { $$ = FORWARD; /* default */ }
+ ;
+
+fetch_how_many: Iconst
+ { $$ = $1;
+ if ($1 <= 0) elog(WARN,"Please specify nonnegative count for fetch"); }
+ | ALL { $$ = 0; /* 0 means fetch all tuples*/}
+ | /*EMPTY*/ { $$ = 0; /*default*/ }
+ ;
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * GRANT [privileges] ON [relation_name_list] TO [GROUP] grantee
+ *
+ *****************************************************************************/
+
+GrantStmt: GRANT privileges ON relation_name_list TO grantee opt_with_grant
+ {
+ $$ = (Node*)makeAclStmt($2,$4,$6,'+');
+ free($2);
+ free($6);
+ }
+ ;
+
+privileges: ALL PRIVILEGES
+ {
+ $$ = aclmakepriv("rwaR",0);
+ }
+ | ALL
+ {
+ $$ = aclmakepriv("rwaR",0);
+ }
+ | operation_commalist {
+ $$ = $1;
+ }
+ ;
+
+operation_commalist: operation {
+ $$ = aclmakepriv("",$1);
+ }
+ | operation_commalist ',' operation
+ {
+ $$ = aclmakepriv($1,$3);
+ free($1);
+ }
+ ;
+
+operation: SELECT {
+ $$ = ACL_MODE_RD_CHR;
+ }
+ | INSERT {
+ $$ = ACL_MODE_AP_CHR;
+ }
+ | UPDATE {
+ $$ = ACL_MODE_WR_CHR;
+ }
+ | DELETE {
+ $$ = ACL_MODE_WR_CHR;
+ }
+ | RULE {
+ $$ = ACL_MODE_RU_CHR;
+ }
+ ;
+
+grantee: PUBLIC {
+ $$ = aclmakeuser("A","");
+ }
+ | GROUP Id {
+ $$ = aclmakeuser("G",$2);
+ }
+ | Id {
+ $$ = aclmakeuser("U",$1);
+ }
+ ;
+
+opt_with_grant : /* empty */
+ | WITH GRANT OPTION
+ {
+ yyerror("WITH GRANT OPTION is not supported. Only relation owners can set privileges");
+ }
+ ;
+/*****************************************************************************
+ *
+ * QUERY:
+ * REVOKE [privileges] ON [relation_name] FROM [user]
+ *
+ *****************************************************************************/
+
+RevokeStmt: REVOKE privileges ON relation_name_list FROM grantee
+ {
+ $$ = (Node*)makeAclStmt($2,$4,$6,'-');
+ free($2);
+ free($6);
+ }
+ ;
+
+/*****************************************************************************
+ *
+ * QUERY:
+ *
+ *****************************************************************************/
+
+MoveStmt: MOVE opt_direction opt_move_where opt_portal_name
+ {
+ MoveStmt *n = makeNode(MoveStmt);
+ n->direction = $2;
+ n->to = FALSE;
+ n->where = $3;
+ n->portalname = $4;
+ $$ = (Node *)n;
+ }
+ | MOVE opt_direction TO Iconst opt_portal_name
+ {
+ MoveStmt *n = makeNode(MoveStmt);
+ n->direction = $2;
+ n->to = TRUE;
+ n->where = $4;
+ n->portalname = $5;
+ $$ = (Node *)n;
+ }
+ ;
+
+opt_move_where: Iconst { $$ = $1; }
+ | /*EMPTY*/ { $$ = 1; /* default */ }
+ ;
+
+opt_portal_name: IN name { $$ = $2;}
+ | /*EMPTY*/ { $$ = NULL; }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * define [archive] index on
+ * using
"(" ( with )+ ")" [with+ * ]
+ *
+ * [where ] is not supported anymore
+ *****************************************************************************/
+
+IndexStmt: CREATE INDEX index_name ON relation_name
+ USING access_method '(' index_params ')'
+ {
+ /* should check that access_method is valid,
+ etc ... but doesn't */
+ IndexStmt *n = makeNode(IndexStmt);
+ n->idxname = $3;
+ n->relname = $5;
+ n->accessMethod = $7;
+ n->indexParams = $9;
+ n->withClause = NIL;
+ n->whereClause = NULL;
+ $$ = (Node *)n;
+ }
+ ;
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * extend index [where ]
+ *
+ *****************************************************************************/
+
+ExtendStmt: EXTEND INDEX index_name where_clause
+ {
+ ExtendStmt *n = makeNode(ExtendStmt);
+ n->idxname = $3;
+ n->whereClause = $4;
+ $$ = (Node *)n;
+ }
+ ;
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * execute recipe
+ *
+ *****************************************************************************/
+
+RecipeStmt: EXECUTE RECIPE recipe_name
+ {
+ RecipeStmt *n;
+ if (!IsTransactionBlock())
+ elog(WARN, "EXECUTE RECIPE may only be used in begin/end transaction blocks.");
+
+ n = makeNode(RecipeStmt);
+ n->recipeName = $3;
+ $$ = (Node *)n;
+ }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * define function
+ * (language = , returntype =
+ * [, perbyte_cpu = ]
+ * [, percall_cpu = ]
+ * [, iscachable])
+ * [arg is ( { , })]
+ * as
+ *
+ *****************************************************************************/
+
+ProcedureStmt: CREATE FUNCTION def_name def_args
+ RETURNS def_arg opt_with AS Sconst LANGUAGE Sconst
+ {
+ ProcedureStmt *n = makeNode(ProcedureStmt);
+ n->funcname = $3;
+ n->defArgs = $4;
+ n->returnType = (Node *)$6;
+ n->withClause = $7;
+ n->as = $9;
+ n->language = $11;
+ $$ = (Node *)n;
+ };
+
+opt_with: WITH definition { $$ = $2; }
+ | /* EMPTY */ { $$ = NIL; }
+ ;
+
+def_args: '(' def_name_list ')' { $$ = $2; }
+ | '(' ')' { $$ = NIL; }
+ ;
+
+def_name_list: name_list;
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * purge [before ] [after ]
+ * or
+ * purge [after][before ]
+ *
+ *****************************************************************************/
+
+PurgeStmt: PURGE relation_name purge_quals
+ {
+ $3->relname = $2;
+ $$ = (Node *)$3;
+ }
+ ;
+
+purge_quals: before_clause
+ {
+ $$ = makeNode(PurgeStmt);
+ $$->beforeDate = $1;
+ $$->afterDate = NULL;
+ }
+ | after_clause
+ {
+ $$ = makeNode(PurgeStmt);
+ $$->beforeDate = NULL;
+ $$->afterDate = $1;
+ }
+ | before_clause after_clause
+ {
+ $$ = makeNode(PurgeStmt);
+ $$->beforeDate = $1;
+ $$->afterDate = $2;
+ }
+ | after_clause before_clause
+ {
+ $$ = makeNode(PurgeStmt);
+ $$->beforeDate = $2;
+ $$->afterDate = $1;
+ }
+ | /*EMPTY*/
+ {
+ $$ = makeNode(PurgeStmt);
+ $$->beforeDate = NULL;
+ $$->afterDate = NULL;
+ }
+ ;
+
+before_clause: BEFORE date { $$ = $2; }
+after_clause: AFTER date { $$ = $2; }
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ *
+ * remove function
+ * (REMOVE FUNCTION "funcname" (arg1, arg2, ...))
+ * remove operator
+ * (REMOVE OPERATOR "opname" (leftoperand_typ rightoperand_typ))
+ * remove type
+ * (REMOVE TYPE "typename")
+ * remove rule
+ * (REMOVE RULE "rulename")
+ *
+ *****************************************************************************/
+
+RemoveStmt: DROP remove_type name
+ {
+ RemoveStmt *n = makeNode(RemoveStmt);
+ n->removeType = $2;
+ n->name = $3;
+ $$ = (Node *)n;
+ }
+ ;
+
+remove_type: AGGREGATE { $$ = AGGREGATE; }
+ | Type { $$ = P_TYPE; }
+ | INDEX { $$ = INDEX; }
+ | RULE { $$ = RULE; }
+ | VIEW { $$ = VIEW; }
+ ;
+
+RemoveFuncStmt: DROP FUNCTION name '(' func_argtypes ')'
+ {
+ RemoveFuncStmt *n = makeNode(RemoveFuncStmt);
+ n->funcname = $3;
+ n->args = $5;
+ $$ = (Node *)n;
+ }
+ ;
+
+func_argtypes: name_list { $$ = $1; }
+ | /*EMPTY*/ { $$ = NIL; }
+ ;
+
+RemoveOperStmt: DROP OPERATOR all_Op '(' oper_argtypes ')'
+ {
+ RemoveOperStmt *n = makeNode(RemoveOperStmt);
+ n->opname = $3;
+ n->args = $5;
+ $$ = (Node *)n;
+ }
+ ;
+
+all_Op: Op | MathOp;
+
+MathOp: '+' { $$ = "+"; }
+ | '-' { $$ = "-"; }
+ | '*' { $$ = "*"; }
+ | '/' { $$ = "/"; }
+ | '<' { $$ = "<"; }
+ | '>' { $$ = ">"; }
+ | '=' { $$ = "="; }
+ ;
+
+oper_argtypes: name
+ {
+ elog(WARN, "parser: argument type missing (use NONE for unary operators)");
+ }
+ | name ',' name
+ { $$ = makeList(makeString($1), makeString($3), -1); }
+ | NONE ',' name /* left unary */
+ { $$ = makeList(NULL, makeString($3), -1); }
+ | name ',' NONE /* right unary */
+ { $$ = makeList(makeString($1), NULL, -1); }
+ ;
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * rename to
+ *
+ *****************************************************************************/
+
+RenameStmt: ALTER TABLE relation_name opt_inh_star
+ RENAME opt_column opt_name TO name
+ {
+ RenameStmt *n = makeNode(RenameStmt);
+ n->relname = $3;
+ n->inh = $4;
+ n->column = $7;
+ n->newname = $9;
+ $$ = (Node *)n;
+ }
+ ;
+
+opt_name: name { $$ = $1; }
+ | /*EMPTY*/ { $$ = NULL; }
+ ;
+
+opt_column: COLUMN { $$ = COLUMN; }
+ | /*EMPTY*/ { $$ = 0; }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY: Define Rewrite Rule , Define Tuple Rule
+ *
+ * only rewrite rule is supported -- ay 9/94
+ *
+ *****************************************************************************/
+
+RuleStmt: CREATE RULE name AS
+ { QueryIsRule=TRUE; }
+ ON event TO event_object where_clause
+ DO opt_instead OptStmtList
+ {
+ RuleStmt *n = makeNode(RuleStmt);
+ n->rulename = $3;
+ n->event = $7;
+ n->object = $9;
+ n->whereClause = $10;
+ n->instead = $12;
+ n->actions = $13;
+ $$ = (Node *)n;
+ }
+ ;
+
+OptStmtList: NOTHING { $$ = NIL; }
+ | OptimizableStmt { $$ = lcons($1, NIL); }
+ | '[' OptStmtBlock ']' { $$ = $2; }
+ ;
+
+OptStmtBlock: OptimizableStmt
+ { $$ = lcons($1, NIL); }
+ | OptimizableStmt ';'
+ { $$ = lcons($1, NIL); }
+ | OptStmtBlock OptimizableStmt
+ { $$ = lappend($1, $2); }
+ ;
+
+event_object: relation_name '.' attr_name
+ {
+ $$ = makeNode(Attr);
+ $$->relname = $1;
+ $$->paramNo = NULL;
+ $$->attrs = lcons(makeString($3), NIL);
+ $$->indirection = NIL;
+ }
+ | relation_name
+ {
+ $$ = makeNode(Attr);
+ $$->relname = $1;
+ $$->paramNo = NULL;
+ $$->attrs = NIL;
+ $$->indirection = NIL;
+ }
+ ;
+
+/* change me to select, update, etc. some day */
+event: SELECT { $$ = CMD_SELECT; }
+ | UPDATE { $$ = CMD_UPDATE; }
+ | DELETE { $$ = CMD_DELETE; }
+ | INSERT { $$ = CMD_INSERT; }
+ ;
+
+opt_instead: INSTEAD { $$ = TRUE; }
+ | /* EMPTY */ { $$ = FALSE; }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * NOTIFY can appear both in rule bodies and
+ * as a query-level command
+ *
+ *****************************************************************************/
+
+NotifyStmt: NOTIFY relation_name
+ {
+ NotifyStmt *n = makeNode(NotifyStmt);
+ n->relname = $2;
+ $$ = (Node *)n;
+ }
+ ;
+
+ListenStmt: LISTEN relation_name
+ {
+ ListenStmt *n = makeNode(ListenStmt);
+ n->relname = $2;
+ $$ = (Node *)n;
+ }
+;
+
+
+/*****************************************************************************
+ *
+ * Transactions:
+ *
+ * abort transaction
+ * (ABORT)
+ * begin transaction
+ * (BEGIN)
+ * end transaction
+ * (END)
+ *
+ *****************************************************************************/
+
+TransactionStmt: ABORT_TRANS TRANSACTION
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = ABORT_TRANS;
+ $$ = (Node *)n;
+ }
+ | BEGIN_TRANS TRANSACTION
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = BEGIN_TRANS;
+ $$ = (Node *)n;
+ }
+ | BEGIN_TRANS WORK
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = BEGIN_TRANS;
+ $$ = (Node *)n;
+ }
+ | COMMIT WORK
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = END_TRANS;
+ $$ = (Node *)n;
+ }
+ | END_TRANS TRANSACTION
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = END_TRANS;
+ $$ = (Node *)n;
+ }
+ | ROLLBACK WORK
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = ABORT_TRANS;
+ $$ = (Node *)n;
+ }
+
+ | ABORT_TRANS
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = ABORT_TRANS;
+ $$ = (Node *)n;
+ }
+ | BEGIN_TRANS
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = BEGIN_TRANS;
+ $$ = (Node *)n;
+ }
+ | COMMIT
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = END_TRANS;
+ $$ = (Node *)n;
+ }
+
+ | END_TRANS
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = END_TRANS;
+ $$ = (Node *)n;
+ }
+ | ROLLBACK
+ {
+ TransactionStmt *n = makeNode(TransactionStmt);
+ n->command = ABORT_TRANS;
+ $$ = (Node *)n;
+ }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * define view '('target-list ')' [where ]
+ *
+ *****************************************************************************/
+
+ViewStmt: CREATE VIEW name AS RetrieveStmt
+ {
+ ViewStmt *n = makeNode(ViewStmt);
+ n->viewname = $3;
+ n->query = (Query *)$5;
+ $$ = (Node *)n;
+ }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * load "filename"
+ *
+ *****************************************************************************/
+
+LoadStmt: LOAD file_name
+ {
+ LoadStmt *n = makeNode(LoadStmt);
+ n->filename = $2;
+ $$ = (Node *)n;
+ }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * createdb dbname
+ *
+ *****************************************************************************/
+
+CreatedbStmt: CREATE DATABASE database_name
+ {
+ CreatedbStmt *n = makeNode(CreatedbStmt);
+ n->dbname = $3;
+ $$ = (Node *)n;
+ }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * destroydb dbname
+ *
+ *****************************************************************************/
+
+DestroydbStmt: DROP DATABASE database_name
+ {
+ DestroydbStmt *n = makeNode(DestroydbStmt);
+ n->dbname = $3;
+ $$ = (Node *)n;
+ }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * cluster on
+ *
+ *****************************************************************************/
+
+ClusterStmt: CLUSTER index_name ON relation_name
+ {
+ ClusterStmt *n = makeNode(ClusterStmt);
+ n->relname = $4;
+ n->indexname = $2;
+ $$ = (Node*)n;
+ }
+ ;
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * vacuum
+ *
+ *****************************************************************************/
+
+VacuumStmt: VACUUM
+ {
+ $$ = (Node *)makeNode(VacuumStmt);
+ }
+ | VACUUM relation_name
+ {
+ VacuumStmt *n = makeNode(VacuumStmt);
+ n->vacrel = $2;
+ $$ = (Node *)n;
+ }
+ ;
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * EXPLAIN query
+ *
+ *****************************************************************************/
+
+ExplainStmt: EXPLAIN explain_options OptimizableStmt
+ {
+ ExplainStmt *n = makeNode(ExplainStmt);
+ n->query = (Query*)$3;
+ n->options = $2;
+ $$ = (Node *)n;
+ }
+ ;
+
+explain_options: WITH name_list
+ { $$ = $2; }
+ | /*EMPTY*/
+ { $$ = NIL; }
+ ;
+
+/*****************************************************************************
+ * *
+ * Optimizable Stmts: *
+ * *
+ * one of the five queries processed by the planner *
+ * *
+ * [ultimately] produces query-trees as specified *
+ * in the query-spec document in ~postgres/ref *
+ * *
+ *****************************************************************************/
+
+OptimizableStmt: RetrieveStmt
+ | CursorStmt
+ | ReplaceStmt
+ | AppendStmt
+ | NotifyStmt
+ | DeleteStmt /* by default all are $$=$1 */
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * INSERT STATEMENTS
+ *
+ *****************************************************************************/
+
+AppendStmt: INSERT INTO relation_name opt_column_list insert_rest
+ {
+ $5->relname = $3;
+ $5->cols = $4;
+ $$ = (Node *)$5;
+ }
+ ;
+
+insert_rest: VALUES '(' exprList ')'
+ {
+ $$ = makeNode(AppendStmt);
+ $$->exprs = $3;
+ $$->fromClause = NIL;
+ $$->whereClause = NULL;
+ }
+ | SELECT exprList from_clause where_clause
+ {
+ $$ = makeNode(AppendStmt);
+ $$->exprs = $2;
+ $$->fromClause = $3;
+ $$->whereClause = $4;
+ }
+ ;
+
+opt_column_list: '(' columnList ')' { $$ = $2; }
+ | /*EMPTY*/ { $$ = NIL; }
+ ;
+
+columnList:
+ columnList ',' columnElem
+ { $$ = lappend($1, $3); }
+ | columnElem
+ { $$ = lcons($1, NIL); }
+ ;
+
+columnElem: Id opt_indirection
+ {
+ Ident *id = makeNode(Ident);
+ id->name = $1;
+ id->indirection = $2;
+ $$ = (Node *)id;
+ }
+ ;
+
+exprList: exprList ',' exprElem
+ { $$ = lappend($1, $3); }
+ | exprElem
+ { $$ = lcons($1, NIL); }
+
+ ;
+
+exprElem: a_expr
+ { $$ = (Node *)$1; }
+ | relation_name '.' '*'
+ {
+ Attr *n = makeNode(Attr);
+ n->relname = $1;
+ n->paramNo = NULL;
+ n->attrs = lcons(makeString("*"), NIL);
+ n->indirection = NIL;
+ $$ = (Node *)n;
+ }
+ | '*'
+ {
+ Attr *n = makeNode(Attr);
+ n->relname = "*";
+ n->paramNo = NULL;
+ n->attrs = NIL;
+ n->indirection = NIL;
+ $$ = (Node *)n;
+ }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * DELETE STATEMENTS
+ *
+ *****************************************************************************/
+
+DeleteStmt: DELETE FROM relation_name
+ where_clause
+ {
+ DeleteStmt *n = makeNode(DeleteStmt);
+ n->relname = $3;
+ n->whereClause = $4;
+ $$ = (Node *)n;
+ }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * ReplaceStmt (UPDATE)
+ *
+ *****************************************************************************/
+
+ReplaceStmt: UPDATE relation_name
+ SET res_target_list
+ from_clause
+ where_clause
+ {
+ ReplaceStmt *n = makeNode(ReplaceStmt);
+ n->relname = $2;
+ n->targetList = $4;
+ n->fromClause = $5;
+ n->whereClause = $6;
+ $$ = (Node *)n;
+ }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * CURSOR STATEMENTS
+ *
+ *****************************************************************************/
+
+CursorStmt: DECLARE name opt_binary CURSOR FOR
+ SELECT opt_unique res_target_list2
+ from_clause where_clause sort_clause
+ {
+ CursorStmt *n = makeNode(CursorStmt);
+
+ /* from PORTAL name */
+ /*
+ * 15 august 1991 -- since 3.0 postgres does locking
+ * right, we discovered that portals were violating
+ * locking protocol. portal locks cannot span xacts.
+ * as a short-term fix, we installed the check here.
+ * -- mao
+ */
+ if (!IsTransactionBlock())
+ elog(WARN, "Named portals may only be used in begin/end transaction blocks.");
+
+ n->portalname = $2;
+ n->binary = $3;
+ n->unique = $7;
+ n->targetList = $8;
+ n->fromClause = $9;
+ n->whereClause = $10;
+ n->orderClause = $11;
+ $$ = (Node *)n;
+ }
+ ;
+
+
+/*****************************************************************************
+ *
+ * QUERY:
+ * SELECT STATEMENTS
+ *
+ *****************************************************************************/
+
+RetrieveStmt: SELECT opt_unique res_target_list2
+ result from_clause where_clause
+ group_clause having_clause
+ sort_clause
+ {
+ RetrieveStmt *n = makeNode(RetrieveStmt);
+ n->unique = $2;
+ n->targetList = $3;
+ n->into = $4;
+ n->fromClause = $5;
+ n->whereClause = $6;
+ n->groupClause = $7;
+ n->havingClause = $8;
+ n->orderClause = $9;
+ $$ = (Node *)n;
+ }
+ ;
+
+result: INTO TABLE relation_name
+ { $$= $3; /* should check for archive level */ }
+ | /*EMPTY*/
+ { $$ = NULL; }
+ ;
+
+opt_unique: DISTINCT { $$ = "*"; }
+ | DISTINCT ON Id { $$ = $3; }
+ | /*EMPTY*/ { $$ = NULL;}
+ ;
+
+sort_clause: ORDER BY sortby_list { $$ = $3; }
+ | /*EMPTY*/ { $$ = NIL; }
+ ;
+
+sortby_list: sortby
+ { $$ = lcons($1, NIL); }
+ | sortby_list ',' sortby
+ { $$ = lappend($1, $3); }
+ ;
+
+sortby: Id OptUseOp
+ {
+ $$ = makeNode(SortBy);
+ $$->name = $1;
+ $$->useOp = $2;
+ }
+ | attr OptUseOp
+ {
+ yyerror("parse error: use 'sort by attribute_name'");
+ }
+ ;
+
+OptUseOp: USING Op { $$ = $2; }
+ | USING '<' { $$ = "<"; }
+ | USING '>' { $$ = ">"; }
+ | ASC { $$ = "<"; }
+ | DESC { $$ = ">"; }
+ | /*EMPTY*/ { $$ = "<"; /*default*/ }
+ ;
+
+
+index_params: index_elem { $$ = lcons($1,NIL); }
+ | func_index { $$ = lcons($1,NIL); }
+ ;
+
+/*index_list:
+ index_list ',' index_elem
+ { $$ = lappend($1, $3); }
+ | index_elem
+ { $$ = lcons($1, NIL); }
+ ;*/
+
+func_index: name '(' name_list ')' opt_class
+ {
+ $$ = makeNode(IndexElem);
+ $$->name = $1;
+ $$->args = $3;
+ $$->class = $5;
+ }
+ ;
+
+index_elem: attr_name opt_class
+ {
+ $$ = makeNode(IndexElem);
+ $$->name = $1;
+ $$->args = NIL;
+ $$->class = $2;
+ }
+ ;
+
+opt_class: class
+ | WITH class { $$ = $2; }
+ | /*EMPTY*/ { $$ = NULL; }
+ ;
+
+/*
+ * jimmy bell-style recursive queries aren't supported in the
+ * current system.
+ *
+ * ...however, recursive addattr and rename supported. make special
+ * cases for these.
+ *
+ * XXX i believe '*' should be the default behavior, but...
+ */
+opt_inh_star: '*' { $$ = TRUE; }
+ | /*EMPTY*/ { $$ = FALSE; }
+ ;
+
+relation_name_list: name_list ;
+
+name_list: name
+ { $$=lcons(makeString($1),NIL); }
+ | name_list ',' name
+ { $$=lappend($1,makeString($3)); }
+ ;
+
+group_clause: GROUP BY groupby_list { $$ = $3; }
+ | /*EMPTY*/ { $$ = NIL; }
+ ;
+
+groupby_list: groupby { $$ = lcons($1, NIL); }
+ | groupby_list ',' groupby { $$ = lappend($1, $3); }
+ ;
+
+groupby: Id
+ {
+ Ident *n = makeNode(Ident);
+ n->name = $1;
+ n->indirection = NULL;
+ $$ = (Node*)n;
+ }
+ | attr
+ {
+ $$ = (Node*)$1;
+ }
+ ;
+
+having_clause: HAVING a_expr { $$ = $2; }
+ | /*EMPTY*/ { $$ = NULL; }
+ ;
+
+/*****************************************************************************
+ *
+ * clauses common to all Optimizable Stmts:
+ * from_clause -
+ * where_clause -
+ *
+ *****************************************************************************/
+
+from_clause: FROM from_list { $$ = $2; }
+ | /*EMPTY*/ { $$ = NIL; }
+ ;
+
+from_list: from_list ',' from_val
+ { $$ = lappend($1, $3); }
+ | from_val
+ { $$ = lcons($1, NIL); }
+ ;
+
+from_val: relation_expr AS var_name
+ {
+ $$ = makeNode(RangeVar);
+ $$->relExpr = $1;
+ $$->name = $3;
+ }
+ | relation_expr var_name
+ {
+ $$ = makeNode(RangeVar);
+ $$->relExpr = $1;
+ $$->name = $2;
+ }
+ | relation_expr
+ {
+ $$ = makeNode(RangeVar);
+ $$->relExpr = $1;
+ $$->name = NULL;
+ }
+ ;
+
+where_clause: WHERE a_expr { $$ = $2; }
+ | /*EMPTY*/ { $$ = NULL; /* no qualifiers */ }
+ ;
+
+relation_expr: relation_name
+ {
+ /* normal relations */
+ $$ = makeNode(RelExpr);
+ $$->relname = $1;
+ $$->inh = FALSE;
+ $$->timeRange = NULL;
+ }
+ | relation_name '*' %prec '='
+ {
+ /* inheiritance query */
+ $$ = makeNode(RelExpr);
+ $$->relname = $1;
+ $$->inh = TRUE;
+ $$->timeRange = NULL;
+ }
+ | relation_name time_range
+ {
+ /* time-qualified query */
+ $$ = makeNode(RelExpr);
+ $$->relname = $1;
+ $$->inh = FALSE;
+ $$->timeRange = $2;
+ }
+ ;
+
+
+time_range: '[' opt_range_start ',' opt_range_end ']'
+ {
+ $$ = makeNode(TimeRange);
+ $$->startDate = $2;
+ $$->endDate = $4;
+ }
+ | '[' date ']'
+ {
+ $$ = makeNode(TimeRange);
+ $$->startDate = $2;
+ $$->endDate = NULL;
+ }
+ ;
+
+opt_range_start: date
+ | /*EMPTY*/ { $$ = "epoch"; }
+ ;
+
+opt_range_end: date
+ | /*EMPTY*/ { $$ = "now"; }
+ ;
+
+opt_array_bounds: '[' ']' nest_array_bounds
+ { $$ = lcons(makeInteger(-1), $3); }
+ | '[' Iconst ']' nest_array_bounds
+ { $$ = lcons(makeInteger($2), $4); }
+ | /* EMPTY */
+ { $$ = NIL; }
+ ;
+
+nest_array_bounds: '[' ']' nest_array_bounds
+ { $$ = lcons(makeInteger(-1), $3); }
+ | '[' Iconst ']' nest_array_bounds
+ { $$ = lcons(makeInteger($2), $4); }
+ | /*EMPTY*/
+ { $$ = NIL; }
+ ;
+
+typname: name
+ {
+ char *tname = xlateSqlType($1);
+ $$ = makeNode(TypeName);
+ $$->name = tname;
+
+ /* Is this the name of a complex type? If so, implement
+ * it as a set.
+ */
+ if (!strcmp(saved_relname, tname)) {
+ /* This attr is the same type as the relation
+ * being defined. The classic example: create
+ * emp(name=text,mgr=emp)
+ */
+ $$->setof = TRUE;
+ }else if (get_typrelid((Type)type(tname))
+ != InvalidOid) {
+ /* (Eventually add in here that the set can only
+ * contain one element.)
+ */
+ $$->setof = TRUE;
+ } else {
+ $$->setof = FALSE;
+ }
+ }
+ | SETOF name
+ {
+ $$ = makeNode(TypeName);
+ $$->name = $2;
+ $$->setof = TRUE;
+ }
+ ;
+
+Typename: typname opt_array_bounds
+ {
+ $$ = $1;
+ $$->arrayBounds = $2;
+ }
+ | name '(' Iconst ')'
+ {
+ /*
+ * The following implements char() and varchar().
+ * We do it here instead of the 'typname:' production
+ * because we don't want to allow arrays of varchar().
+ * I haven't thought about whether that will work or not.
+ * - ay 6/95
+ */
+ $$ = makeNode(TypeName);
+ if (!strcasecmp($1, "char")) {
+ $$->name = "bpchar"; /* strdup("bpchar"); */
+ } else if (!strcasecmp($1, "varchar")) {
+ $$->name = "varchar"; /* strdup("varchar"); */
+ } else {
+ yyerror("parse error");
+ }
+ if ($3 < 1) {
+ elog(WARN, "length for '%s' type must be at least 1",
+ $1);
+ } else if ($3 > 4096) {
+ /* we can store a char() of length up to the size
+ of a page (8KB) - page headers and friends but
+ just to be safe here... - ay 6/95 */
+ elog(WARN, "length for '%s' type cannot exceed 4096",
+ $1);
+ }
+ /* we actually implement this sort of like a varlen, so
+ the first 4 bytes is the length. (the difference
+ between this and "text" is that we blank-pad and
+ truncate where necessary */
+ $$->typlen = 4 + $3;
+ }
+ ;
+
+
+/*****************************************************************************
+ *
+ * expression grammar, still needs some cleanup
+ *
+ *****************************************************************************/
+
+a_expr: attr opt_indirection
+ {
+ $1->indirection = $2;
+ $$ = (Node *)$1;
+ }
+ | AexprConst
+ { $$ = $1; }
+ | '-' a_expr %prec UMINUS
+ { $$ = makeA_Expr(OP, "-", NULL, $2); }
+ | a_expr '+' a_expr
+ { $$ = makeA_Expr(OP, "+", $1, $3); }
+ | a_expr '-' a_expr
+ { $$ = makeA_Expr(OP, "-", $1, $3); }
+ | a_expr '/' a_expr
+ { $$ = makeA_Expr(OP, "/", $1, $3); }
+ | a_expr '*' a_expr
+ { $$ = makeA_Expr(OP, "*", $1, $3); }
+ | a_expr '<' a_expr
+ { $$ = makeA_Expr(OP, "<", $1, $3); }
+ | a_expr '>' a_expr
+ { $$ = makeA_Expr(OP, ">", $1, $3); }
+ | a_expr '=' a_expr
+ { $$ = makeA_Expr(OP, "=", $1, $3); }
+ | ':' a_expr
+ { $$ = makeA_Expr(OP, ":", NULL, $2); }
+ | ';' a_expr
+ { $$ = makeA_Expr(OP, ";", NULL, $2); }
+ | '|' a_expr
+ { $$ = makeA_Expr(OP, "|", NULL, $2); }
+ | AexprConst TYPECAST Typename
+ {
+ /* AexprConst can be either A_Const or ParamNo */
+ if (nodeTag($1) == T_A_Const) {
+ ((A_Const *)$1)->typename = $3;
+ }else {
+ ((ParamNo *)$1)->typename = $3;
+ }
+ $$ = (Node *)$1;
+ }
+ | CAST AexprConst AS Typename
+ {
+ /* AexprConst can be either A_Const or ParamNo */
+ if (nodeTag($2) == T_A_Const) {
+ ((A_Const *)$2)->typename = $4;
+ }else {
+ ((ParamNo *)$2)->typename = $4;
+ }
+ $$ = (Node *)$2;
+ }
+ | '(' a_expr ')'
+ { $$ = $2; }
+ | a_expr Op a_expr
+ { $$ = makeA_Expr(OP, $2, $1, $3); }
+ | a_expr LIKE a_expr
+ { $$ = makeA_Expr(OP, "~~", $1, $3); }
+ | a_expr NOT LIKE a_expr
+ { $$ = makeA_Expr(OP, "!~~", $1, $4); }
+ | Op a_expr
+ { $$ = makeA_Expr(OP, $1, NULL, $2); }
+ | a_expr Op
+ { $$ = makeA_Expr(OP, $2, $1, NULL); }
+ | Id
+ { /* could be a column name or a relation_name */
+ Ident *n = makeNode(Ident);
+ n->name = $1;
+ n->indirection = NULL;
+ $$ = (Node *)n;
+ }
+ | name '(' '*' ')'
+ {
+ FuncCall *n = makeNode(FuncCall);
+ Ident *star = makeNode(Ident);
+
+ /* cheap hack for aggregate (eg. count) */
+ star->name = "oid";
+ n->funcname = $1;
+ n->args = lcons(star, NIL);
+ $$ = (Node *)n;
+ }
+ | name '(' ')'
+ {
+ FuncCall *n = makeNode(FuncCall);
+ n->funcname = $1;
+ n->args = NIL;
+ $$ = (Node *)n;
+ }
+ | name '(' expr_list ')'
+ {
+ FuncCall *n = makeNode(FuncCall);
+ n->funcname = $1;
+ n->args = $3;
+ $$ = (Node *)n;
+ }
+ | a_expr ISNULL
+ { $$ = makeA_Expr(ISNULL, NULL, $1, NULL); }
+ | a_expr NOTNULL
+ { $$ = makeA_Expr(NOTNULL, NULL, $1, NULL); }
+ | a_expr AND a_expr
+ { $$ = makeA_Expr(AND, NULL, $1, $3); }
+ | a_expr OR a_expr
+ { $$ = makeA_Expr(OR, NULL, $1, $3); }
+ | NOT a_expr
+ { $$ = makeA_Expr(NOT, NULL, NULL, $2); }
+ ;
+
+opt_indirection: '[' a_expr ']' opt_indirection
+ {
+ A_Indices *ai = makeNode(A_Indices);
+ ai->lidx = NULL;
+ ai->uidx = $2;
+ $$ = lcons(ai, $4);
+ }
+ | '[' a_expr ':' a_expr ']' opt_indirection
+ {
+ A_Indices *ai = makeNode(A_Indices);
+ ai->lidx = $2;
+ ai->uidx = $4;
+ $$ = lcons(ai, $6);
+ }
+ | /* EMPTY */
+ { $$ = NIL; }
+ ;
+
+expr_list: a_expr
+ { $$ = lcons($1, NIL); }
+ | expr_list ',' a_expr
+ { $$ = lappend($1, $3); }
+ ;
+
+attr: relation_name '.' attrs
+ {
+ $$ = makeNode(Attr);
+ $$->relname = $1;
+ $$->paramNo = NULL;
+ $$->attrs = $3;
+ $$->indirection = NULL;
+ }
+ | ParamNo '.' attrs
+ {
+ $$ = makeNode(Attr);
+ $$->relname = NULL;
+ $$->paramNo = $1;
+ $$->attrs = $3;
+ $$->indirection = NULL;
+ }
+ ;
+
+attrs: attr_name
+ { $$ = lcons(makeString($1), NIL); }
+ | attrs '.' attr_name
+ { $$ = lappend($1, makeString($3)); }
+ | attrs '.' '*'
+ { $$ = lappend($1, makeString("*")); }
+ ;
+
+
+/*****************************************************************************
+ *
+ * target lists
+ *
+ *****************************************************************************/
+
+res_target_list: res_target_list ',' res_target_el
+ { $$ = lappend($1,$3); }
+ | res_target_el
+ { $$ = lcons($1, NIL); }
+ | '*'
+ {
+ ResTarget *rt = makeNode(ResTarget);
+ Attr *att = makeNode(Attr);
+ att->relname = "*";
+ att->paramNo = NULL;
+ att->attrs = NULL;
+ att->indirection = NIL;
+ rt->name = NULL;
+ rt->indirection = NULL;
+ rt->val = (Node *)att;
+ $$ = lcons(rt, NIL);
+ }
+ ;
+
+res_target_el: Id opt_indirection '=' a_expr
+ {
+ $$ = makeNode(ResTarget);
+ $$->name = $1;
+ $$->indirection = $2;
+ $$->val = (Node *)$4;
+ }
+ | attr opt_indirection
+ {
+ $$ = makeNode(ResTarget);
+ $$->name = NULL;
+ $$->indirection = $2;
+ $$->val = (Node *)$1;
+ }
+ | relation_name '.' '*'
+ {
+ Attr *att = makeNode(Attr);
+ att->relname = $1;
+ att->paramNo = NULL;
+ att->attrs = lcons(makeString("*"), NIL);
+ att->indirection = NIL;
+ $$ = makeNode(ResTarget);
+ $$->name = NULL;
+ $$->indirection = NULL;
+ $$->val = (Node *)att;
+ }
+ ;
+
+/*
+** target list for select.
+** should get rid of the other but is still needed by the defunct retrieve into
+** and update (uses a subset)
+*/
+res_target_list2:
+ res_target_list2 ',' res_target_el2
+ { $$ = lappend($1, $3); }
+ | res_target_el2
+ { $$ = lcons($1, NIL); }
+ | '*'
+ {
+ ResTarget *rt = makeNode(ResTarget);
+ Attr *att = makeNode(Attr);
+ att->relname = "*";
+ att->paramNo = NULL;
+ att->attrs = NULL;
+ att->indirection = NIL;
+ rt->name = NULL;
+ rt->indirection = NULL;
+ rt->val = (Node *)att;
+ $$ = lcons(rt, NIL);
+ }
+ ;
+
+/* AS is not optional because shift/red conflict with unary ops */
+res_target_el2: a_expr AS Id
+ {
+ $$ = makeNode(ResTarget);
+ $$->name = $3;
+ $$->indirection = NULL;
+ $$->val = (Node *)$1;
+ }
+ | a_expr
+ {
+ $$ = makeNode(ResTarget);
+ $$->name = NULL;
+ $$->indirection = NULL;
+ $$->val = (Node *)$1;
+ }
+ | relation_name '.' '*'
+ {
+ Attr *att = makeNode(Attr);
+ att->relname = $1;
+ att->paramNo = NULL;
+ att->attrs = lcons(makeString("*"), NIL);
+ att->indirection = NIL;
+ $$ = makeNode(ResTarget);
+ $$->name = NULL;
+ $$->indirection = NULL;
+ $$->val = (Node *)att;
+ }
+ ;
+
+opt_id: Id { $$ = $1; }
+ | /* EMPTY */ { $$ = NULL; }
+ ;
+
+relation_name: SpecialRuleRelation
+ {
+ $$ = $1;
+ strcpy(saved_relname, $1);
+ }
+ | Id
+ {
+ /* disallow refs to magic system tables */
+ if (strcmp(LogRelationName, $1) == 0
+ || strcmp(VariableRelationName, $1) == 0
+ || strcmp(TimeRelationName, $1) == 0
+ || strcmp(MagicRelationName, $1) == 0) {
+ elog(WARN, "%s cannot be accessed by users", $1);
+ } else {
+ $$ = $1;
+ }
+ strcpy(saved_relname, $1);
+ }
+ ;
+
+database_name: Id { $$ = $1; };
+access_method: Id { $$ = $1; };
+attr_name: Id { $$ = $1; };
+class: Id { $$ = $1; };
+index_name: Id { $$ = $1; };
+var_name: Id { $$ = $1; };
+name: Id { $$ = $1; };
+
+date: Sconst { $$ = $1; };
+file_name: Sconst { $$ = $1; };
+recipe_name: Id { $$ = $1; };
+
+AexprConst: Iconst
+ {
+ A_Const *n = makeNode(A_Const);
+ n->val.type = T_Integer;
+ n->val.val.ival = $1;
+ $$ = (Node *)n;
+ }
+ | FCONST
+ {
+ A_Const *n = makeNode(A_Const);
+ n->val.type = T_Float;
+ n->val.val.dval = $1;
+ $$ = (Node *)n;
+ }
+ | Sconst
+ {
+ A_Const *n = makeNode(A_Const);
+ n->val.type = T_String;
+ n->val.val.str = $1;
+ $$ = (Node *)n;
+ }
+ | ParamNo
+ { $$ = (Node *)$1; }
+ | Pnull
+ {
+ A_Const *n = makeNode(A_Const);
+ n->val.type = T_Null;
+ $$ = (Node *)n;
+ }
+ ;
+
+ParamNo: PARAM
+ {
+ $$ = makeNode(ParamNo);
+ $$->number = $1;
+ }
+ ;
+
+NumConst: Iconst { $$ = makeInteger($1); }
+ | FCONST { $$ = makeFloat($1); }
+ ;
+
+Iconst: ICONST { $$ = $1; };
+Sconst: SCONST { $$ = $1; };
+
+Id: IDENT { $$ = $1; };
+
+SpecialRuleRelation: CURRENT
+ {
+ if (QueryIsRule)
+ $$ = "*CURRENT*";
+ else
+ elog(WARN,"CURRENT used in non-rule query");
+ }
+ | NEW
+ {
+ if (QueryIsRule)
+ $$ = "*NEW*";
+ else
+ elog(WARN,"NEW used in non-rule query");
+ }
+ ;
+
+Type: P_TYPE;
+Pnull: PNULL;
+
+
+%%
+
+static Node *makeA_Expr(int op, char *opname, Node *lexpr, Node *rexpr)
+{
+ A_Expr *a = makeNode(A_Expr);
+ a->oper = op;
+ a->opname = opname;
+ a->lexpr = lexpr;
+ a->rexpr = rexpr;
+ return (Node *)a;
+}
+
+static char *
+xlateSqlType(char *name)
+{
+ if (!strcasecmp(name,"int") ||
+ !strcasecmp(name,"integer"))
+ return "int4"; /* strdup("int4") -- strdup leaks memory here */
+ else if (!strcasecmp(name, "smallint"))
+ return "int2";
+ else if (!strcasecmp(name, "float") ||
+ !strcasecmp(name, "real"))
+ return "float4";
+ else
+ return name;
+}
+
+void parser_init(Oid *typev, int nargs)
+{
+ QueryIsRule = false;
+ saved_relname[0]= '\0';
+
+ param_type_init(typev, nargs);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * keywords.c--
+ * lexical token lookup for reserved words in postgres SQL
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/parser/keywords.c,v 1.1.1.1 1996/07/09 06:21:40 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/parsenodes.h"
+#include "parse.h"
+#include "utils/elog.h"
+#include "parser/keywords.h"
+#include "parser/dbcommands.h" /* createdb, destroydb stop_vacuum */
+
+
+/*
+ * List of (keyword-name, keyword-token-value) pairs.
+ *
+ * !!WARNING!!: This list must be sorted, because binary
+ * search is used to locate entries.
+ */
+static ScanKeyword ScanKeywords[] = {
+ /* name value */
+ { "abort", ABORT_TRANS },
+ { "acl", ACL },
+ { "add", ADD },
+ { "after", AFTER },
+ { "aggregate", AGGREGATE },
+ { "all", ALL },
+ { "alter", ALTER },
+ { "and", AND },
+ { "append", APPEND },
+ { "archIve", ARCHIVE }, /* XXX crooked: I < _ */
+ { "arch_store", ARCH_STORE },
+ { "archive", ARCHIVE }, /* XXX crooked: i > _ */
+ { "as", AS },
+ { "asc", ASC },
+ { "backward", BACKWARD },
+ { "before", BEFORE },
+ { "begin", BEGIN_TRANS },
+ { "binary", BINARY },
+ { "by", BY },
+ { "cast", CAST },
+ { "change", CHANGE },
+ { "close", CLOSE },
+ { "cluster", CLUSTER },
+ { "column", COLUMN },
+ { "commit", COMMIT },
+ { "copy", COPY },
+ { "create", CREATE },
+ { "current", CURRENT },
+ { "cursor", CURSOR },
+ { "database", DATABASE },
+ { "declare", DECLARE },
+ { "delete", DELETE },
+ { "delimiters", DELIMITERS },
+ { "desc", DESC },
+ { "distinct", DISTINCT },
+ { "do", DO },
+ { "drop", DROP },
+ { "end", END_TRANS },
+ { "execute", EXECUTE },
+ { "explain", EXPLAIN },
+ { "extend", EXTEND },
+ { "fetch", FETCH },
+ { "for", FOR },
+ { "forward", FORWARD },
+ { "from", FROM },
+ { "function", FUNCTION },
+ { "grant", GRANT },
+ { "group", GROUP },
+ { "having", HAVING },
+ { "heavy", HEAVY },
+ { "in", IN },
+ { "index", INDEX },
+ { "inherits", INHERITS },
+ { "insert", INSERT },
+ { "instead", INSTEAD },
+ { "into", INTO },
+ { "isnull", ISNULL },
+ { "language", LANGUAGE },
+ { "light", LIGHT },
+ { "like", LIKE },
+ { "listen", LISTEN },
+ { "load", LOAD },
+ { "merge", MERGE },
+ { "move", MOVE },
+ { "new", NEW },
+ { "none", NONE },
+ { "not", NOT },
+ { "nothing", NOTHING },
+ { "notify", NOTIFY },
+ { "notnull", NOTNULL },
+ { "null", PNULL },
+ { "on", ON },
+ { "operator", OPERATOR },
+ { "option", OPTION },
+ { "or", OR },
+ { "order", ORDER },
+ { "privileges", PRIVILEGES },
+ { "public", PUBLIC },
+ { "purge", PURGE },
+ { "recipe", RECIPE },
+ { "rename", RENAME },
+ { "replace", REPLACE },
+ { "retrieve", RETRIEVE },
+ { "returns", RETURNS },
+ { "revoke", REVOKE },
+ { "rollback", ROLLBACK },
+ { "rule", RULE },
+ { "select", SELECT },
+ { "set", SET },
+ { "setof", SETOF },
+ { "stdin", STDIN },
+ { "stdout", STDOUT },
+ { "store", STORE },
+ { "table", TABLE },
+ { "to", TO },
+ { "transaction", TRANSACTION },
+ { "type", P_TYPE },
+ { "update", UPDATE },
+ { "using", USING },
+ { "vacuum", VACUUM },
+ { "values", VALUES },
+ { "version", VERSION },
+ { "view", VIEW },
+ { "where", WHERE },
+ { "with", WITH },
+ { "work", WORK },
+};
+
+ScanKeyword *
+ScanKeywordLookup(char *text)
+{
+ ScanKeyword *low = &ScanKeywords[0];
+ ScanKeyword *high = endof(ScanKeywords) - 1;
+ ScanKeyword *middle;
+ int difference;
+
+ while (low <= high) {
+ middle = low + (high - low) / 2;
+ /* keywords case-insensitive (for SQL) -- ay 8/94 */
+ difference = strcasecmp(middle->name, text);
+ if (difference == 0)
+ return (middle);
+ else if (difference < 0)
+ low = middle + 1;
+ else
+ high = middle - 1;
+ }
+
+ return (NULL);
+}
+
+char*
+AtomValueGetString(int atomval)
+{
+ ScanKeyword *low = &ScanKeywords[0];
+ ScanKeyword *high = endof(ScanKeywords) - 1;
+ int keyword_list_length = (high-low);
+ int i;
+
+ for (i=0; i < keyword_list_length ; i++ )
+ if (ScanKeywords[i].value == atomval )
+ return(ScanKeywords[i].name);
+
+ elog(WARN,"AtomGetString called with bogus atom # : %d", atomval );
+ return(NULL);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * keywords.h--
+ * string,atom lookup thingy, reduces strcmp traffic greatly
+ * in the bowels of the system. Look for actual defs in lib/C/atoms.c
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: keywords.h,v 1.1.1.1 1996/07/09 06:21:40 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef KEYWORDS_H
+#define KEYWORDS_H
+
+typedef struct ScanKeyword {
+ char *name;
+ int value;
+} ScanKeyword;
+
+extern ScanKeyword *ScanKeywordLookup(char *text);
+extern char* AtomValueGetString(int atomval);
+
+#endif /* KEYWORDS_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * parse_query.c--
+ * take an "optimizable" stmt and make the query tree that
+ * the planner requires.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/parser/Attic/parse_query.c,v 1.1.1.1 1996/07/09 06:21:40 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "utils/tqual.h"
+#include "access/tupmacs.h"
+#include "utils/builtins.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/acl.h" /* for ACL_NO_PRIV_WARNING */
+#include "utils/rel.h" /* Relation stuff */
+
+#include "utils/syscache.h"
+#include "catalog/pg_type.h"
+#include "catalog_utils.h"
+#include "parser/parse_query.h"
+/* #include "parser/io.h" */
+#include "utils/lsyscache.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/primnodes.h"
+#include "nodes/parsenodes.h"
+#include "nodes/makefuncs.h"
+
+Oid *param_type_info;
+int pfunc_num_args;
+
+extern int Quiet;
+
+
+/* given range variable, return id of variable; position starts with 1 */
+int
+RangeTablePosn(List *rtable, char *rangevar)
+{
+ int index;
+ List *temp;
+
+ index = 1;
+/* temp = pstate->p_rtable; */
+ temp = rtable;
+ while (temp != NIL) {
+ RangeTblEntry *rt_entry = lfirst(temp);
+
+ if (!strcmp(rt_entry->refname, rangevar))
+ return index;
+
+ temp = lnext(temp);
+ index++;
+ }
+ return(0);
+}
+
+char*
+VarnoGetRelname(ParseState *pstate, int vnum)
+{
+ int i;
+ List *temp = pstate->p_rtable;
+ for( i = 1; i < vnum ; i++)
+ temp = lnext(temp);
+ return(((RangeTblEntry*)lfirst(temp))->relname);
+}
+
+
+RangeTblEntry *
+makeRangeTableEntry(char *relname,
+ bool inh,
+ TimeRange *timeRange,
+ char *refname)
+{
+ Relation relation;
+ RangeTblEntry *ent = makeNode(RangeTblEntry);
+
+ ent->relname = pstrdup(relname);
+ ent->refname = refname;
+
+ relation = heap_openr(ent->relname);
+ if (relation == NULL) {
+ elog(WARN,"%s: %s",
+ relname, ACL_NO_PRIV_WARNING);
+ }
+
+ /*
+ * Flags - zero or more from archive,inheritance,union,version
+ * or recursive (transitive closure)
+ * [we don't support them all -- ay 9/94 ]
+ */
+ ent->inh = inh;
+
+ ent->timeRange = timeRange;
+
+ /* RelOID */
+ ent->relid = RelationGetRelationId(relation);
+
+ /*
+ * close the relation we're done with it for now.
+ */
+ heap_close(relation);
+ return ent;
+}
+
+/*
+ * expandAll -
+ * makes a list of attributes
+ * assumes reldesc caching works
+ */
+List *
+expandAll(ParseState* pstate, char *relname, int *this_resno)
+{
+ Relation rdesc;
+ List *tall = NIL;
+ Var *varnode;
+ int i, maxattrs, first_resno;
+ int type_id, type_len, vnum;
+ char *physical_relname;
+
+ first_resno = *this_resno;
+
+ /* printf("\nExpanding %.*s.all\n", NAMEDATALEN, relname); */
+ vnum = RangeTablePosn(pstate->p_rtable, relname);
+ if ( vnum == 0 ) {
+ pstate->p_rtable = lappend(pstate->p_rtable,
+ makeRangeTableEntry(relname, FALSE, NULL,
+ relname));
+ vnum = RangeTablePosn(pstate->p_rtable, relname);
+ }
+
+ physical_relname = VarnoGetRelname(pstate, vnum);
+
+ rdesc = heap_openr(physical_relname);
+
+ if (rdesc == NULL ) {
+ elog(WARN,"Unable to expand all -- heap_openr failed on %s",
+ physical_relname);
+ return NIL;
+ }
+ maxattrs = RelationGetNumberOfAttributes(rdesc);
+
+ for ( i = maxattrs-1 ; i > -1 ; --i ) {
+ char *attrname;
+ TargetEntry *rte = makeNode(TargetEntry);
+
+ attrname = pstrdup ((rdesc->rd_att->attrs[i]->attname).data);
+ varnode = (Var*)make_var(pstate, relname, attrname, &type_id);
+ type_len = (int)tlen(get_id_type(type_id));
+
+ /* Even if the elements making up a set are complex, the
+ * set itself is not. */
+
+ rte->resdom = makeResdom((AttrNumber) i + first_resno,
+ (Oid)type_id,
+ (Size)type_len,
+ attrname,
+ (Index)0,
+ (Oid)0,
+ 0);
+ rte->expr = (Node *)varnode;
+ tall = lcons(rte, tall);
+ }
+
+ /*
+ * Close the reldesc - we're done with it now
+ */
+ heap_close(rdesc);
+ *this_resno = first_resno + maxattrs;
+ return(tall);
+}
+
+TimeQual
+makeTimeRange(char *datestring1,
+ char *datestring2,
+ int timecode) /* 0 = snapshot , 1 = timerange */
+{
+ TimeQual qual;
+ AbsoluteTime t1,t2;
+
+ switch (timecode) {
+ case 0:
+ if (datestring1 == NULL) {
+ elog(WARN, "MakeTimeRange: bad snapshot arg");
+ }
+ t1 = nabstimein(datestring1);
+ if (!AbsoluteTimeIsValid(t1)) {
+ elog(WARN, "bad snapshot time: \"%s\"",
+ datestring1);
+ }
+ qual = TimeFormSnapshotTimeQual(t1);
+ break;
+ case 1:
+ if (datestring1 == NULL) {
+ t1 = NOSTART_ABSTIME;
+ } else {
+ t1 = nabstimein(datestring1);
+ if (!AbsoluteTimeIsValid(t1)) {
+ elog(WARN,
+ "bad range start time: \"%s\"",
+ datestring1);
+ }
+ }
+ if (datestring2 == NULL) {
+ t2 = NOEND_ABSTIME;
+ } else {
+ t2 = nabstimein(datestring2);
+ if (!AbsoluteTimeIsValid(t2)) {
+ elog(WARN,
+ "bad range end time: \"%s\"",
+ datestring2);
+ }
+ }
+ qual = TimeFormRangedTimeQual(t1,t2);
+ break;
+ default:
+ elog(WARN, "MakeTimeRange: internal parser error");
+ }
+ return qual;
+}
+
+static void
+disallow_setop(char *op, Type optype, Node *operand)
+{
+ if (operand==NULL)
+ return;
+
+ if (nodeTag(operand) == T_Iter) {
+ elog(NOTICE, "An operand to the '%s' operator returns a set of %s,",
+ op, tname(optype));
+ elog(WARN, "but '%s' takes single values, not sets.",
+ op);
+ }
+}
+
+static Node *
+make_operand(char *opname,
+ Node *tree,
+ int orig_typeId,
+ int true_typeId)
+{
+ Node *result;
+ Type true_type;
+ Datum val;
+ Oid infunc;
+
+ if (tree != NULL) {
+ result = tree;
+ true_type = get_id_type(true_typeId);
+ disallow_setop(opname, true_type, result);
+ if (true_typeId != orig_typeId) { /* must coerce */
+ Const *con= (Const *)result;
+
+ Assert(nodeTag(result)==T_Const);
+ val = (Datum)textout((struct varlena *)
+ con->constvalue);
+ infunc = typeid_get_retinfunc(true_typeId);
+ con = makeNode(Const);
+ con->consttype = true_typeId;
+ con->constlen = tlen(true_type);
+ con->constvalue = (Datum)fmgr(infunc,
+ val,
+ get_typelem(true_typeId),
+ -1 /* for varchar() type */);
+ con->constisnull = false;
+ con->constbyval = true;
+ con->constisset = false;
+ result = (Node *)con;
+ }
+ }else {
+ Const *con= makeNode(Const);
+
+ con->consttype = true_typeId;
+ con->constlen = 0;
+ con->constvalue = (Datum)(struct varlena *)NULL;
+ con->constisnull = true;
+ con->constbyval = true;
+ con->constisset = false;
+ result = (Node *)con;
+ }
+
+ return result;
+}
+
+
+Expr *
+make_op(char *opname, Node *ltree, Node *rtree)
+{
+ int ltypeId, rtypeId;
+ Operator temp;
+ OperatorTupleForm opform;
+ Oper *newop;
+ Node *left, *right;
+ Expr *result;
+
+ if (rtree == NULL) {
+
+ /* right operator */
+ ltypeId = (ltree==NULL) ? UNKNOWNOID : exprType(ltree);
+ temp = right_oper(opname, ltypeId);
+ opform = (OperatorTupleForm) GETSTRUCT(temp);
+ left = make_operand(opname, ltree, ltypeId, opform->oprleft);
+ right = NULL;
+
+ }else if (ltree == NULL) {
+
+ /* left operator */
+ rtypeId = (rtree==NULL) ? UNKNOWNOID : exprType(rtree);
+ temp = left_oper(opname, rtypeId);
+ opform = (OperatorTupleForm) GETSTRUCT(temp);
+ right = make_operand(opname, rtree, rtypeId, opform->oprright);
+ left = NULL;
+
+ }else {
+
+ /* binary operator */
+ ltypeId = (ltree==NULL) ? UNKNOWNOID : exprType(ltree);
+ rtypeId = (rtree==NULL) ? UNKNOWNOID : exprType(rtree);
+ temp = oper(opname, ltypeId, rtypeId);
+ opform = (OperatorTupleForm) GETSTRUCT(temp);
+ left = make_operand(opname, ltree, ltypeId, opform->oprleft);
+ right = make_operand(opname, rtree, rtypeId, opform->oprright);
+ }
+
+ newop = makeOper(oprid(temp), /* opno */
+ InvalidOid, /* opid */
+ opform->oprresult, /* operator result type */
+ 0,
+ NULL);
+
+ result = makeNode(Expr);
+ result->typeOid = opform->oprresult;
+ result->opType = OP_EXPR;
+ result->oper = (Node *)newop;
+
+ if (!left) {
+ result->args = lcons(right, NIL);
+ } else if (!right) {
+ result->args = lcons(left, NIL);
+ } else {
+ result->args = lcons(left, lcons(right, NIL));
+ }
+
+ return result;
+}
+
+int
+find_atttype(Oid relid, char *attrname)
+{
+ int attid, vartype;
+ Relation rd;
+
+ rd = heap_open(relid);
+ if (!RelationIsValid(rd)) {
+ rd = heap_openr(tname(get_id_type(relid)));
+ if (!RelationIsValid(rd))
+ elog(WARN, "cannot compute type of att %s for relid %d",
+ attrname, relid);
+ }
+
+ attid = nf_varattno(rd, attrname);
+
+ if (attid == InvalidAttrNumber)
+ elog(WARN, "Invalid attribute %s\n", attrname);
+
+ vartype = att_typeid(rd , attid);
+
+ /*
+ * close relation we're done with it now
+ */
+ heap_close(rd);
+
+ return (vartype);
+}
+
+
+Var *
+make_var(ParseState *pstate, char *relname, char *attrname, int *type_id)
+{
+ Var *varnode;
+ int vnum, attid, vartypeid;
+ Relation rd;
+
+ vnum = RangeTablePosn(pstate->p_rtable, relname);
+
+ if (vnum == 0) {
+ pstate->p_rtable =
+ lappend(pstate->p_rtable,
+ makeRangeTableEntry(relname, FALSE,
+ NULL, relname));
+ vnum = RangeTablePosn (pstate->p_rtable, relname);
+ relname = VarnoGetRelname(pstate, vnum);
+ } else {
+ relname = VarnoGetRelname(pstate, vnum);
+ }
+
+ rd = heap_openr(relname);
+/* relid = RelationGetRelationId(rd); */
+ attid = nf_varattno(rd, (char *) attrname);
+ if (attid == InvalidAttrNumber)
+ elog(WARN, "Invalid attribute %s\n", attrname);
+ vartypeid = att_typeid(rd, attid);
+
+ varnode = makeVar(vnum, attid, vartypeid, vnum, attid);
+
+ /*
+ * close relation we're done with it now
+ */
+ heap_close(rd);
+
+ *type_id = vartypeid;
+ return varnode;
+}
+
+/*
+ * make_array_ref() -- Make an array reference node.
+ *
+ * Array references can hang off of arbitrary nested dot (or
+ * function invocation) expressions. This routine takes a
+ * tree generated by ParseFunc() and an array index and
+ * generates a new array reference tree. We do some simple
+ * typechecking to be sure the dereference is valid in the
+ * type system, but we don't do any bounds checking here.
+ *
+ * indirection is a list of A_Indices
+ */
+ArrayRef *
+make_array_ref(Node *expr,
+ List *indirection)
+{
+ Oid typearray;
+ HeapTuple type_tuple;
+ TypeTupleForm type_struct_array, type_struct_element;
+ ArrayRef *aref;
+ int reftype;
+ List *upperIndexpr=NIL;
+ List *lowerIndexpr=NIL;
+
+ typearray = (Oid) exprType(expr);
+
+ type_tuple = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(typearray),
+ 0,0,0);
+
+ if (!HeapTupleIsValid(type_tuple))
+ elog(WARN, "make_array_ref: Cache lookup failed for type %d\n",
+ typearray);
+
+ /* get the array type struct from the type tuple */
+ type_struct_array = (TypeTupleForm) GETSTRUCT(type_tuple);
+
+ if (type_struct_array->typelem == InvalidOid) {
+ elog(WARN, "make_array_ref: type %s is not an array",
+ (Name)&(type_struct_array->typname.data[0]));
+ }
+
+ /* get the type tuple for the element type */
+ type_tuple = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(type_struct_array->typelem),
+ 0,0,0);
+ if (!HeapTupleIsValid(type_tuple))
+ elog(WARN, "make_array_ref: Cache lookup failed for type %d\n",
+ typearray);
+
+ type_struct_element = (TypeTupleForm) GETSTRUCT(type_tuple);
+
+ while(indirection!=NIL) {
+ A_Indices *ind = lfirst(indirection);
+ if (ind->lidx) {
+ /* XXX assumes all lower indices non null in this case
+ */
+ lowerIndexpr = lappend(lowerIndexpr, ind->lidx);
+ }
+ upperIndexpr = lappend(upperIndexpr, ind->uidx);
+ indirection = lnext(indirection);
+ }
+ aref = makeNode(ArrayRef);
+ aref->refattrlength = type_struct_array->typlen;
+ aref->refelemlength = type_struct_element->typlen;
+ aref->refelemtype = type_struct_array->typelem;
+ aref->refelembyval = type_struct_element->typbyval;
+ aref->refupperindexpr = upperIndexpr;
+ aref->reflowerindexpr = lowerIndexpr;
+ aref->refexpr = expr;
+ aref->refassgnexpr = NULL;
+
+ if (lowerIndexpr == NIL) /* accessing a single array element */
+ reftype = aref->refelemtype;
+ else /* request to clip a part of the array, the result is another array */
+ reftype = typearray;
+
+ /* we change it to reflect the true type; since the original refelemtype
+ * doesn't seem to get used anywhere. - ay 10/94
+ */
+ aref->refelemtype = reftype;
+
+ return aref;
+}
+
+ArrayRef *
+make_array_set(Expr *target_expr,
+ List *upperIndexpr,
+ List *lowerIndexpr,
+ Expr *expr)
+{
+ Oid typearray;
+ HeapTuple type_tuple;
+ TypeTupleForm type_struct_array;
+ TypeTupleForm type_struct_element;
+ ArrayRef *aref;
+ int reftype;
+
+ typearray = exprType((Node*)target_expr);
+
+ type_tuple = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(typearray),
+ 0,0,0);
+
+ if (!HeapTupleIsValid(type_tuple))
+ elog(WARN, "make_array_ref: Cache lookup failed for type %d\n",
+ typearray);
+
+ /* get the array type struct from the type tuple */
+ type_struct_array = (TypeTupleForm) GETSTRUCT(type_tuple);
+
+ if (type_struct_array->typelem == InvalidOid) {
+ elog(WARN, "make_array_ref: type %s is not an array",
+ (Name)&(type_struct_array->typname.data[0]));
+ }
+ /* get the type tuple for the element type */
+ type_tuple = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(type_struct_array->typelem),
+ 0,0,0);
+
+ if (!HeapTupleIsValid(type_tuple))
+ elog(WARN, "make_array_ref: Cache lookup failed for type %d\n",
+ typearray);
+
+ type_struct_element = (TypeTupleForm) GETSTRUCT(type_tuple);
+
+ aref = makeNode(ArrayRef);
+ aref->refattrlength = type_struct_array->typlen;
+ aref->refelemlength = type_struct_element->typlen;
+ aref->refelemtype = type_struct_array->typelem;
+ aref->refelembyval = type_struct_element->typbyval;
+ aref->refupperindexpr = upperIndexpr;
+ aref->reflowerindexpr = lowerIndexpr;
+ aref->refexpr = (Node*)target_expr;
+ aref->refassgnexpr = (Node*)expr;
+
+ if (lowerIndexpr == NIL) /* accessing a single array element */
+ reftype = aref->refelemtype;
+ else /* request to set a part of the array, by another array */
+ reftype = typearray;
+
+ aref->refelemtype = reftype;
+
+ return aref;
+}
+
+/*
+ *
+ * make_const -
+ *
+ * - takes a lispvalue, (as returned to the yacc routine by the lexer)
+ * extracts the type, and makes the appropriate type constant
+ * by invoking the (c-callable) lisp routine c-make-const
+ * via the lisp_call() mechanism
+ *
+ * eventually, produces a "const" lisp-struct as per nodedefs.cl
+ */
+Const *
+make_const(Value *value)
+{
+ Type tp;
+ Datum val;
+ Const *con;
+
+ switch(nodeTag(value)) {
+ case T_Integer:
+ tp = type("int4");
+ val = Int32GetDatum(intVal(value));
+ break;
+
+ case T_Float:
+ {
+ float32 dummy;
+ tp = type("float4");
+
+ dummy = (float32)palloc(sizeof(float32data));
+ *dummy = floatVal(value);
+
+ val = Float32GetDatum(dummy);
+ }
+ break;
+
+ case T_String:
+ tp = type("unknown"); /* unknown for now, will be type coerced */
+ val = PointerGetDatum(textin(strVal(value)));
+ break;
+
+ case T_Null:
+ default:
+ {
+ if (nodeTag(value)!=T_Null)
+ elog(NOTICE,"unknown type : %d\n", nodeTag(value));
+
+ /* null const */
+ con = makeConst(0, 0, (Datum)NULL, TRUE, 0, FALSE);
+ return NULL /*con*/;
+ }
+ }
+
+ con = makeConst(typeid(tp),
+ tlen(tp),
+ val,
+ FALSE,
+ tbyval(tp),
+ FALSE); /* not a set */
+
+ return (con);
+}
+
+/*
+ * param_type_init()
+ *
+ * keep enough information around fill out the type of param nodes
+ * used in postquel functions
+ */
+void
+param_type_init(Oid* typev, int nargs)
+{
+ pfunc_num_args = nargs;
+ param_type_info = typev;
+}
+
+Oid
+param_type(int t)
+{
+ if ((t >pfunc_num_args) ||(t ==0)) return InvalidOid;
+ return param_type_info[t-1];
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * parse_query.h--
+ * prototypes for parse_query.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: parse_query.h,v 1.1.1.1 1996/07/09 06:21:40 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSE_QUERY_H
+#define PARSE_QUERY_H
+
+#include "nodes/pg_list.h"
+#include "nodes/parsenodes.h"
+#include "parser/catalog_utils.h"
+#include "parser/parse_state.h"
+
+typedef struct QueryTreeList {
+ int len; /* number of queries */
+ Query** qtrees;
+} QueryTreeList;
+
+extern int RangeTablePosn(List *rtable, char *rangevar);
+extern char *VarnoGetRelname(ParseState *pstate, int vnum);
+extern RangeTblEntry *makeRangeTableEntry(char *relname, bool inh,
+ TimeRange *timeRange, char *refname);
+extern List *expandAll(ParseState *pstate, char *relname, int *this_resno);
+extern TimeQual makeTimeRange(char *datestring1, char *datestring2,
+ int timecode);
+extern Expr *make_op(char *opname, Node *ltree, Node *rtree);
+
+extern int find_atttype(Oid relid, char *attrname);
+extern Var *make_var(ParseState *pstate,
+ char *relname, char *attrname, int *type_id);
+extern ArrayRef *make_array_ref(Node *array, List *indirection);
+extern ArrayRef *make_array_set(Expr *target_expr, List *upperIndexpr,
+ List *lowerIndexpr, Expr *expr);
+extern Const *make_const(Value *value);
+
+extern void param_type_init(Oid* typev, int nargs);
+extern Oid param_type(int t);
+
+/* parser.c (was ylib.c) */
+extern QueryTreeList *parser(char *str, Oid *typev, int nargs);
+extern Node *parser_typecast(Value *expr, TypeName *typename, int typlen);
+extern Node *parser_typecast2(Node *expr, int exprType, Type tp, int typlen);
+extern Aggreg *ParseAgg(char *aggname, Oid basetype, Node *target);
+
+/*
+ * analyze.c
+ */
+
+#if 0
+extern List *p_rtable;
+extern int NumLevels;
+#endif
+
+Oid exprType(Node *expr);
+ParseState* makeParseState();
+QueryTreeList *parse_analyze(List *querytree_list);
+
+/* define in parse_query.c, used in gram.y */
+extern Oid *param_type_info;
+extern int pfunc_num_args;
+
+/* useful macros */
+#define ISCOMPLEX(type) (typeid_get_relid((Oid)type) ? true : false)
+
+#endif /* PARSE_QUERY_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * parse_state.h--
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: parse_state.h,v 1.1.1.1 1996/07/09 06:21:40 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef PARSE_STATE_H
+#define PARSE_STATE_H
+
+/* state information used during parse analysis */
+typedef struct ParseState {
+ int p_last_resno;
+ List *p_target_resnos;
+ Relation parser_current_rel;
+ List *p_rtable;
+ int p_query_is_rule;
+ int p_numAgg;
+ List *p_aggs;
+} ParseState;
+
+
+#endif /*PARSE_QUERY_H*/
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * ylib.c--
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/parser/parser.c,v 1.1.1.1 1996/07/09 06:21:40 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#ifndef WIN32
+#endif /*WIN32 */
+#include /* for MAXPATHLEN */
+
+#include "utils/elog.h"
+#include "parser/catalog_utils.h"
+#include "nodes/pg_list.h"
+#include "utils/exc.h"
+#include "utils/excid.h"
+#include "utils/palloc.h"
+#include "catalog/pg_aggregate.h"
+#include "catalog/pg_type.h"
+#include "nodes/primnodes.h"
+#include "nodes/plannodes.h"
+#include "nodes/execnodes.h"
+#include "nodes/relation.h"
+#include "parser/parse_query.h"
+#include "utils/builtins.h"
+#include "utils/lsyscache.h"
+#include "access/heapam.h"
+#include "nodes/makefuncs.h"
+#include "optimizer/clauses.h"
+
+char *parseString; /* the char* which holds the string to be parsed */
+char *parseCh; /* a pointer used during parsing to walk down ParseString*/
+
+List *parsetree = NIL;
+
+static void fixupsets();
+static void define_sets();
+/*
+ * parser-- returns a list of parse trees
+ *
+ * CALLER is responsible for free'ing the list returned
+ */
+QueryTreeList *
+parser(char *str, Oid *typev, int nargs)
+{
+ QueryTreeList* queryList;
+ int yyresult;
+
+#if defined(FLEX_SCANNER)
+ extern void DeleteBuffer(void);
+#endif /* FLEX_SCANNER */
+
+ init_io();
+
+ /* Set things up to read from the string, if there is one */
+ if (strlen(str) != 0) {
+ parseString = (char *) palloc(strlen(str) + 1);
+ memmove(parseString,str,strlen(str)+1);
+ }
+
+ parser_init(typev, nargs);
+ yyresult = yyparse();
+
+#if defined(FLEX_SCANNER)
+ DeleteBuffer();
+#endif /* FLEX_SCANNER */
+
+ clearerr(stdin);
+
+ if (yyresult) { /* error */
+ return((QueryTreeList*)NULL);
+ }
+
+ queryList = parse_analyze(parsetree);
+
+#ifdef SETS_FIXED
+ /* Fixing up sets calls the parser, so it reassigns the global
+ * variable parsetree. So save the real parsetree.
+ */
+ savetree = parsetree;
+ foreach (parse, savetree) { /* savetree is really a list of parses */
+
+ /* find set definitions embedded in query */
+ fixupsets((Query *)lfirst(parse));
+
+ }
+ return savetree;
+#endif
+
+ return queryList;
+}
+
+static void
+fixupsets(Query *parse)
+{
+ if (parse == NULL)
+ return;
+ if (parse->commandType==CMD_UTILITY) /* utility */
+ return;
+ if (parse->commandType!=CMD_INSERT)
+ return;
+ define_sets(parse);
+}
+
+/* Recursively find all of the Consts in the parsetree. Some of
+ * these may represent a set. The value of the Const will be the
+ * query (a string) which defines the set. Call SetDefine to define
+ * the set, and store the OID of the new set in the Const instead.
+ */
+static void
+define_sets(Node *clause)
+{
+#ifdef SETS_FIXED
+ Oid setoid;
+ Type t = type("oid");
+ Oid typeoid = typeid(t);
+ Size oidsize = tlen(t);
+ bool oidbyval = tbyval(t);
+
+ if (clause==NULL) {
+ return;
+ } else if (IsA(clause,LispList)) {
+ define_sets(lfirst(clause));
+ define_sets(lnext(clause));
+ } else if (IsA(clause,Const)) {
+ if (get_constisnull((Const)clause) ||
+ !get_constisset((Const)clause)) {
+ return;
+ }
+ setoid = SetDefine(((Const*)clause)->constvalue,
+ get_id_typname(((Const*)clause)->consttype));
+ set_constvalue((Const)clause, setoid);
+ set_consttype((Const)clause,typeoid);
+ set_constlen((Const)clause,oidsize);
+ set_constbyval((Const)clause,oidbyval);
+ } else if ( IsA(clause,Iter) ) {
+ define_sets(((Iter*)clause)->iterexpr);
+ } else if (single_node (clause)) {
+ return;
+ } else if (or_clause(clause)) {
+ List *temp;
+ /* mapcan */
+ foreach (temp, ((Expr*)clause)->args) {
+ define_sets(lfirst(temp));
+ }
+ } else if (is_funcclause (clause)) {
+ List *temp;
+ /* mapcan */
+ foreach(temp, ((Expr*)clause)->args) {
+ define_sets(lfirst(temp));
+ }
+ } else if (IsA(clause,ArrayRef)) {
+ define_sets(((ArrayRef*)clause)->refassgnexpr);
+ } else if (not_clause (clause)) {
+ define_sets (get_notclausearg (clause));
+ } else if (is_opclause (clause)) {
+ define_sets(get_leftop (clause));
+ define_sets(get_rightop (clause));
+ }
+#endif
+}
+
+#define PSIZE(PTR) (*((int32 *)(PTR) - 1))
+Node *
+parser_typecast(Value *expr, TypeName *typename, int typlen)
+{
+ /* check for passing non-ints */
+ Const *adt;
+ Datum lcp;
+ Type tp;
+ char type_string[16];
+ int32 len;
+ char *cp = NULL;
+ char *const_string;
+ bool string_palloced = false;
+
+ switch(nodeTag(expr)) {
+ case T_String:
+ const_string = DatumGetPointer(expr->val.str);
+ break;
+ case T_Integer:
+ const_string = (char *) palloc(256);
+ string_palloced = true;
+ sprintf(const_string, "%ld", expr->val.ival);
+ break;
+ default:
+ elog(WARN,
+ "parser_typecast: cannot cast this expression to type \"%s\"",
+ typename->name);
+ }
+
+ if (typename->arrayBounds != NIL) {
+ sprintf(type_string,"_%s", typename->name);
+ tp = (Type) type(type_string);
+ } else {
+ tp = (Type) type(typename->name);
+ }
+
+ len = tlen(tp);
+
+#if 0 /* fix me */
+ switch ( CInteger(lfirst(expr)) ) {
+ case 23: /* int4 */
+ const_string = (char *) palloc(256);
+ string_palloced = true;
+ sprintf(const_string,"%d", ((Const*)lnext(expr))->constvalue);
+ break;
+
+ case 19: /* char16 */
+ const_string = (char *) palloc(256);
+ string_palloced = true;
+ sprintf(const_string,"%s", ((Const*)lnext(expr))->constvalue);
+ break;
+
+ case 18: /* char */
+ const_string = (char *) palloc(256);
+ string_palloced = true;
+ sprintf(const_string,"%c", ((Const)lnext(expr))->constvalue);
+ break;
+
+ case 701:/* float8 */
+ const_string = (char *) palloc(256);
+ string_palloced = true;
+ sprintf(const_string,"%f", ((Const)lnext(expr))->constvalue);
+ break;
+
+ case 25: /* text */
+ const_string = DatumGetPointer(((Const)lnext(expr))->constvalue);
+ const_string = (char *) textout((struct varlena *)const_string);
+ break;
+
+ case 705: /* unknown */
+ const_string = DatumGetPointer(((Const)lnext(expr))->constvalue);
+ const_string = (char *) textout((struct varlena *)const_string);
+ break;
+
+ default:
+ elog(WARN,"unknown type %d", CInteger(lfirst(expr)));
+ }
+#endif
+
+ cp = instr2 (tp, const_string, typlen);
+
+ if (!tbyvalue(tp)) {
+ if (len >= 0 && len != PSIZE(cp)) {
+ char *pp;
+ pp = (char *) palloc(len);
+ memmove(pp, cp, len);
+ cp = pp;
+ }
+ lcp = PointerGetDatum(cp);
+ } else {
+ switch(len) {
+ case 1:
+ lcp = Int8GetDatum(cp);
+ break;
+ case 2:
+ lcp = Int16GetDatum(cp);
+ break;
+ case 4:
+ lcp = Int32GetDatum(cp);
+ break;
+ default:
+ lcp = PointerGetDatum(cp);
+ break;
+ }
+ }
+
+ adt = makeConst(typeid(tp),
+ len,
+ (Datum)lcp ,
+ 0,
+ tbyvalue(tp),
+ 0 /* not a set */);
+
+ if (string_palloced)
+ pfree(const_string);
+
+ return (Node*)adt;
+}
+
+Node *
+parser_typecast2(Node *expr, int exprType, Type tp, int typlen)
+{
+ /* check for passing non-ints */
+ Const *adt;
+ Datum lcp;
+ int32 len = tlen(tp);
+ char *cp = NULL;
+
+ char *const_string;
+ bool string_palloced = false;
+
+ Assert(IsA(expr,Const));
+
+ switch (exprType) {
+ case 23: /* int4 */
+ const_string = (char *) palloc(256);
+ string_palloced = true;
+ sprintf(const_string,"%d",
+ (int) ((Const*)expr)->constvalue);
+ break;
+ case 19: /* char16 */
+ const_string = (char *) palloc(256);
+ string_palloced = true;
+ sprintf(const_string,"%s",
+ (char*) ((Const*)expr)->constvalue);
+ break;
+ case 18: /* char */
+ const_string = (char *) palloc(256);
+ string_palloced = true;
+ sprintf(const_string,"%c",
+ (char) ((Const*)expr)->constvalue);
+ break;
+ case 700: /* float4 */
+ {
+ float32 floatVal =
+ DatumGetFloat32(((Const*)expr)->constvalue);
+ const_string = (char *) palloc(256);
+ string_palloced = true;
+ sprintf(const_string,"%f", *floatVal);
+ break;
+ }
+ case 701:/* float8 */
+ {
+ float64 floatVal =
+ DatumGetFloat64(((Const*)expr)->constvalue);
+ const_string = (char *) palloc(256);
+ string_palloced = true;
+ sprintf(const_string,"%f", *floatVal);
+ break;
+ }
+ case 25: /* text */
+ const_string =
+ DatumGetPointer(((Const*)expr)->constvalue );
+ const_string = (char *) textout((struct varlena *)const_string);
+ break;
+ case 705: /* unknown */
+ const_string =
+ DatumGetPointer(((Const*)expr)->constvalue );
+ const_string = (char *) textout((struct varlena *)const_string);
+ break;
+ default:
+ elog(WARN,"unknown type%d ",exprType);
+ }
+
+ cp = instr2 (tp, const_string, typlen);
+
+
+ if (!tbyvalue(tp)) {
+ if (len >= 0 && len != PSIZE(cp)) {
+ char *pp;
+ pp = (char *) palloc(len);
+ memmove(pp, cp, len);
+ cp = pp;
+ }
+ lcp = PointerGetDatum(cp);
+ } else {
+ switch(len) {
+ case 1:
+ lcp = Int8GetDatum(cp);
+ break;
+ case 2:
+ lcp = Int16GetDatum(cp);
+ break;
+ case 4:
+ lcp = Int32GetDatum(cp);
+ break;
+ default:
+ lcp = PointerGetDatum(cp);
+ break;
+ }
+ }
+
+ adt = makeConst((Oid)typeid(tp),
+ (Size)len,
+ (Datum)lcp,
+ 0,
+ 0 /*was omitted*/,
+ 0 /* not a set */);
+ /*
+ printf("adt %s : %d %d %d\n",CString(expr),typeid(tp) ,
+ len,cp);
+ */
+ if (string_palloced) pfree(const_string);
+
+ return ((Node*) adt);
+}
+
+Aggreg *
+ParseAgg(char *aggname, Oid basetype, Node *target)
+{
+ Oid fintype;
+ Oid vartype;
+ Oid xfn1;
+ Form_pg_aggregate aggform;
+ Aggreg *aggreg;
+ HeapTuple theAggTuple;
+
+ theAggTuple = SearchSysCacheTuple(AGGNAME, PointerGetDatum(aggname),
+ ObjectIdGetDatum(basetype),
+ 0, 0);
+ if (!HeapTupleIsValid(theAggTuple)) {
+ elog(WARN, "aggregate %s does not exist", aggname);
+ }
+
+ aggform = (Form_pg_aggregate) GETSTRUCT(theAggTuple);
+ fintype = aggform->aggfinaltype;
+ xfn1 = aggform->aggtransfn1;
+
+ if (nodeTag(target) != T_Var)
+ elog(WARN, "parser: aggregate can only be applied on an attribute");
+
+ /* only aggregates with transfn1 need a base type */
+ if (OidIsValid(xfn1)) {
+ basetype = aggform->aggbasetype;
+ vartype = ((Var*)target)->vartype;
+
+ if (basetype != vartype) {
+ Type tp1, tp2, get_id_type();
+
+ tp1 = get_id_type(basetype);
+ tp2 = get_id_type(vartype);
+ elog(NOTICE, "Aggregate type mismatch:");
+ elog(WARN, "%s works on %s, not %s", aggname,
+ tname(tp1), tname(tp2));
+ }
+ }
+
+ aggreg = makeNode(Aggreg);
+ aggreg->aggname = pstrdup(aggname);
+ aggreg->basetype = aggform->aggbasetype;
+ aggreg->aggtype = fintype;
+
+ aggreg->target = target;
+
+ return aggreg;
+}
+
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * parsetree.h--
+ * Routines to access various components and subcomponents of
+ * parse trees.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: parsetree.h,v 1.1.1.1 1996/07/09 06:21:41 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSETREE_H
+#define PARSETREE_H /* include once only */
+
+/* ----------------
+ * need pg_list.h for definitions of CAR(), etc. macros
+ * ----------------
+ */
+#include "nodes/pg_list.h"
+#include "nodes/parsenodes.h"
+
+/* ----------------
+ * range table macros
+ *
+ * parse tree:
+ * (root targetlist qual)
+ * ^^^^
+ * parse root:
+ * (numlevels cmdtype resrel rangetable priority ruleinfo nestdotinfo)
+ * ^^^^^^^^^^
+ * range table:
+ * (rtentry ...)
+ *
+ * rtentry:
+ * note: this might be wrong, I don't understand how
+ * rt_time / rt_archive_time work together. anyways it
+ * looks something like:
+ *
+ * (relname ? relid timestuff flags rulelocks)
+ * or (new/cur relname relid timestuff flags rulelocks)
+ *
+ * someone who knows more should correct this -cim 6/9/91
+ * ----------------
+ */
+
+#define rt_relname(rt_entry) \
+ ((!strcmp(((rt_entry)->refname),"*CURRENT*") ||\
+ !strcmp(((rt_entry)->refname),"*NEW*")) ? ((rt_entry)->refname) : \
+ ((char *)(rt_entry)->relname))
+
+/*
+ * rt_fetch
+ * rt_store
+ *
+ * Access and (destructively) replace rangetable entries.
+ *
+ */
+#define rt_fetch(rangetable_index, rangetable) \
+ ((RangeTblEntry*)nth((rangetable_index)-1, rangetable))
+
+#define rt_store(rangetable_index, rangetable, rt) \
+ set_nth(rangetable, (rangetable_index)-1, rt)
+
+/*
+ * getrelid
+ * getrelname
+ *
+ * Given the range index of a relation, return the corresponding
+ * relation id or relation name.
+ */
+#define getrelid(rangeindex,rangetable) \
+ ((RangeTblEntry*)nth((rangeindex)-1, rangetable))->relid
+
+#define getrelname(rangeindex, rangetable) \
+ rt_relname((RangeTblEntry*)nth((rangeindex)-1, rangetable))
+
+#endif /* PARSETREE_H */
+
--- /dev/null
+%{
+/*-------------------------------------------------------------------------
+ *
+ * scan.l--
+ * lexical scanner for POSTGRES
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/parser/scan.l,v 1.1.1.1 1996/07/09 06:21:41 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#ifndef WIN32
+#include
+#endif /* WIN32 */
+#ifndef __linux__
+#include
+#else
+#include
+#endif /* __linux__ */
+#include
+
+#include "postgres.h"
+#include "miscadmin.h"
+#include "nodes/pg_list.h"
+#include "nodes/parsenodes.h"
+#include "parser/keywords.h"
+#include "parser/scansup.h"
+#include "parse.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+extern char *parseString;
+extern char *parseCh;
+
+/* some versions of lex define this as a macro */
+#if defined(yywrap)
+#undef yywrap
+#endif /* yywrap */
+
+#if defined(FLEX_SCANNER)
+/* MAX_PARSE_BUFFER is defined in miscadmin.h */
+#define YYLMAX MAX_PARSE_BUFFER
+extern int myinput(char* buf, int max);
+#undef YY_INPUT
+#define YY_INPUT(buf,result,max) {result = myinput(buf,max);}
+#else
+#undef input
+int input();
+#undef unput
+void unput(char);
+#endif /* FLEX_SCANNER */
+
+extern YYSTYPE yylval;
+%}
+
+digit [0-9]
+letter [_A-Za-z]
+letter_or_digit [_A-Za-z0-9]
+
+identifier {letter}{letter_or_digit}*
+
+self [,()\[\].;$\:\+\-\*\/\<\>\=\|]
+op_and_self [\~\!\@\#\%\^\&\|\`\?\$\:\+\-\*\/\<\>\=]
+op_only [\~\!\@\#\%\^\&\`\?]
+
+operator ({op_and_self}{op_and_self}+)|{op_only}+
+ /* we used to allow double-quoted strings, but SQL doesn't */
+ /* so we won't either*/
+quote '
+
+integer -?{digit}+
+real -?{digit}+\.{digit}+([Ee][-+]?{digit}+)?
+
+param \${integer}
+
+comment "--".*\n
+
+space [ \t\n\f]
+other .
+
+%%
+{comment} { /* ignore */ }
+
+"::" { return TYPECAST; }
+
+{self} { return (yytext[0]); }
+
+{operator} {
+ yylval.str = pstrdup((char*)yytext);
+ return (Op);
+ }
+{param} { yylval.ival = atoi((char*)&yytext[1]);
+ return (PARAM);
+ }
+{integer} {
+ yylval.ival = atoi((char*)yytext);
+ return (ICONST);
+ }
+{real} {
+ yylval.dval = atof((char*)yytext);
+ return (FCONST);
+ }
+{quote} {
+ char literal[MAX_PARSE_BUFFER];
+ int i = 0;
+ int c = 0;
+ /* quote_seen can be either \ or ' because
+ we handle both cases of \' and '' for
+ quoting quotes*/
+ int quote_seen = 0;
+
+ while (i < MAX_PARSE_BUFFER - 1) {
+ c = input();
+ if (quote_seen != 0) {
+ if (quote_seen == '\'' &&
+ c != '\'') {
+ /* a non-quote follows a single quote */
+ /* so we've hit the end of the literal */
+ if (c != '\0' && c != EOF)
+ unput(c); /* put back the extra char we read*/
+ i = i - 1;
+ break; /* break out of the while loop */
+ }
+ /* if we reach here, we're still in */
+ /* the string literal */
+ literal[i++] = c;
+ quote_seen = 0;
+ continue;
+ }
+ if (c == '\0' || c == EOF) {
+ elog(WARN,"unterminated quoted string literal");
+ /* not reached */
+ }
+ literal[i++] = c;
+ if (c == '\'' || c == '\\')
+ quote_seen = c;
+ }
+ if ( i == MAX_PARSE_BUFFER - 1) {
+ elog (WARN, "unterminated quote string. parse buffer of %d chars exceeded", MAX_PARSE_BUFFER);
+ /* not reached */
+ }
+ literal[i] = '\0';
+ yylval.str = pstrdup(scanstr(literal));
+ return (SCONST);
+ }
+{identifier} {
+ ScanKeyword *keyword;
+
+ keyword = ScanKeywordLookup((char*)yytext);
+ if (keyword != NULL) {
+ return (keyword->value);
+ } else {
+ yylval.str = pstrdup((char*)yytext);
+ return (IDENT);
+ }
+ }
+{space} { /* ignore */ }
+
+{other} { return (yytext[0]); }
+
+%%
+
+void yyerror(char message[])
+{
+ elog(WARN, "parser: %s at or near \"%s\"\n", message, yytext);
+}
+
+int yywrap()
+{
+ return(1);
+}
+
+/*
+ init_io:
+ called by postgres before any actual parsing is done
+*/
+void
+init_io()
+{
+ /* it's important to set this to NULL
+ because input()/myinput() checks the non-nullness of parseCh
+ to know when to pass the string to lex/flex */
+ parseCh = NULL;
+#if defined(FLEX_SCANNER)
+ if (YY_CURRENT_BUFFER)
+ yy_flush_buffer(YY_CURRENT_BUFFER);
+#endif /* FLEX_SCANNER */
+ BEGIN INITIAL;
+}
+
+
+#if !defined(FLEX_SCANNER)
+/* get lex input from a string instead of from stdin */
+int
+input()
+{
+ if (parseCh == NULL) {
+ parseCh = parseString;
+ return(*parseCh++);
+ } else if (*parseCh == '\0') {
+ return(0);
+ } else {
+ return(*parseCh++);
+ }
+}
+
+/* undo lex input from a string instead of from stdin */
+void
+unput(char c)
+{
+ if (parseCh == NULL) {
+ elog(FATAL, "Unput() failed.\n");
+ } else if (c != 0) {
+ *--parseCh = c;
+ }
+}
+#endif /* !defined(FLEX_SCANNER) */
+
+#ifdef FLEX_SCANNER
+/* input routine for flex to read input from a string instead of a file */
+int
+myinput(char* buf, int max)
+{
+ int len, copylen;
+
+ if (parseCh == NULL) {
+ len = strlen(parseString);
+ if (len >= max)
+ copylen = max - 1;
+ else
+ copylen = len;
+ if (copylen > 0)
+ memcpy(buf, parseString, copylen);
+ buf[copylen] = '\0';
+ parseCh = parseString;
+ return copylen;
+ } else {
+ return 0; /* end of string */
+ }
+}
+
+char*
+CurScan(void)
+{
+/*
+ return (InputFrag ? InputFrag : parseCh) +
+ (yy_c_buf_p - &yy_current_buffer->yy_ch_buf[yy_n_chars]);
+*/
+}
+#endif /* FLEX_SCANNER */
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * scansup.c--
+ * support routines for the lex/flex scanner, used by both the normal
+ * backend as well as the bootstrap backend
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/parser/scansup.c,v 1.1.1.1 1996/07/09 06:21:41 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include "c.h"
+#include "postgres.h"
+#include "miscadmin.h"
+#include "utils/elog.h"
+#include "parser/scansup.h"
+
+/*
+ * Scanner error handler.
+ */
+static void
+serror(char *str)
+{
+ elog(WARN, "*** scanner error: %s\n", str);
+}
+
+/* ----------------
+ * scanstr
+ *
+ * if the string passed in has escaped codes, map the escape codes to actual
+ * chars
+ *
+ * also, remove leading and ending quotes '"' if any
+ *
+ * the string passed in must be non-null
+ *
+ * the string returned is a pointer to static storage and should NOT
+ * be freed by the CALLER.
+ * ----------------
+ */
+
+char*
+scanstr(char *s)
+{
+ static char newStr[MAX_PARSE_BUFFER];
+ int len, i, start, j;
+ char delimiter;
+
+ if (s == NULL || s[0] == '\0')
+ return s;
+
+ len = strlen(s);
+ start = 0;
+
+ /* remove leading and trailing quotes, if any */
+ /* the normal backend lexer only accepts single quotes, but the
+ bootstrap lexer accepts double quotes */
+ delimiter = 0;
+ if (s[0] == '"' || s[0] == '\''){
+ delimiter = s[0];
+ start = 1;
+ }
+ if (delimiter != 0) {
+ if (s[len-1] == delimiter)
+ len = len - 1;
+ else
+ serror("mismatched quote delimiters");
+ }
+
+ for (i = start, j = 0; i < len ; i++) {
+ if (s[i] == '\'') {
+ i = i + 1;
+ if (s[i] == '\'')
+ newStr[j] = '\'';
+ }
+ else {
+ if (s[i] == '\\') {
+ i = i + 1;
+ switch (s[i]) {
+ case '\\':
+ newStr[j] = '\\';
+ break;
+ case 'b':
+ newStr[j] = '\b';
+ break;
+ case 'f':
+ newStr[j] = '\f';
+ break;
+ case 'n':
+ newStr[j] = '\n';
+ break;
+ case 'r':
+ newStr[j] = '\r';
+ break;
+ case 't':
+ newStr[j] = '\t';
+ break;
+ case '"':
+ newStr[j] = '"';
+ break;
+ case '\'':
+ newStr[j] = '\'';
+ break;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ {
+ char octal[4];
+ int k;
+ long octVal;
+
+ for (k=0;
+ s[i+k] >= '0' && s[i+k] <= '7' && k < 3;
+ k++)
+ octal[k] = s[i+k];
+ i += k-1;
+ octal[3] = '\0';
+
+ octVal = strtol(octal,0,8);
+/* elog (NOTICE, "octal = %s octVal = %d, %od", octal, octVal, octVal);*/
+ if (octVal <= 0377) {
+ newStr[j] = ((char)octVal);
+ break;
+ }
+ }
+ default:
+ elog (WARN, "Bad escape sequence, s[i] = %d", s[i]);
+ } /* switch */
+ } /* s[i] == '\\' */
+ else
+ newStr[j] = s[i];
+ }
+ j++;
+ }
+ newStr[j] = '\0';
+ return newStr;
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * scansup.h--
+ * scanner support routines. used by both the bootstrap lexer
+ * as well as the normal lexer
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: scansup.h,v 1.1.1.1 1996/07/09 06:21:41 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+
+extern char* scanstr(char *s);
+
+
+
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for port/BSD44_derived (for OSs derived from 4.4-lite BSD)
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/port/BSD44_derived/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:41 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+CFLAGS+= -DUSE_POSIX_TIME
+
+#
+# 4.4-lite BSD-derived OSs require that the lex library be included,
+# in case yywrap is defined
+#
+LDADD+= -ll
+
+#
+# 4.4-lite BSD-derived OSs have a little trouble with partially-implemented
+# dynamic loading soutines. See the comments in port-protos.h.
+#
+SUBSRCS= dl.c
+
+HEADERS+= float.h machine.h port-protos.h
--- /dev/null
+
+It was extended to cover Operating Systems derived from the 4.4-lite
+BSD release by Alistair G. Crooks.
--- /dev/null
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)dl.c 5.4 (Berkeley) 2/23/91";
+#endif /* LIBC_SCCS and not lint */
+
+#include
+#include
+#include
+
+#include
+#include
+
+static char error_message[BUFSIZ];
+
+char *
+BSD44_derived_dlerror(void)
+{
+ static char ret[BUFSIZ];
+
+ (void) strcpy(ret, error_message);
+ error_message[0] = 0;
+ return((ret[0] == 0) ? (char *) NULL : ret);
+}
+
+void *
+BSD44_derived_dlopen(char *file, int num)
+{
+ void *vp;
+
+ if ((vp = dlopen(file, num)) == (void *) NULL) {
+ (void) sprintf(error_message, "dlopen (%s) failed", file);
+ }
+ return(vp);
+}
+
+void *
+BSD44_derived_dlsym(void *handle, char *name)
+{
+ void *vp;
+ char buf[BUFSIZ];
+
+ if (*name != '_') {
+ (void) sprintf(buf, "_%s", name);
+ name = buf;
+ }
+ if ((vp = dlsym(handle, name)) == (void *) NULL) {
+ (void) sprintf(error_message, "dlsym (%s) failed", name);
+ }
+ return(vp);
+}
+
+void
+BSD44_derived_dlclose(void *handle)
+{
+ dlclose(handle);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * float.h--
+ * definitions for ANSI floating point
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: float.h,v 1.1.1.1 1996/07/09 06:21:42 scrappy Exp $
+ *
+ * NOTES
+ * These come straight out of ANSI X3.159-1989 (p.18) and
+ * would be unnecessary if SunOS 4 were ANSI-compliant.
+ *
+ * This is only a partial listing because I'm lazy to type
+ * the whole thing in.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef FLOAT_H
+#define FLOAT_H
+
+#define FLT_DIG 6
+#define FLT_MIN ((float) 1.17549435e-38)
+#define FLT_MAX ((float) 3.40282347e+38)
+#define DBL_DIG 15
+#define DBL_MIN 2.2250738585072014e-308
+#define DBL_MAX 1.7976931348623157e+308
+
+#endif /* FLOAT_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * machine.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: machine.h,v 1.1.1.1 1996/07/09 06:21:42 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MACHINE_H
+#define MACHINE_H
+
+#define BLCKSZ 8192
+
+#endif
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port-protos.h--
+ * port-specific prototypes for NetBSD 1.0
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: port-protos.h,v 1.1.1.1 1996/07/09 06:21:42 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PORT_PROTOS_H
+#define PORT_PROTOS_H
+
+#include
+#include
+#include
+
+#include "fmgr.h" /* for func_ptr */
+#include "utils/dynamic_loader.h"
+
+/* dynloader.c */
+/*
+ * Dynamic Loader on NetBSD 1.0.
+ *
+ * this dynamic loader uses the system dynamic loading interface for shared
+ * libraries (ie. dlopen/dlsym/dlclose). The user must specify a shared
+ * library as the file to be dynamically loaded.
+ *
+ * agc - I know this is all a bit crufty, but it does work, is fairly
+ * portable, and works (the stipulation that the d.l. function must
+ * begin with an underscore is fairly tricky, and some versions of
+ * NetBSD (like 1.0, and 1.0A pre June 1995) have no dlerror.)
+ */
+#define pg_dlopen(f) BSD44_derived_dlopen(f, 1)
+#define pg_dlsym BSD44_derived_dlsym
+#define pg_dlclose BSD44_derived_dlclose
+#define pg_dlerror BSD44_derived_dlerror
+
+#endif /* PORT_PROTOS_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for the port module (for code specific to various UNIX
+# platforms)
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/port/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:41 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+portdir= $(CURDIR)/port/$(PORTNAME)
+VPATH:= $(VPATH):$(portdir)
+
+SUBSRCS=
+include $(portdir)/Makefile.inc
+SRCS_PORT:= $(SUBSRCS)
+
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for port/aix (AIX specific stuff)
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/port/aix/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:41 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+#
+# aix has fast linkers and don't need the BIGOBJ stuff.
+#
+BIGOBJS=false
+
+CFLAGS+= -DCLASS_CONFLICT -DDISABLE_XOPEN_NLS -DNEED_ISINF
+
+LDFLAGS+= -bE:$(objdir)/$(PROG).exp
+
+LDADD+= -ll -lld
+
+HEADERS+= dlfcn.h machine.h port-protos.h
+
+SUBSRCS+= dlfcn.c
+
+${PROG}.exp: ${PROG}.noexp
+ mv -f $(objdir)/${PROG}.noexp $(objdir)/${PROG}
+ $(CURDIR)/port/aix/mkldexport.sh $(objdir)/${PROG} ${BINDIR} > $(objdir)/${PROG}.exp
+ mv -f $(objdir)/${PROG} $(objdir)/${PROG}.noexp
+
+${PROG}.noexp: ${OBJS}
+ touch -f $(objdir)/${PROG}.exp
+ ${CC} ${LDFLAGS} -o $(objdir)/${PROG}.noexp ${OBJS} ${LDADD}
+
+EXPORTS= ${PROG}.exp
+
+CLEANFILES+= ${PROG}.noexp ${PROG}.exp
--- /dev/null
+Copyright (c) 1992,1993,1995, Jens-Uwe Mager, Helios Software GmbH
+Not derived from licensed software.
+
+Permission is granted to freely use, copy, modify, and redistribute
+this software, provided that no attempt is made to gain profit from it,
+the author is not construed to be liable for any results of using the
+software, alterations are clearly marked as such, and this notice is
+not modified.
+
+libdl.a
+-------
+
+This is an emulation library to emulate the SunOS/System V.4 functions
+to access the runtime linker. The functions are emulated by using the
+AIX load() function and by reading the .loader section of the loaded
+module to find the exports. The to be loaded module should be linked as
+follows (if using AIX 3):
+
+ cc -o module.so -bM:SRE -bE:module.exp -e _nostart $(OBJS)
+
+For AIX 4:
+
+ cc -o module.so -bM:SRE -bE:module.exp -bnoentry $(OBJS)
+
+The module export file contains the symbols to be exported. Because
+this library uses the loader section, the final module.so file can be
+stripped. C++ users should build their shared objects using the script
+makeC++SharedLib (part of the IBM C++ compiler), this will make sure
+that constructors and destructors for static and global objects will be
+called upon loading and unloading the module.
+
+Usage
+-----
+
+void *dlopen(const char *path, int mode);
+
+This routine loads the module pointed to by path and reads its export
+table. If the path does not contain a '/' character, dlopen will search
+for the module using the LIBPATH environment variable. It returns an
+opaque handle to the module or NULL on error. The mode parameter can be
+either RTLD_LAZY (for lazy function binding) or RTLD_NOW for immediate
+function binding. The AIX implementation currently does treat RTLD_NOW
+the same as RTLD_LAZY. The flag RTLD_GLOBAL might be or'ed into the
+mode parameter to allow loaded modules to bind to global variables or
+functions in other loaded modules loaded by dlopen(). If RTLD_GLOBAL is
+not specified, only globals from the main part of the executable or
+shared libraries are used to look for undefined symbols in loaded
+modules.
+
+
+void *dlsym(void *handle, const char *symbol);
+
+This routine searches for the symbol in the module referred to by
+handle and returns its address. If the symbol could not be found, the
+function returns NULL. The return value must be casted to a proper
+function pointer before it can be used. SunOS/System V.4 allow handle
+to be a NULL pointer to refer to the module the call is made from, this
+is not implemented.
+
+int dlclose(void *handle);
+
+This routine unloads the module referred to by the handle and disposes
+of any local storage. this function returns -1 on failure.
+
+char *dlerror(void);
+
+This routine can be used to retrieve a text message describing the most
+recent error that occured on on of the above routines. This function
+returns NULL if there is not error information.
+
+Initialization and termination handlers
+---------------------------------------
+
+The emulation provides for an initialization and a termination
+handler. The dlfcn.h file contains a structure declaration named
+dl_info with following members:
+
+ void (*init)(void);
+ void (*fini)(void);
+
+The init function is called upon first referencing the library. The
+fini function is called at dlclose() time or when the process exits.
+The module should declare a variable named dl_info that contains this
+structure which must be exported. These functions correspond to the
+documented _init() and _fini() functions of SunOS 4.x, but these are
+appearently not implemented in SunOS. When using SunOS 5.0, these
+correspond to #pragma init and #pragma fini respectively. At the same
+time any static or global C++ object's constructors or destructors will
+be called.
+
+Jens-Uwe Mager
+
+HELIOS Software GmbH
+Lavesstr. 80
+30159 Hannover
+Germany
+
+Phone: +49 511 36482-0
+FAX: +49 511 36482-69
+AppleLink: helios.de Attn: Jens-Uwe Mager
+
+Revison History
+---------------
+
+SCCS/s.dlfcn.h:
+
+D 1.4 95/04/25 09:36:52 jum 4 3 00018/00004/00028
+MRs:
+COMMENTS:
+added RTLD_GLOBAL, include and C++ guards
+
+D 1.3 92/12/27 20:58:32 jum 3 2 00001/00001/00031
+MRs:
+COMMENTS:
+we always have prototypes on RS/6000
+
+D 1.2 92/08/16 17:45:11 jum 2 1 00009/00000/00023
+MRs:
+COMMENTS:
+added dl_info structure to implement initialize and terminate functions
+
+D 1.1 92/08/02 18:08:45 jum 1 0 00023/00000/00000
+MRs:
+COMMENTS:
+Erstellungsdatum und -uhrzeit 92/08/02 18:08:45 von jum
+
+SCCS/s.dlfcn.c:
+
+D 1.7 95/08/14 19:08:38 jum 8 6 00026/00004/00502
+MRs:
+COMMENTS:
+shared objects generated under AIX 4. Fixed bug that symbols with exactly
+8 characters would use garbage characters from the following symbol value.
+
+D 1.6 95/04/25 09:38:03 jum 6 5 00046/00006/00460
+MRs:
+COMMENTS:
+added handling of C++ static constructors and destructors, added RTLD_GLOBAL to bind against other loaded modules
+
+D 1.5 93/02/14 20:14:17 jum 5 4 00002/00000/00464
+MRs:
+COMMENTS:
+added path to dlopen error message to make clear where there error occured.
+
+D 1.4 93/01/03 19:13:56 jum 4 3 00061/00005/00403
+MRs:
+COMMENTS:
+to allow calling symbols in the main module call load with L_NOAUTODEFER and
+do a loadbind later with the main module.
+
+D 1.3 92/12/27 20:59:55 jum 3 2 00066/00008/00342
+MRs:
+COMMENTS:
+added search by L_GETINFO if module got loaded by LIBPATH
+
+D 1.2 92/08/16 17:45:43 jum 2 1 00074/00006/00276
+MRs:
+COMMENTS:
+implemented initialize and terminate functions, added reference counting to avoid multiple loads of the same library
+
+D 1.1 92/08/02 18:08:45 jum 1 0 00282/00000/00000
+MRs:
+COMMENTS:
+Erstellungsdatum und -uhrzeit 92/08/02 18:08:45 von jum
+
--- /dev/null
+/*
+ * @(#)dlfcn.c 1.7 revision of 95/08/14 19:08:38
+ * This is an unpublished work copyright (c) 1992 HELIOS Software GmbH
+ * 30159 Hannover, Germany
+ */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include "dlfcn.h"
+
+/*
+ * We simulate dlopen() et al. through a call to load. Because AIX has
+ * no call to find an exported symbol we read the loader section of the
+ * loaded module and build a list of exported symbols and their virtual
+ * address.
+ */
+
+typedef struct {
+ char *name; /* the symbols's name */
+ void *addr; /* its relocated virtual address */
+} Export, *ExportPtr;
+
+/*
+ * xlC uses the following structure to list its constructors and
+ * destructors. This is gleaned from the output of munch.
+ */
+typedef struct {
+ void (*init)(void); /* call static constructors */
+ void (*term)(void); /* call static destructors */
+} Cdtor, *CdtorPtr;
+
+/*
+ * The void * handle returned from dlopen is actually a ModulePtr.
+ */
+typedef struct Module {
+ struct Module *next;
+ char *name; /* module name for refcounting */
+ int refCnt; /* the number of references */
+ void *entry; /* entry point from load */
+ struct dl_info *info; /* optional init/terminate functions */
+ CdtorPtr cdtors; /* optional C++ constructors */
+ int nExports; /* the number of exports found */
+ ExportPtr exports; /* the array of exports */
+} Module, *ModulePtr;
+
+/*
+ * We keep a list of all loaded modules to be able to call the fini
+ * handlers and destructors at atexit() time.
+ */
+static ModulePtr modList;
+
+/*
+ * The last error from one of the dl* routines is kept in static
+ * variables here. Each error is returned only once to the caller.
+ */
+static char errbuf[BUFSIZ];
+static int errvalid;
+
+extern char *strdup(const char *);
+static void caterr(char *);
+static int readExports(ModulePtr);
+static void terminate(void);
+static void *findMain(void);
+
+void *dlopen(const char *path, int mode)
+{
+ register ModulePtr mp;
+ static void *mainModule;
+
+ /*
+ * Upon the first call register a terminate handler that will
+ * close all libraries. Also get a reference to the main module
+ * for use with loadbind.
+ */
+ if (!mainModule) {
+ if ((mainModule = findMain()) == NULL)
+ return NULL;
+ atexit(terminate);
+ }
+ /*
+ * Scan the list of modules if we have the module already loaded.
+ */
+ for (mp = modList; mp; mp = mp->next)
+ if (strcmp(mp->name, path) == 0) {
+ mp->refCnt++;
+ return mp;
+ }
+ if ((mp = (ModulePtr)calloc(1, sizeof(*mp))) == NULL) {
+ errvalid++;
+ strcpy(errbuf, "calloc: ");
+ strcat(errbuf, strerror(errno));
+ return NULL;
+ }
+ if ((mp->name = strdup(path)) == NULL) {
+ errvalid++;
+ strcpy(errbuf, "strdup: ");
+ strcat(errbuf, strerror(errno));
+ free(mp);
+ return NULL;
+ }
+ /*
+ * load should be declared load(const char *...). Thus we
+ * cast the path to a normal char *. Ugly.
+ */
+ if ((mp->entry = (void *)load((char *)path, L_NOAUTODEFER, NULL)) == NULL) {
+ free(mp->name);
+ free(mp);
+ errvalid++;
+ strcpy(errbuf, "dlopen: ");
+ strcat(errbuf, path);
+ strcat(errbuf, ": ");
+ /*
+ * If AIX says the file is not executable, the error
+ * can be further described by querying the loader about
+ * the last error.
+ */
+ if (errno == ENOEXEC) {
+ char *tmp[BUFSIZ/sizeof(char *)];
+ if (loadquery(L_GETMESSAGES, tmp, sizeof(tmp)) == -1)
+ strcpy(errbuf, strerror(errno));
+ else {
+ char **p;
+ for (p = tmp; *p; p++)
+ caterr(*p);
+ }
+ } else
+ strcat(errbuf, strerror(errno));
+ return NULL;
+ }
+ mp->refCnt = 1;
+ mp->next = modList;
+ modList = mp;
+ if (loadbind(0, mainModule, mp->entry) == -1) {
+ dlclose(mp);
+ errvalid++;
+ strcpy(errbuf, "loadbind: ");
+ strcat(errbuf, strerror(errno));
+ return NULL;
+ }
+ /*
+ * If the user wants global binding, loadbind against all other
+ * loaded modules.
+ */
+ if (mode & RTLD_GLOBAL) {
+ register ModulePtr mp1;
+ for (mp1 = mp->next; mp1; mp1 = mp1->next)
+ if (loadbind(0, mp1->entry, mp->entry) == -1) {
+ dlclose(mp);
+ errvalid++;
+ strcpy(errbuf, "loadbind: ");
+ strcat(errbuf, strerror(errno));
+ return NULL;
+ }
+ }
+ if (readExports(mp) == -1) {
+ dlclose(mp);
+ return NULL;
+ }
+ /*
+ * If there is a dl_info structure, call the init function.
+ */
+ if (mp->info = (struct dl_info *)dlsym(mp, "dl_info")) {
+ if (mp->info->init)
+ (*mp->info->init)();
+ } else
+ errvalid = 0;
+ /*
+ * If the shared object was compiled using xlC we will need
+ * to call static constructors (and later on dlclose destructors).
+ */
+ if (mp->cdtors = (CdtorPtr)dlsym(mp, "__cdtors")) {
+ while (mp->cdtors->init) {
+ (*mp->cdtors->init)();
+ mp->cdtors++;
+ }
+ } else
+ errvalid = 0;
+ return mp;
+}
+
+/*
+ * Attempt to decipher an AIX loader error message and append it
+ * to our static error message buffer.
+ */
+static void caterr(char *s)
+{
+ register char *p = s;
+
+ while (*p >= '0' && *p <= '9')
+ p++;
+ switch(atoi(s)) {
+ case L_ERROR_TOOMANY:
+ strcat(errbuf, "to many errors");
+ break;
+ case L_ERROR_NOLIB:
+ strcat(errbuf, "can't load library");
+ strcat(errbuf, p);
+ break;
+ case L_ERROR_UNDEF:
+ strcat(errbuf, "can't find symbol");
+ strcat(errbuf, p);
+ break;
+ case L_ERROR_RLDBAD:
+ strcat(errbuf, "bad RLD");
+ strcat(errbuf, p);
+ break;
+ case L_ERROR_FORMAT:
+ strcat(errbuf, "bad exec format in");
+ strcat(errbuf, p);
+ break;
+ case L_ERROR_ERRNO:
+ strcat(errbuf, strerror(atoi(++p)));
+ break;
+ default:
+ strcat(errbuf, s);
+ break;
+ }
+}
+
+void *dlsym(void *handle, const char *symbol)
+{
+ register ModulePtr mp = (ModulePtr)handle;
+ register ExportPtr ep;
+ register int i;
+
+ /*
+ * Could speed up the search, but I assume that one assigns
+ * the result to function pointers anyways.
+ */
+ for (ep = mp->exports, i = mp->nExports; i; i--, ep++)
+ if (strcmp(ep->name, symbol) == 0)
+ return ep->addr;
+ errvalid++;
+ strcpy(errbuf, "dlsym: undefined symbol ");
+ strcat(errbuf, symbol);
+ return NULL;
+}
+
+char *dlerror(void)
+{
+ if (errvalid) {
+ errvalid = 0;
+ return errbuf;
+ }
+ return NULL;
+}
+
+int dlclose(void *handle)
+{
+ register ModulePtr mp = (ModulePtr)handle;
+ int result;
+ register ModulePtr mp1;
+
+ if (--mp->refCnt > 0)
+ return 0;
+ if (mp->info && mp->info->fini)
+ (*mp->info->fini)();
+ if (mp->cdtors)
+ while (mp->cdtors->term) {
+ (*mp->cdtors->term)();
+ mp->cdtors++;
+ }
+ result = unload(mp->entry);
+ if (result == -1) {
+ errvalid++;
+ strcpy(errbuf, strerror(errno));
+ }
+ if (mp->exports) {
+ register ExportPtr ep;
+ register int i;
+ for (ep = mp->exports, i = mp->nExports; i; i--, ep++)
+ if (ep->name)
+ free(ep->name);
+ free(mp->exports);
+ }
+ if (mp == modList)
+ modList = mp->next;
+ else {
+ for (mp1 = modList; mp1; mp1 = mp1->next)
+ if (mp1->next == mp) {
+ mp1->next = mp->next;
+ break;
+ }
+ }
+ free(mp->name);
+ free(mp);
+ return result;
+}
+
+static void terminate(void)
+{
+ while (modList)
+ dlclose(modList);
+}
+
+/*
+ * Build the export table from the XCOFF .loader section.
+ */
+static int readExports(ModulePtr mp)
+{
+ LDFILE *ldp = NULL;
+ SCNHDR sh, shdata;
+ LDHDR *lhp;
+ char *ldbuf;
+ LDSYM *ls;
+ int i;
+ ExportPtr ep;
+
+ if ((ldp = ldopen(mp->name, ldp)) == NULL) {
+ struct ld_info *lp;
+ char *buf;
+ int size = 4*1024;
+ if (errno != ENOENT) {
+ errvalid++;
+ strcpy(errbuf, "readExports: ");
+ strcat(errbuf, strerror(errno));
+ return -1;
+ }
+ /*
+ * The module might be loaded due to the LIBPATH
+ * environment variable. Search for the loaded
+ * module using L_GETINFO.
+ */
+ if ((buf = malloc(size)) == NULL) {
+ errvalid++;
+ strcpy(errbuf, "readExports: ");
+ strcat(errbuf, strerror(errno));
+ return -1;
+ }
+ while ((i = loadquery(L_GETINFO, buf, size)) == -1 && errno == ENOMEM) {
+ free(buf);
+ size += 4*1024;
+ if ((buf = malloc(size)) == NULL) {
+ errvalid++;
+ strcpy(errbuf, "readExports: ");
+ strcat(errbuf, strerror(errno));
+ return -1;
+ }
+ }
+ if (i == -1) {
+ errvalid++;
+ strcpy(errbuf, "readExports: ");
+ strcat(errbuf, strerror(errno));
+ free(buf);
+ return -1;
+ }
+ /*
+ * Traverse the list of loaded modules. The entry point
+ * returned by load() does actually point to the data
+ * segment origin.
+ */
+ lp = (struct ld_info *)buf;
+ while (lp) {
+ if (lp->ldinfo_dataorg == mp->entry) {
+ ldp = ldopen(lp->ldinfo_filename, ldp);
+ break;
+ }
+ if (lp->ldinfo_next == 0)
+ lp = NULL;
+ else
+ lp = (struct ld_info *)((char *)lp + lp->ldinfo_next);
+ }
+ free(buf);
+ if (!ldp) {
+ errvalid++;
+ strcpy(errbuf, "readExports: ");
+ strcat(errbuf, strerror(errno));
+ return -1;
+ }
+ }
+ if (TYPE(ldp) != U802TOCMAGIC) {
+ errvalid++;
+ strcpy(errbuf, "readExports: bad magic");
+ while(ldclose(ldp) == FAILURE)
+ ;
+ return -1;
+ }
+ /*
+ * Get the padding for the data section. This is needed for
+ * AIX 4.1 compilers. This is used when building the final
+ * function pointer to the exported symbol.
+ */
+ if (ldnshread(ldp, _DATA, &shdata) != SUCCESS) {
+ errvalid++;
+ strcpy(errbuf, "readExports: cannot read data section header");
+ while(ldclose(ldp) == FAILURE)
+ ;
+ return -1;
+ }
+ if (ldnshread(ldp, _LOADER, &sh) != SUCCESS) {
+ errvalid++;
+ strcpy(errbuf, "readExports: cannot read loader section header");
+ while(ldclose(ldp) == FAILURE)
+ ;
+ return -1;
+ }
+ /*
+ * We read the complete loader section in one chunk, this makes
+ * finding long symbol names residing in the string table easier.
+ */
+ if ((ldbuf = (char *)malloc(sh.s_size)) == NULL) {
+ errvalid++;
+ strcpy(errbuf, "readExports: ");
+ strcat(errbuf, strerror(errno));
+ while(ldclose(ldp) == FAILURE)
+ ;
+ return -1;
+ }
+ if (FSEEK(ldp, sh.s_scnptr, BEGINNING) != OKFSEEK) {
+ errvalid++;
+ strcpy(errbuf, "readExports: cannot seek to loader section");
+ free(ldbuf);
+ while(ldclose(ldp) == FAILURE)
+ ;
+ return -1;
+ }
+ if (FREAD(ldbuf, sh.s_size, 1, ldp) != 1) {
+ errvalid++;
+ strcpy(errbuf, "readExports: cannot read loader section");
+ free(ldbuf);
+ while(ldclose(ldp) == FAILURE)
+ ;
+ return -1;
+ }
+ lhp = (LDHDR *)ldbuf;
+ ls = (LDSYM *)(ldbuf+LDHDRSZ);
+ /*
+ * Count the number of exports to include in our export table.
+ */
+ for (i = lhp->l_nsyms; i; i--, ls++) {
+ if (!LDR_EXPORT(*ls))
+ continue;
+ mp->nExports++;
+ }
+ if ((mp->exports = (ExportPtr)calloc(mp->nExports, sizeof(*mp->exports))) == NULL) {
+ errvalid++;
+ strcpy(errbuf, "readExports: ");
+ strcat(errbuf, strerror(errno));
+ free(ldbuf);
+ while(ldclose(ldp) == FAILURE)
+ ;
+ return -1;
+ }
+ /*
+ * Fill in the export table. All entries are relative to
+ * the entry point we got from load.
+ */
+ ep = mp->exports;
+ ls = (LDSYM *)(ldbuf+LDHDRSZ);
+ for (i = lhp->l_nsyms; i; i--, ls++) {
+ char *symname;
+ char tmpsym[SYMNMLEN+1];
+ if (!LDR_EXPORT(*ls))
+ continue;
+ if (ls->l_zeroes == 0)
+ symname = ls->l_offset+lhp->l_stoff+ldbuf;
+ else {
+ /*
+ * The l_name member is not zero terminated, we
+ * must copy the first SYMNMLEN chars and make
+ * sure we have a zero byte at the end.
+ */
+ strncpy(tmpsym, ls->l_name, SYMNMLEN);
+ tmpsym[SYMNMLEN] = '\0';
+ symname = tmpsym;
+ }
+ ep->name = strdup(symname);
+ ep->addr = (void *)((unsigned long)mp->entry +
+ ls->l_value - shdata.s_vaddr);
+ ep++;
+ }
+ free(ldbuf);
+ while(ldclose(ldp) == FAILURE)
+ ;
+ return 0;
+}
+
+/*
+ * Find the main modules entry point. This is used as export pointer
+ * for loadbind() to be able to resolve references to the main part.
+ */
+static void * findMain(void)
+{
+ struct ld_info *lp;
+ char *buf;
+ int size = 4*1024;
+ int i;
+ void *ret;
+
+ if ((buf = malloc(size)) == NULL) {
+ errvalid++;
+ strcpy(errbuf, "findMain: ");
+ strcat(errbuf, strerror(errno));
+ return NULL;
+ }
+ while ((i = loadquery(L_GETINFO, buf, size)) == -1 && errno == ENOMEM) {
+ free(buf);
+ size += 4*1024;
+ if ((buf = malloc(size)) == NULL) {
+ errvalid++;
+ strcpy(errbuf, "findMain: ");
+ strcat(errbuf, strerror(errno));
+ return NULL;
+ }
+ }
+ if (i == -1) {
+ errvalid++;
+ strcpy(errbuf, "findMain: ");
+ strcat(errbuf, strerror(errno));
+ free(buf);
+ return NULL;
+ }
+ /*
+ * The first entry is the main module. The entry point
+ * returned by load() does actually point to the data
+ * segment origin.
+ */
+ lp = (struct ld_info *)buf;
+ ret = lp->ldinfo_dataorg;
+ free(buf);
+ return ret;
+}
--- /dev/null
+/*
+ * @(#)dlfcn.h 1.4 revision of 95/04/25 09:36:52
+ * This is an unpublished work copyright (c) 1992 HELIOS Software GmbH
+ * 30159 Hannover, Germany
+ */
+
+#ifndef __dlfcn_h__
+#define __dlfcn_h__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Mode flags for the dlopen routine.
+ */
+#define RTLD_LAZY 1 /* lazy function call binding */
+#define RTLD_NOW 2 /* immediate function call binding */
+#define RTLD_GLOBAL 0x100 /* allow symbols to be global */
+
+/*
+ * To be able to intialize, a library may provide a dl_info structure
+ * that contains functions to be called to initialize and terminate.
+ */
+struct dl_info {
+ void (*init)(void);
+ void (*fini)(void);
+};
+
+#if __STDC__ || defined(_IBMR2)
+void *dlopen(const char *path, int mode);
+void *dlsym(void *handle, const char *symbol);
+char *dlerror(void);
+int dlclose(void *handle);
+#else
+void *dlopen();
+void *dlsym();
+char *dlerror();
+int dlclose();
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __dlfcn_h__ */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * machine.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: machine.h,v 1.1.1.1 1996/07/09 06:21:41 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MACHINE_H
+#define MACHINE_H
+
+#define BLCKSZ 8192
+
+#endif
+
--- /dev/null
+#!/bin/sh
+#
+# mkldexport
+# create an AIX exports file from an object file
+#
+# Usage:
+# mkldexport objectfile [location]
+# where
+# objectfile is the current location of the object file.
+# location is the eventual (installed) location of the
+# object file (if different from the current
+# working directory).
+#
+# [This file comes from the Postgres 4.2 distribution. - ay 7/95]
+#
+# Header: /usr/local/devel/postgres/src/tools/mkldexport/RCS/mkldexport.sh,v 1.2 1994/03/13 04:59:12 aoki Exp
+#
+
+# setting this to nm -B might be better
+NM = /usr/ucb/nm
+
+CMDNAME=`basename $0`
+if [ -z "$1" ]; then
+ echo "Usage: $CMDNAME object [location]"
+ exit 1
+fi
+OBJNAME=`basename $1`
+if [ "`basename $OBJNAME`" != "`basename $OBJNAME .o`" ]; then
+ OBJNAME=`basename $OBJNAME .o`.so
+fi
+if [ -z "$2" ]; then
+ echo '#!'
+else
+ echo '#!' $2/$OBJNAME
+fi
+$NM -g $1 | \
+ egrep ' [TD] ' | \
+ sed -e 's/.* //' | \
+ egrep -v '\$' | \
+ sed -e 's/^[.]//' | \
+ sort | \
+ uniq
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port-protos.h--
+ * port-specific prototypes for AIX
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: port-protos.h,v 1.1.1.1 1996/07/09 06:21:41 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PORT_PROTOS_H
+#define PORT_PROTOS_H
+
+#include "dlfcn.h" /* this is from jum's libdl package */
+
+/* dynloader.c */
+
+#define pg_dlopen(f) dlopen(filename, RTLD_LAZY)
+#define pg_dlsym(h,f) dlsym(h, f)
+#define pg_dlclose(h) dlclose(h)
+#define pg_dlerror() dlerror()
+
+#endif /* PORT_PROTOS_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for port/alpha (Alpha OSF/1 specific stuff)
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/port/alpha/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:42 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+CFLAGS+= -DUSE_POSIX_TIME -DDISABLE_XOPEN_NLS -DNEED_ISINF -DHAS_LONG_LONG
+
+LDADD+= -lln
+
+#
+# The YACC grammar is too big..
+#
+#.if !defined(CDEBUG)
+##CFLAGS+= -Olimit 2000
+#.endif
+
+HEADERS+= machine.h port-protos.h
+
+SUBSRCS= port.c
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * machine.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: machine.h,v 1.1.1.1 1996/07/09 06:21:42 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MACHINE_H
+#define MACHINE_H
+
+#define BLCKSZ 8192
+
+#endif
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port-protos.h--
+ * prototypes for OSF/1-specific routines
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: port-protos.h,v 1.1.1.1 1996/07/09 06:21:42 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef PORT_PROTOS_H
+#define PORT_PROTOS_H
+
+#include "utils/dynamic_loader.h"
+
+/* dynloader.c */
+
+/*
+ * Dynamic Loader on Alpha OSF/1.x
+ *
+ * this dynamic loader uses the system dynamic loading interface for shared
+ * libraries (ie. dlopen/dlsym/dlclose). The user must specify a shared
+ * library as the file to be dynamically loaded.
+ *
+ */
+#define pg_dlopen(f) dlopen(f, RTLD_LAZY)
+#define pg_dlsym(h, f) ((func_ptr)dlsym(h, f))
+#define pg_dlclose(h) dlclose(h)
+#define pg_dlerror() dlerror()
+
+/* port.c */
+
+extern void init_address_fixup(void);
+
+#endif /* PORT_PROTOS_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port.c--
+ * OSF/1-specific routines
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/port/alpha/Attic/port.c,v 1.1.1.1 1996/07/09 06:21:42 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include
+#include "c.h"
+#include "utils/elog.h"
+
+void
+init_address_fixup()
+{
+#ifdef NOFIXADE
+ int buffer[] = { SSIN_UACPROC, UAC_SIGBUS };
+#endif /* NOFIXADE */
+#ifdef NOPRINTADE
+ int buffer[] = { SSIN_UACPROC, UAC_NOPRINT };
+#endif /* NOPRINTADE */
+
+ if (setsysinfo(SSI_NVPAIRS, buffer, 1, (caddr_t) NULL,
+ (unsigned long) NULL) < 0) {
+ elog(NOTICE, "setsysinfo failed: %d\n", errno);
+ }
+}
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for port/bsdi
+#
+# NOTES
+# The BSD/OS port is included here by courtesy of Kurt Lidl.
+#
+#
+#-------------------------------------------------------------------------
+
+CFLAGS+=-DUSE_POSIX_TIME -DNEED_CBRT
+LDADD+= -ldld -lipc
+SUBSRCS= dynloader.c
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * dynloader.c--
+ * Dynamic Loader for Postgres for Linux, generated from those for
+ * Ultrix.
+ *
+ * You need to install the dld library on your Linux system!
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * /usr/local/devel/pglite/cvs/src/backend/port/linux/dynloader.c,v 1.1.1.1 1994/11/07 05:19:37 andrew Exp
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "postgres.h"
+#include "port-protos.h"
+#include "utils/elog.h"
+#include "fmgr.h"
+
+extern char pg_pathname[];
+
+void *
+pg_dlopen(char *filename)
+{
+ static int dl_initialized= 0;
+
+ /*
+ * initializes the dynamic loader with the executable's pathname.
+ * (only needs to do this the first time pg_dlopen is called.)
+ */
+ if (!dl_initialized) {
+ if (dld_init (dld_find_executable (pg_pathname))) {
+ return NULL;
+ }
+ /*
+ * if there are undefined symbols, we want dl to search from the
+ * following libraries also.
+ */
+ dl_initialized= 1;
+ }
+
+ /*
+ * link the file, then check for undefined symbols!
+ */
+ if (dld_link(filename)) {
+ return NULL;
+ }
+
+ /*
+ * If undefined symbols: try to link with the C and math libraries!
+ * This could be smarter, if the dynamic linker was able to handle
+ * shared libs!
+ */
+ if(dld_undefined_sym_count > 0) {
+ if (dld_link("/usr/lib/libc.a")) {
+ elog(NOTICE, "dld: Cannot link C library!");
+ return NULL;
+ }
+ if(dld_undefined_sym_count > 0) {
+ if (dld_link("/usr/lib/libm.a")) {
+ elog(NOTICE, "dld: Cannot link math library!");
+ return NULL;
+ }
+ if(dld_undefined_sym_count > 0) {
+ int count = dld_undefined_sym_count;
+ char **list= dld_list_undefined_sym();
+
+ /* list the undefined symbols, if any */
+ elog(NOTICE, "dld: Undefined:");
+ do {
+ elog(NOTICE, " %s", *list);
+ list++;
+ count--;
+ } while(count > 0);
+
+ dld_unlink_by_file(filename, 1);
+ return NULL;
+ }
+ }
+ }
+
+ return (void *) strdup(filename);
+}
+
+char *
+pg_dlerror()
+{
+ return dld_strerror(dld_errno);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * machine.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * machine.h,v 1.1.1.1 1994/11/07 05:19:37 andrew Exp
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MACHINE_H
+#define MACHINE_H
+
+#define BLCKSZ 8192
+
+#endif
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port-protos.h--
+ * port-specific prototypes for SunOS 4
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * port-protos.h,v 1.2 1995/05/25 22:51:03 andrew Exp
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PORT_PROTOS_H
+#define PORT_PROTOS_H
+
+#include "fmgr.h" /* for func_ptr */
+#include "utils/dynamic_loader.h"
+
+/* dynloader.c */
+
+#ifndef LINUX_ELF
+#define pg_dlsym(handle, funcname) ((func_ptr) dld_get_func((funcname)))
+#define pg_dlclose(handle) ({ dld_unlink_by_file(handle, 1); free(handle); })
+#else
+#define pg_dlopen(f) dlopen(f, 1)
+#define pg_dlsym dlsym
+#define pg_dlclose dlclose
+#define pg_dlerror dlerror
+#endif
+
+/* port.c */
+
+#endif /* PORT_PROTOS_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port.c--
+ * Linux-specific routines
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * /usr/local/devel/pglite/cvs/src/backend/port/linux/port.c,v 1.1.1.1 1994/11/07 05:19:38 andrew Exp
+ *
+ *-------------------------------------------------------------------------
+ */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for port/hpux (HP-UX specific stuff)
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/port/hpux/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:43 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+#
+# HP-UX needs:
+# -W l,-E export symbols for linking with the shared libraries
+# dynamic loader
+# -W p,-H400000 expand cpp #define table size so the Nodes files don't
+# break it
+#
+# -W p,-H400000
+ifeq ($(CC), cc)
+CFLAGS+= -W l,-E
+LDFLAGS+= -W l,-E
+LDADD+= -ll -ldld
+else
+ifeq ($(CC), gcc)
+LDADD+= -ll /usr/lib/libdld.sl
+endif
+endif
+
+CFLAGS+= -DUSE_POSIX_TIME
+
+#
+# cbrt(3m) and rint(3m) are missing from 8.07.
+# cbrt(3m) and rint(3m) are broken in 9.01.
+# cbrt(3m) seems to be missing on 9.00 even though it is documented.
+#
+CFLAGS+= -DNEED_RINT -DNEED_CBRT
+
+#
+# The #pragma trick required on 8.07 no longer works -- the #pragma
+# is thoroughly broken. However, the +u flag has been extended to
+# handle alignment requirement arguments (defaulting to 2) for things
+# other than struct references, so the #pragma is no longer needed.
+#
+
+#
+# (1) The YACC grammar is too big..
+# (HP-UX 9.0x, x<2, added basic block limits for +O2; 9.0x, x>=2, changed
+# the syntax to something else.)
+#
+# (2) The 9.00 optimizer chokes on some of our source.
+#
+#.if (${HPUX_MAJOR} == "09")
+#. if !defined(CDEBUG)
+#. if (${HPUX_MINOR} == "00" || ${HPUX_MINOR} == "01")
+#CFLAGS+= +Obb600
+#CFLAGS+= -DWEAK_C_OPTIMIZER
+#. else
+#CFLAGS+= +Onolimit
+#. endif
+#. endif
+#.endif
+
+HEADERS+= fixade.h machine.h port-protos.h
+
+SUBSRCS+= dynloader.c port.c tas.s
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * dynloader.c--
+ * dynamic loader for HP-UX using the shared library mechanism
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/port/hpux/Attic/dynloader.c,v 1.1.1.1 1996/07/09 06:21:43 scrappy Exp $
+ *
+ * NOTES
+ * all functions are defined here -- it's impossible to trace the
+ * shl_* routines from the bundled HP-UX debugger.
+ *
+ *-------------------------------------------------------------------------
+ */
+/* System includes */
+#include
+#include "c.h"
+#include "fmgr.h"
+#include "utils/dynamic_loader.h"
+#include "port-protos.h"
+
+void *
+pg_dlopen(char *filename)
+{
+ shl_t handle = shl_load(filename, BIND_DEFERRED, 0);
+
+ return((void *) handle);
+}
+
+func_ptr
+pg_dlsym(void *handle, char *funcname)
+{
+ func_ptr f;
+
+ if (shl_findsym((shl_t *) &handle, funcname, TYPE_PROCEDURE, &f) == -1) {
+ f = (func_ptr) NULL;
+ }
+ return(f);
+}
+
+void
+pg_dlclose(void *handle)
+{
+ shl_unload((shl_t) handle);
+}
+
+char *
+pg_dlerror()
+{
+ static char errmsg[]= "shl_load failed";
+ return errmsg;
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * fixade.h--
+ * compiler tricks to make things work while POSTGRES does non-native
+ * dereferences on PA-RISC.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: fixade.h,v 1.1.1.1 1996/07/09 06:21:43 scrappy Exp $
+ *
+ * NOTES
+ * This must be included in EVERY source file.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef FIXADE_H
+#define FIXADE_H
+
+#if !defined(NOFIXADE)
+
+#if defined(HP_S500_ALIGN)
+/* ----------------
+ * This cheesy hack turns ON unaligned-access fixup on H-P PA-RISC;
+ * the resulting object files contain code that explicitly handles
+ * realignment on reference, so it slows memory access down by a
+ * considerable factor. It must be used in conjunction with the +u
+ * flag to cc. The #pragma is included in c.h to be safe since EVERY
+ * source file that performs unaligned access must contain the #pragma.
+ * ----------------
+ */
+#pragma HP_ALIGN HPUX_NATURAL_S500
+
+#if defined(BROKEN_STRUCT_INIT)
+/* ----------------
+ * This is so bogus. The HP-UX 9.01 compiler has totally broken
+ * struct initialization code. It actually length-checks ALL
+ * array initializations within structs against the FIRST one that
+ * it sees (when #pragma HP_ALIGN HPUX_NATURAL_S500 is defined)..
+ * we have to throw in this unused structure before struct varlena
+ * is defined.
+ *
+ * XXX guess you don't need the #pragma anymore after all :-)
+ * since no one looks at this except me i think i'll just leave
+ * this here for now..
+ * ----------------
+ */
+struct HP_WAY_BOGUS {
+ char hpwb_bogus[8192];
+};
+struct HP_TOO_BOGUS {
+ int hptb_bogus[8192];
+};
+#endif /* BROKEN_STRUCT_INIT */
+#endif /* HP_S500_ALIGN */
+
+#if defined(WEAK_C_OPTIMIZER)
+#pragma OPT_LEVEL 1
+#endif /* WEAK_C_OPTIMIZER */
+
+#endif /* !NOFIXADE */
+
+#endif /* FIXADE_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * machine.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: machine.h,v 1.1.1.1 1996/07/09 06:21:43 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MACHINE_H
+#define MACHINE_H
+
+#define BLCKSZ 8192
+
+#endif
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port-protos.h--
+ * port-specific prototypes for HP-UX
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: port-protos.h,v 1.1.1.1 1996/07/09 06:21:43 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PORT_PROTOS_H
+#define PORT_PROTOS_H
+
+#include /* for struct rusage */
+#include
/* for shl_t */+
+#include "utils/dynamic_loader.h"
+
+/* dynloader.c */
+
+/* pg_dl{open,close,sym} prototypes are in utils/dynamic_loader.h */
+
+/* port.c */
+
+extern int init_address_fixup(void);
+extern double rint(double x);
+extern double cbrt(double x);
+extern long random(void);
+extern void srandom(int seed);
+extern int getrusage(int who, struct rusage *ru);
+
+#endif /* PORT_PROTOS_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port.c--
+ * port-specific routines for HP-UX
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/port/hpux/Attic/port.c,v 1.1.1.1 1996/07/09 06:21:43 scrappy Exp $
+ *
+ * NOTES
+ * For the most part, this file gets around some non-POSIX calls
+ * in POSTGRES.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* for rand()/srand() prototypes */
+#include /* for pow() prototype */
+#include /* for syscall #defines */
+
+#include "c.h"
+
+void
+init_address_fixup()
+{
+ /*
+ * On PA-RISC, unaligned access fixup is handled by the compiler,
+ * not by the kernel.
+ */
+}
+
+long
+random()
+{
+ return(lrand48());
+}
+
+void srandom(int seed)
+{
+ srand48((long int) seed);
+}
+
+getrusage(int who, struct rusage *ru)
+{
+ return(syscall(SYS_GETRUSAGE, who, ru));
+}
--- /dev/null
+/*
+ * To generate tas.s using this template:
+ * 1. cc +O2 -S -c tas.c
+ * 2. edit tas.s:
+ * - replace the LDW with LDCWX
+ * For details about the LDCWX instruction, see the "Precision
+ * Architecture and Instruction Reference Manual" (09740-90014 of June
+ * 1987), p. 5-38.
+ */
+
+int
+tas(lock)
+ int *lock; /* LDCWX is a word instruction */
+{
+ /*
+ * LDCWX requires that we align the "semaphore" to a 16-byte
+ * boundary. The actual datum is a single word (4 bytes).
+ */
+ lock = ((long) lock + 15) & ~15;
+
+ /*
+ * The LDCWX instruction atomically clears the target word and
+ * returns the previous value. Hence, if the instruction returns
+ * 0, someone else has already acquired the lock before we tested
+ * it (i.e., we have failed).
+ *
+ * Notice that this means that we actually clear the word to set
+ * the lock and set the word to clear the lock. This is the
+ * opposite behavior from the SPARC LDSTUB instruction. For some
+ * reason everything that H-P does is rather baroque...
+ */
+ if (*lock) { /* this generates the LDW */
+ return(0); /* success */
+ }
+ return(1); /* failure */
+}
--- /dev/null
+
+ .SPACE $TEXT$,SORT=8
+ .SUBSPA $CODE$,QUAD=0,ALIGN=4,ACCESS=44,CODE_ONLY,SORT=24
+tas
+ .PROC
+ .CALLINFO CALLER,FRAME=0,ENTRY_SR=3
+ .ENTRY
+ LDO 15(%r26),%r31 ;offset 0x0
+ DEPI 0,31,4,%r31 ;offset 0x4
+ LDCWX 0(0,%r31),%r23 ;offset 0x8
+ COMICLR,= 0,%r23,%r0 ;offset 0xc
+ DEP,TR %r0,31,32,%r28 ;offset 0x10
+$00000001
+ LDI 1,%r28 ;offset 0x14
+$L0
+ .EXIT
+ BV,N %r0(%r2) ;offset 0x18
+ .PROCEND ;in=26;out=28;
+
+
+ .SPACE $TEXT$
+ .SUBSPA $CODE$
+ .SPACE $PRIVATE$,SORT=16
+ .SUBSPA $DATA$,QUAD=1,ALIGN=8,ACCESS=31,SORT=16
+ .SPACE $TEXT$
+ .SUBSPA $CODE$
+ .EXPORT tas,ENTRY,PRIV_LEV=3,ARGW0=GR,RTNVAL=GR
+ .END
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for port/irix5 (IRIX 5 specific stuff)
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# /usr/local/devel/pglite/cvs/src/backend/port/sparc_solaris/Makefile.inc,v 1.3 1995/03/21 06:51:21 andrew Exp
+#
+#-------------------------------------------------------------------------
+
+CFLAGS+= -DUSE_POSIX_TIME -DNEED_ISINF -DNO_EMPTY_STMTS
+
+LDADD+= -ll
+
+SUBSRCS+= port.c
+
+HEADERS+= machine.h port-protos.h
--- /dev/null
+The IRIX 5 port was contributed by
+ Paul 'Shag' Walmsley
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * machine.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * machine.h,v 1.1.1.1 1994/11/07 05:19:38 andrew Exp
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MACHINE_H
+#define MACHINE_H
+
+#define BLCKSZ 8192
+
+#endif
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port-protos.h--
+ * port-specific prototypes for Irix 5
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * port-protos.h,v 1.2 1995/03/17 06:40:18 andrew Exp
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PORT_PROTOS_H
+#define PORT_PROTOS_H
+
+#include "fmgr.h" /* for func_ptr */
+#include "utils/dynamic_loader.h"
+
+/* dynloader.c */
+/*
+ * Dynamic Loader on SunOS 4.
+ *
+ * this dynamic loader uses the system dynamic loading interface for shared
+ * libraries (ie. dlopen/dlsym/dlclose). The user must specify a shared
+ * library as the file to be dynamically loaded.
+ *
+ */
+#define pg_dlopen(f) dlopen(f,1)
+#define pg_dlsym dlsym
+#define pg_dlclose dlclose
+#define pg_dlerror dlerror
+
+/* port.c */
+extern long random(void);
+
+#endif /* PORT_PROTOS_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port.c--
+ * Irix5-specific routines
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * /usr/local/devel/pglite/cvs/src/backend/port/sparc_solaris/port.c,v 1.2 1995/03/17 06:40:19 andrew Exp
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* for pow() prototype */
+
+#include
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for port/linux (Linux specific stuff)
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/port/linux/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:44 scrappy Exp $
+#
+# NOTES
+# The Linux port is included here by courtesy of Kai Petzke.
+#
+#
+#-------------------------------------------------------------------------
+
+#
+# linux has fast linkers and don't need the BIGOBJ stuff.
+#
+BIGOBJS= false
+
+
+ifdef LINUX_ELF
+CC=gcc
+LDADD+= -ldl
+CFLAGS+= -DLINUX_ELF
+else
+LDADD+= -ldld
+SUBSRCS+= dynloader.c
+endif
+
+HEADERS+= machine.h port-protos.h
+CFLAGS+= -DNEED_CBRT
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * dynloader.c--
+ * Dynamic Loader for Postgres for Linux, generated from those for
+ * Ultrix.
+ *
+ * You need to install the dld library on your Linux system!
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/port/linux/Attic/dynloader.c,v 1.1.1.1 1996/07/09 06:21:44 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "postgres.h"
+#include "port-protos.h"
+#include "utils/elog.h"
+#include "fmgr.h"
+
+extern char pg_pathname[];
+
+void *
+pg_dlopen(char *filename)
+{
+ static int dl_initialized= 0;
+
+ /*
+ * initializes the dynamic loader with the executable's pathname.
+ * (only needs to do this the first time pg_dlopen is called.)
+ */
+ if (!dl_initialized) {
+ if (dld_init (dld_find_executable (pg_pathname))) {
+ return NULL;
+ }
+ /*
+ * if there are undefined symbols, we want dl to search from the
+ * following libraries also.
+ */
+ dl_initialized= 1;
+ }
+
+ /*
+ * link the file, then check for undefined symbols!
+ */
+ if (dld_link(filename)) {
+ return NULL;
+ }
+
+ /*
+ * If undefined symbols: try to link with the C and math libraries!
+ * This could be smarter, if the dynamic linker was able to handle
+ * shared libs!
+ */
+ if(dld_undefined_sym_count > 0) {
+ if (dld_link("/usr/lib/libc.a")) {
+ elog(NOTICE, "dld: Cannot link C library!");
+ return NULL;
+ }
+ if(dld_undefined_sym_count > 0) {
+ if (dld_link("/usr/lib/libm.a")) {
+ elog(NOTICE, "dld: Cannot link math library!");
+ return NULL;
+ }
+ if(dld_undefined_sym_count > 0) {
+ int count = dld_undefined_sym_count;
+ char **list= dld_list_undefined_sym();
+
+ /* list the undefined symbols, if any */
+ elog(NOTICE, "dld: Undefined:");
+ do {
+ elog(NOTICE, " %s", *list);
+ list++;
+ count--;
+ } while(count > 0);
+
+ dld_unlink_by_file(filename, 1);
+ return NULL;
+ }
+ }
+ }
+
+ return (void *) strdup(filename);
+}
+
+char *
+pg_dlerror()
+{
+ return dld_strerror(dld_errno);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * machine.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: machine.h,v 1.1.1.1 1996/07/09 06:21:44 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MACHINE_H
+#define MACHINE_H
+
+#define BLCKSZ 8192
+
+#endif
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port-protos.h--
+ * port-specific prototypes for SunOS 4
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: port-protos.h,v 1.1.1.1 1996/07/09 06:21:44 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PORT_PROTOS_H
+#define PORT_PROTOS_H
+
+#include "fmgr.h" /* for func_ptr */
+#include "utils/dynamic_loader.h"
+#ifdef LINUX_ELF
+#include "dlfcn.h"
+#endif
+
+/* dynloader.c */
+
+#ifndef LINUX_ELF
+#define pg_dlsym(handle, funcname) ((func_ptr) dld_get_func((funcname)))
+#define pg_dlclose(handle) ({ dld_unlink_by_file(handle, 1); free(handle); })
+#else
+/* #define pg_dlopen(f) dlopen(f, 1) */
+#define pg_dlopen(f) dlopen(f, 2)
+#define pg_dlsym dlsym
+#define pg_dlclose dlclose
+#define pg_dlerror dlerror
+#endif
+
+/* port.c */
+
+#endif /* PORT_PROTOS_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port.c--
+ * Linux-specific routines
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/port/linux/Attic/port.c,v 1.1.1.1 1996/07/09 06:21:44 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for port/sparc (SPARC/SunOS 4 specific stuff)
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/port/sparc/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:44 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+CFLAGS+= -DUSE_POSIX_TIME
+
+LDADD+= -lln -ldl
+
+#
+# SunOS 4 strtol is broken -- doesn't report overflow using errno.
+#
+SUBSRCS= strtol.c
+
+HEADERS+= float.h machine.h port-protos.h
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * float.h--
+ * definitions for ANSI floating point
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: float.h,v 1.1.1.1 1996/07/09 06:21:44 scrappy Exp $
+ *
+ * NOTES
+ * These come straight out of ANSI X3.159-1989 (p.18) and
+ * would be unnecessary if SunOS 4 were ANSI-compliant.
+ *
+ * This is only a partial listing because I'm lazy to type
+ * the whole thing in.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef FLOAT_H
+#define FLOAT_H
+
+#define FLT_DIG 6
+#define FLT_MIN ((float) 1.17549435e-38)
+#define FLT_MAX ((float) 3.40282347e+38)
+#define DBL_DIG 15
+#define DBL_MIN 2.2250738585072014e-308
+#define DBL_MAX 1.7976931348623157e+308
+
+#endif /* FLOAT_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * machine.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: machine.h,v 1.1.1.1 1996/07/09 06:21:44 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MACHINE_H
+#define MACHINE_H
+
+#define BLCKSZ 8192
+
+#endif
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port-protos.h--
+ * port-specific prototypes for SunOS 4
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: port-protos.h,v 1.1.1.1 1996/07/09 06:21:44 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PORT_PROTOS_H
+#define PORT_PROTOS_H
+
+#include "fmgr.h" /* for func_ptr */
+#include "utils/dynamic_loader.h"
+
+/* dynloader.c */
+/*
+ * Dynamic Loader on SunOS 4.
+ *
+ * this dynamic loader uses the system dynamic loading interface for shared
+ * libraries (ie. dlopen/dlsym/dlclose). The user must specify a shared
+ * library as the file to be dynamically loaded.
+ *
+ */
+#define pg_dlopen(f) dlopen(f, 1)
+#define pg_dlsym dlsym
+#define pg_dlclose dlclose
+#define pg_dlerror dlerror
+
+#endif /* PORT_PROTOS_H */
--- /dev/null
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)strtol.c 5.4 (Berkeley) 2/23/91";
+#endif /* LIBC_SCCS and not lint */
+
+#include
+#include
+#include
+#include
+
+#define const
+
+/*
+ * Convert a string to a long integer.
+ *
+ * Ignores `locale' stuff. Assumes that the upper and lower case
+ * alphabets and digits are each contiguous.
+ */
+long
+strtol(nptr, endptr, base)
+ const char *nptr;
+ char **endptr;
+ register int base;
+{
+ register const char *s = nptr;
+ register unsigned long acc;
+ register int c;
+ register unsigned long cutoff;
+ register int neg = 0, any, cutlim;
+
+ /*
+ * Skip white space and pick up leading +/- sign if any.
+ * If base is 0, allow 0x for hex and 0 for octal, else
+ * assume decimal; if base is already 16, allow 0x.
+ */
+ do {
+ c = *s++;
+ } while (isspace(c));
+ if (c == '-') {
+ neg = 1;
+ c = *s++;
+ } else if (c == '+')
+ c = *s++;
+ if ((base == 0 || base == 16) &&
+ c == '0' && (*s == 'x' || *s == 'X')) {
+ c = s[1];
+ s += 2;
+ base = 16;
+ }
+ if (base == 0)
+ base = c == '0' ? 8 : 10;
+
+ /*
+ * Compute the cutoff value between legal numbers and illegal
+ * numbers. That is the largest legal value, divided by the
+ * base. An input number that is greater than this value, if
+ * followed by a legal input character, is too big. One that
+ * is equal to this value may be valid or not; the limit
+ * between valid and invalid numbers is then based on the last
+ * digit. For instance, if the range for longs is
+ * [-2147483648..2147483647] and the input base is 10,
+ * cutoff will be set to 214748364 and cutlim to either
+ * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated
+ * a value > 214748364, or equal but the next digit is > 7 (or 8),
+ * the number is too big, and we will return a range error.
+ *
+ * Set any if any `digits' consumed; make it negative to indicate
+ * overflow.
+ */
+ cutoff = neg ? -(unsigned long)LONG_MIN : LONG_MAX;
+ cutlim = cutoff % (unsigned long)base;
+ cutoff /= (unsigned long)base;
+ for (acc = 0, any = 0;; c = *s++) {
+ if (isdigit(c))
+ c -= '0';
+ else if (isalpha(c))
+ c -= isupper(c) ? 'A' - 10 : 'a' - 10;
+ else
+ break;
+ if (c >= base)
+ break;
+ if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
+ any = -1;
+ else {
+ any = 1;
+ acc *= base;
+ acc += c;
+ }
+ }
+ if (any < 0) {
+ acc = neg ? LONG_MIN : LONG_MAX;
+ errno = ERANGE;
+ } else if (neg)
+ acc = -acc;
+ if (endptr != 0)
+ *endptr = any ? s - 1 : (char *)nptr;
+ return (acc);
+}
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for port/sparc_solaris (SPARC/Solaris 2.x specific stuff)
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/port/sparc_solaris/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:45 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+CFLAGS+= -DUSE_POSIX_TIME -DNEED_ISINF -DNEED_RUSAGE -DNO_EMPTY_STMTS
+
+LDADD+= -ll -ldl
+
+SUBSRCS+= port.c tas.s
+
+HEADERS+= machine.h port-protos.h rusagestub.h
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * machine.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: machine.h,v 1.1.1.1 1996/07/09 06:21:45 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MACHINE_H
+#define MACHINE_H
+
+#define BLCKSZ 8192
+
+#endif
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port-protos.h--
+ * port-specific prototypes for SunOS 4
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: port-protos.h,v 1.1.1.1 1996/07/09 06:21:45 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PORT_PROTOS_H
+#define PORT_PROTOS_H
+
+#include "fmgr.h" /* for func_ptr */
+#include "utils/dynamic_loader.h"
+
+/* dynloader.c */
+/*
+ * Dynamic Loader on SunOS 4.
+ *
+ * this dynamic loader uses the system dynamic loading interface for shared
+ * libraries (ie. dlopen/dlsym/dlclose). The user must specify a shared
+ * library as the file to be dynamically loaded.
+ *
+ */
+#define pg_dlopen(f) dlopen(f,1)
+#define pg_dlsym dlsym
+#define pg_dlclose dlclose
+#define pg_dlerror dlerror
+
+/* port.c */
+extern long random(void);
+extern void srandom(int seed);
+
+#endif /* PORT_PROTOS_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port.c--
+ * SunOS5-specific routines
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/port/sparc_solaris/Attic/port.c,v 1.1.1.1 1996/07/09 06:21:45 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* for pow() prototype */
+
+#include
+#include "rusagestub.h"
+
+long
+random()
+{
+ return(lrand48());
+}
+
+void
+srandom(int seed)
+{
+ srand48((long int) seed);
+}
+
+int
+getrusage(int who, struct rusage *rusage)
+{
+ struct tms tms;
+ register int tick_rate = CLK_TCK; /* ticks per second */
+ clock_t u, s;
+
+ if (rusage == (struct rusage *) NULL) {
+ errno = EFAULT;
+ return(-1);
+ }
+ if (times(&tms) < 0) {
+ /* errno set by times */
+ return(-1);
+ }
+ switch (who) {
+ case RUSAGE_SELF:
+ u = tms.tms_utime;
+ s = tms.tms_stime;
+ break;
+ case RUSAGE_CHILDREN:
+ u = tms.tms_cutime;
+ s = tms.tms_cstime;
+ break;
+ default:
+ errno = EINVAL;
+ return(-1);
+ }
+#define TICK_TO_SEC(T, RATE) ((T)/(RATE))
+#define TICK_TO_USEC(T,RATE) (((T)%(RATE)*1000000)/RATE)
+ rusage->ru_utime.tv_sec = TICK_TO_SEC(u, tick_rate);
+ rusage->ru_utime.tv_usec = TICK_TO_USEC(u, tick_rate);
+ rusage->ru_stime.tv_sec = TICK_TO_SEC(s, tick_rate);
+ rusage->ru_stime.tv_usec = TICK_TO_USEC(u, tick_rate);
+ return(0);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * rusagestub.h--
+ * Stubs for getrusage(3).
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: rusagestub.h,v 1.1.1.1 1996/07/09 06:21:45 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef RUSAGESTUB_H
+#define RUSAGESTUB_H
+
+#include /* for struct timeval */
+#include /* for struct tms */
+#include /* for CLK_TCK */
+
+#define RUSAGE_SELF 0
+#define RUSAGE_CHILDREN -1
+
+struct rusage {
+ struct timeval ru_utime; /* user time used */
+ struct timeval ru_stime; /* system time used */
+};
+
+extern int getrusage(int who, struct rusage *rusage);
+
+#endif /* RUSAGESTUB_H */
--- /dev/null
+ !!
+ !! $Header: /cvsroot/pgsql/src/backend/port/sparc_solaris/Attic/tas.s,v 1.1.1.1 1996/07/09 06:21:45 scrappy Exp $
+ !!
+ !! this would be a piece of inlined assembler but it appears
+ !! to be easier to just write the assembler than to try to
+ !! figure out how to make sure that in/out registers are kept
+ !! straight in the asm's.
+ !!
+ .file "tas.c"
+.section ".text"
+ .align 4
+ .global tas
+ .type tas,#function
+ .proc 04
+tas:
+ !!
+ !! this is a leaf procedure - no need to save windows and
+ !! diddle the CWP.
+ !!
+ !#PROLOGUE# 0
+ !#PROLOGUE# 1
+
+ !!
+ !! write 0xFF into the lock address, saving the old value in %o0.
+ !! this is an atomic action, even on multiprocessors.
+ !!
+ ldstub [%o0],%o0
+
+ !!
+ !! if it was already set when we set it, somebody else already
+ !! owned the lock -- return 1.
+ !!
+ cmp %o0,0
+ bne .LL2
+ mov 1,%o0
+
+ !!
+ !! otherwise, it was clear and we now own the lock -- return 0.
+ !!
+ mov 0,%o0
+.LL2:
+ !!
+ !! this is a leaf procedure - no need to restore windows and
+ !! diddle the CWP.
+ !!
+ retl
+ nop
+.LLfe1:
+ .size tas,.LLfe1-tas
+ .ident "GCC: (GNU) 2.5.8"
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for port/ultrix (Ultrix4.x specific stuff)
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/port/ultrix4/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:45 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+CFLAGS+= -DNEED_ISINF -DUSE_POSIX_TIME
+
+LDADD+= -ldl -lln
+
+#
+# The YACC grammar is too big..
+#
+#.if !defined(CDEBUG)
+#CFLAGS+= -Olimit 2000
+#.endif
+
+HEADERS+= dl.h machine.h port-protos.h
+
+SUBSRCS+= dynloader.c port.c strdup.c
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * dl.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: dl.h,v 1.1.1.1 1996/07/09 06:21:45 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ * Ultrix 4.x Dynamic Loader Library Version 1.0
+ *
+ * dl.h--
+ * header file for the Dynamic Loader Library
+ *
+ *
+ * Copyright (c) 1993 Andrew K. Yu, University of California at Berkeley
+ * All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for educational, research, and non-profit purposes and
+ * without fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation. Permission
+ * to incorporate this software into commercial products can be obtained
+ * from the author. The University of California and the author make
+ * no representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ *
+ */
+#ifndef _DL_HEADER_
+#define _DL_HEADER_
+
+#include
+#include
+#include
+#include
+#include
+
+
+typedef long CoreAddr;
+
+
+typedef struct ScnInfo {
+ CoreAddr addr; /* starting address of the section */
+ SCNHDR hdr; /* section header */
+ RELOC *relocEntries; /* relocation entries */
+} ScnInfo;
+
+typedef enum {
+ DL_NEEDRELOC, /* still need relocation */
+ DL_RELOCATED, /* no relocation necessary */
+ DL_INPROG /* relocation in progress */
+} dlRStatus;
+
+typedef struct JmpTbl {
+ char *block; /* the jump table memory block */
+ struct JmpTbl *next; /* next block */
+} JmpTbl;
+
+typedef struct dlFile {
+ char *filename; /* file name of the object file */
+
+ int textSize; /* used by mprotect */
+ CoreAddr textAddress; /* start addr of text section */
+ long textVaddr; /* vaddr of text section in obj file */
+ CoreAddr rdataAddress; /* start addr of rdata section */
+ long rdataVaddr; /* vaddr of text section in obj file */
+ CoreAddr dataAddress; /* start addr of data section */
+ long dataVaddr; /* vaddr of text section in obj file */
+ CoreAddr bssAddress; /* start addr of bss section */
+ long bssVaddr; /* vaddr of text section in obj file */
+
+ int nsect; /* number of sections */
+ ScnInfo *sect; /* details of each section (array) */
+
+ int issExtMax; /* size of string space */
+ char *extss; /* extern sym string space (in core) */
+ int iextMax; /* maximum number of Symbols */
+ pEXTR extsyms; /* extern syms */
+
+ dlRStatus relocStatus; /* what relocation needed? */
+ int needReloc;
+
+ JmpTbl *jmptable; /* the jump table for R_JMPADDR */
+
+ struct dlFile *next; /* next member of the archive */
+} dlFile;
+
+typedef struct dlSymbol {
+ char *name; /* name of the symbol */
+ long addr; /* address of the symbol */
+ dlFile *objFile; /* from which file */
+} dlSymbol;
+
+/*
+ * prototypes for the dl* interface
+ */
+extern void *dl_open(/* char *filename, int mode */);
+extern void *dl_sym(/* void *handle, char *name */);
+extern void dl_close(/* void *handle */);
+extern char *dl_error(/* void */);
+
+#define DL_LAZY 0 /* lazy resolution */
+#define DL_NOW 1 /* immediate resolution */
+
+/*
+ * Miscellaneous utility routines:
+ */
+extern char **dl_undefinedSymbols(/* int *count */);
+extern void dl_printAllSymbols(/* void *handle */);
+extern void dl_setLibraries(/* char *libs */);
+
+#endif _DL_HEADER_
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * dynloader.c--
+ * This dynamic loader uses Andrew Yu's libdl-1.0 package for Ultrix 4.x.
+ * (Note that pg_dlsym and pg_dlclose are actually macros defined in
+ * "port-protos.h".)
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/port/ultrix4/Attic/dynloader.c,v 1.1.1.1 1996/07/09 06:21:45 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "dl.h"
+#include "c.h"
+#include "fmgr.h"
+#include "port-protos.h"
+#include "utils/elog.h"
+
+extern char pg_pathname[];
+
+void *
+pg_dlopen(char *filename)
+{
+ static int dl_initialized= 0;
+ void *handle;
+
+ /*
+ * initializes the dynamic loader with the executable's pathname.
+ * (only needs to do this the first time pg_dlopen is called.)
+ */
+ if (!dl_initialized) {
+ if (!dl_init(pg_pathname)) {
+ return NULL;
+ }
+ /*
+ * if there are undefined symbols, we want dl to search from the
+ * following libraries also.
+ */
+ dl_setLibraries("/usr/lib/libm_G0.a:/usr/lib/libc_G0.a");
+ dl_initialized= 1;
+ }
+
+ /*
+ * open the file. We do the symbol resolution right away so that we
+ * will know if there are undefined symbols. (This is in fact the
+ * same semantics as "ld -A". ie. you cannot have undefined symbols.
+ */
+ if ((handle=dl_open(filename, DL_NOW))==NULL) {
+ int count;
+ char **list= dl_undefinedSymbols(&count);
+
+ /* list the undefined symbols, if any */
+ if(count) {
+ elog(NOTICE, "dl: Undefined:");
+ while(*list) {
+ elog(NOTICE, " %s", *list);
+ list++;
+ }
+ }
+ }
+
+ return (void *)handle;
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * machine.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: machine.h,v 1.1.1.1 1996/07/09 06:21:45 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MACHINE_H
+#define MACHINE_H
+
+#define BLCKSZ 8192
+
+#endif
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port-protos.h--
+ * prototypes for Ultrix-specific routines
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: port-protos.h,v 1.1.1.1 1996/07/09 06:21:45 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PORT_PORTOS_H
+#define PORT_PORTOS_H
+
+#include "utils/dynamic_loader.h"
+#include "dl.h"
+
+/* dynloader.c */
+/*
+ * New dynamic loader.
+ *
+ * This dynamic loader uses Andrew Yu's libdl-1.0 package for Ultrix 4.x.
+ * (Note that pg_dlsym and pg_dlclose are actually macros defined in
+ * "port-protos.h".)
+ */
+
+#define pg_dlsym(h, f) ((func_ptr)dl_sym(h, f))
+#define pg_dlclose(h) dl_close(h)
+#define pg_dlerror() dl_error()
+
+/* port.c */
+
+extern void init_address_fixup(void);
+
+#endif /* PORT_PORTOS_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * port.c--
+ * Ultrix-specific routines
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/port/ultrix4/Attic/port.c,v 1.1.1.1 1996/07/09 06:21:45 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+
+#include "c.h"
+
+void
+init_address_fixup()
+{
+#ifdef NOFIXADE
+ syscall(SYS_sysmips, MIPS_FIXADE, 0, NULL, NULL, NULL);
+#endif /* NOFIXADE */
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * strdup.c--
+ * copies a null-terminated string.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/port/ultrix4/Attic/strdup.c,v 1.1.1.1 1996/07/09 06:21:45 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+
+char *
+strdup(char *string)
+{
+ char *nstr;
+
+ nstr = strcpy((char *)palloc(strlen(string)+1), string);
+ return nstr;
+}
--- /dev/null
+#define BLCKSZ 8192
+#define NOFILE 100
--- /dev/null
+#include
+#include
+#include "postgres.h"
+#include "storage/ipc.h"
+
+/* The name of the Postgres 95 ipc file mapping object */
+#define IPC_NAME "PG95_IPC"
+
+/* The name of the Postgres 95 ipc file mapping object semaphore */
+#define IPC_SEM_NAME "PG95_IPC_SEM"
+
+/* The maximum length of a shared memory object name */
+#define IPC_MAX_SHMEM_NAME 32
+
+/* The maximum number of emulated Unix shared memory segments */
+#define IPC_NMAXSHM 10
+
+/* The Maximum number of elements in a semaphore set. Note that this
+** is just a guess.
+*/
+#define IPC_NMAXSEMGRP 7
+
+/* The various states of a semaphore */
+#define SIGNALED 1
+#define UNSIGNALED 0
+#define UNUSED -1
+
+/* The security attribute structure necessary for handles to be inhereted */
+SECURITY_ATTRIBUTES sec_attrib = { sizeof (LPSECURITY_ATTRIBUTES),
+ NULL, TRUE};
+
+/*
+Postgres95 uses semaphores and shared memory. Both are provided by
+Unix and NT, although NT uses a different method for referencing
+them. Rather than changing the function calls used by Postgres95
+to use NT system services, we've written code to emulate the Unix
+system calls. We deliberately don't do a complete emulation of the
+Unix calls, partly because it doesn't appear possible, but also
+because only a few options of the Unix calls are actually used by
+Postgres95.
+
+The most noticable difference between the way Unix and NT use semaphores
+is that the central entity on Unix is a semaphore set consisting of
+potientially many actual semaphores whereas on NT a semaphore handle
+represents just one actual semaphore. Furthermore, a Unix semaphore set
+is identified by one semaphore id no matter how many elements there
+are in the set. Given a Unix semaphore id, the Unix API provides a way
+to index into the set to reference a specific semaphore.
+
+You might think that since both a semaphore id and a semaphore handle
+is just an integer there won't be any changes necessary to the Postgres95
+code to deal with NT semaphores. If it weren't for the existence of
+multi-semaphore semaphore sets this would be true.
+
+To handle semaphore sets a fixed-size table, whose size is partially
+based on the sum of the maximum number of semaphores times the maximum
+number of semaphores per semaphore set, is created and kept in shared
+memory that is visable to every backend started by the Postmaster.
+
+Each semaphore set entry consists of an arbitrary key value, which serves
+to identify the semaphore set, and IPC_NMAXSEMGRP array elements to
+store the NT semaphore handles representing the NT semaphore used for
+the semaphore set. Semaphore IDs are just indices into this table.
+In order to distinguish occupied entries in this table -1 is always
+considered an invalid semaphore ID.
+
+This table is also used to store information about shared memory
+segments. Fortunately, there is a one-to-one mapping between Unix
+shared memory IDs and NT shared memory handles so the code to emulate
+Unix shared memory is simple.
+*/
+
+/* We need one of these for each emulated semaphore set */
+struct Pg_sem
+{
+ key_t Pg_sem_key;
+ HANDLE Pg_sem_handle[IPC_NMAXSEMGRP];
+ int Pg_sem_nsems;
+};
+
+/* We need one of these for each emulated shared memory segment */
+struct Pg_shm
+{
+ key_t Pg_shm_key;
+ HANDLE Pg_shm_handle;
+};
+
+/* This structure is what's stored in shared memory. Note that
+** since both the shared memory and semaphore data is in the same
+** table, and the table is protected by a single NT semaphore, there's
+** a chance that semaphore manipulation could be slowed down by
+** shared memory manipulation, and vice versa. But, since both are
+** allocated primarily when the Postmaster starts up, which isn't time
+** critical, I don't think this will prove to be a problem.
+*/
+
+static struct Pg_shared
+{
+ int Pg_next_sem;
+ int Pg_next_shm;
+ struct Pg_sem Pg_sem[IPC_NMAXSEM];
+ struct Pg_shm Pg_shm[IPC_NMAXSHM];
+} *Pg_shared_ptr;
+
+/* The semaphore that protects the shared memory table */
+HANDLE Pg_shared_hnd;
+
+/*
+** Perform a semaphore operation. We're passed a semaphore set id,
+** a pointer to an array of sembuf structures, and the number
+** of elements in the array. Each element in the sembuf structure
+** describes a specific semaphore within the semaphore set and the
+** operation to perform on it.
+*/
+
+int
+semop(int semid, struct sembuf *sops, u_int nsops)
+{
+ u_int i;
+ int result;
+ HANDLE hndl;
+
+ /* Go through all the sops structures */
+ for (i = 0; i < nsops; i++)
+ {
+ struct sembuf *sptr;
+ int semval;
+ int av_sem_op;
+
+ sptr = &sops[i];
+ /*
+ printf("performing %d in sem # %d\n", sptr->sem_op, sptr->sem_num);
+ */
+
+ /*
+ ** Postgres95 uses -255 to represent a lock request
+ ** and 255 to show a lock release. Changing these values
+ ** to -1 and 1 make it easier to keep track of the state
+ ** of the semaphore.
+ */
+ if (sptr->sem_op == -255)
+ sptr->sem_op = -1;
+ else if (sptr->sem_op == 255)
+ sptr->sem_op = 1;
+ else
+ printf("invalid sem_op %d\n", sptr->sem_op);
+
+ _get_ipc_sem();
+ hndl = Pg_shared_ptr->Pg_sem[semid].Pg_sem_handle[sptr->sem_num];
+ _rel_ipc_sem();
+ semval = _get_sem_val(hndl);
+
+ if (sptr->sem_op == 0)
+ {
+ if (semval == UNSIGNALED)
+ return(semval);
+ else
+ {
+ if (sptr->sem_flg & IPC_NOWAIT)
+ return(SIGNALED);
+ else
+ result = WaitForSingleObject(hndl, 5000);
+ }
+ }
+
+ av_sem_op = abs(sptr->sem_op);
+
+ /* If a lock is being attempted */
+ if (sptr->sem_op < 0)
+ {
+ if (semval >= av_sem_op)
+ {
+ semval -= av_sem_op;
+ if (semval <= UNSIGNALED)
+ result = WaitForSingleObject(hndl, 5000);
+ }
+ else
+ {
+ if (sptr->sem_flg & IPC_NOWAIT)
+ return(SIGNALED);
+ else
+ result = WaitForSingleObject(hndl, 5000);
+ }
+ }
+
+ /* If a lock is being released */
+ if (sptr->sem_op > 0)
+ {
+ semval += av_sem_op;
+ if (semval > 0)
+ ReleaseSemaphore(hndl, 1, NULL);
+ }
+ }
+}
+
+int
+semget(key_t key, int nsems, int semflg)
+{
+ int id, new_sem, ret_val;
+
+ /* If nmsems is 0 then assume that we're just checking whether
+ ** the semaphore identified by key exists. Assume that
+ ** if key is IPC_PRIVATE that this should always fail.
+ */
+ if (nsems == 0)
+ {
+ if (key == IPC_PRIVATE)
+ ret_val = -1;
+ else
+ {
+ _get_ipc_sem();
+ id = _get_sem_id(key);
+ _rel_ipc_sem();
+ ret_val = id;
+ }
+ return(ret_val);
+ }
+
+ /* See if there's already a semaphore with the key.
+ ** If not, record the key, allocate enough space for the
+ ** handles of the semaphores, and then create the semaphores.
+ */
+ _get_ipc_sem();
+ id = _get_sem_id(key);
+ if (id == UNUSED)
+ {
+ register int i;
+ struct Pg_sem *pg_ptr;
+
+ new_sem = Pg_shared_ptr->Pg_next_sem++;
+
+ pg_ptr = &(Pg_shared_ptr->Pg_sem[new_sem]);
+ pg_ptr->Pg_sem_key = key;
+ pg_ptr->Pg_sem_nsems = nsems;
+
+ for (i = 0; i < nsems; i++)
+ pg_ptr->Pg_sem_handle[i] = CreateSemaphore(&sec_attrib, 1, 255, NULL);
+ ret_val = new_sem;
+ }
+ else
+ ret_val = id;
+ _rel_ipc_sem();
+ return(ret_val);
+}
+
+/* These next two functions could be written as one function, although
+** doing so would require some additional logic.
+*/
+
+/* Given a semaphore key, return the corresponding id.
+** This function assumes that the shared memory table is being
+** protected by the shared memory table semaphore.
+*/
+_get_sem_id(key_t key)
+{
+ register int i;
+
+ /* Go through the shared memory table looking for a semaphore
+ ** whose key matches what we're looking for
+ */
+ for (i = 0; i < Pg_shared_ptr->Pg_next_sem; i++)
+ if (Pg_shared_ptr->Pg_sem[i].Pg_sem_key == key)
+ return(i);
+
+ /* Return UNUSED if we didn't find a match */
+ return(UNUSED);
+}
+
+/* Given a shared memory key, return the corresponding id
+** This function assumes that the shared memory table is being
+** protected by the shared memory table semaphore.
+*/
+_get_shm_id(key_t key)
+{
+ register int i;
+
+ /* Go through the shared memory table looking for a semaphore
+ ** whose key matches what we're looking for
+ */
+ for (i = 0; i < Pg_shared_ptr->Pg_next_shm; i++)
+ if (Pg_shared_ptr->Pg_shm[i].Pg_shm_key == key)
+ return(i);
+
+ /* Return UNUSED if we didn't find a match */
+ return(UNUSED);
+}
+
+int
+semctl(int semid, int semnum, int cmd, void *y)
+{
+ int old_val;
+ HANDLE hndl;
+
+ switch (cmd)
+ {
+ case SETALL:
+ case SETVAL:
+ /* We can't change the value of a semaphore under
+ ** NT except by releasing it or waiting for it.
+ */
+ return(0);
+
+ case GETVAL:
+ _get_ipc_sem();
+ hndl = Pg_shared_ptr->Pg_sem[semid].Pg_sem_handle[semnum];
+ _rel_ipc_sem();
+ old_val = _get_sem_val(hndl);
+ return(old_val);
+ }
+}
+
+/* Get the current value of the semaphore whose handle is passed in hnd
+** This function does NOT assume that the shared memory table is being
+** protected by the shared memory table semaphore.
+*/
+
+int
+_get_sem_val(HANDLE hnd)
+{
+ DWORD waitresult;
+
+ /* Try to get the semaphore */
+ waitresult = WaitForSingleObject(hnd, 0L);
+
+ /* Check what the value of the semaphore was */
+ switch(waitresult)
+ {
+ /* The semaphore was signaled so we just got it.
+ ** Since we don't really want to keep it, since we just
+ ** wanted to test its value, go ahead and release it.
+ */
+ case WAIT_OBJECT_0:
+ ReleaseSemaphore(hnd, 1, NULL);
+ return(SIGNALED);
+
+ /* The semaphore was non-signaled meaning someone else had it. */
+ case WAIT_TIMEOUT:
+ return(UNSIGNALED);
+ }
+}
+
+int
+shmget(key_t key, uint32 size, int flags)
+{
+ HANDLE hnd;
+ char name[IPC_MAX_SHMEM_NAME];
+ int id;
+
+ /* Get the handle for the key, if any. */
+ _get_ipc_sem();
+ id = _get_shm_id(key);
+ _rel_ipc_sem();
+
+ /* If we're really going to create a new mapping */
+ if (flags != 0)
+ {
+ /* if the key is already being used return an error */
+ if (id != UNUSED)
+ return(-1);
+
+ /* convert the key to a character string */
+ sprintf(name, "%d", key);
+
+ hnd = CreateFileMapping((HANDLE)0xffffffff,
+ &sec_attrib, PAGE_READWRITE,
+ 0, size, name);
+
+ if (hnd == NULL)
+ return(-1);
+ else
+ {
+ int new_ipc;
+ struct Pg_shm *pg_ptr;
+
+ _get_ipc_sem();
+ new_ipc = Pg_shared_ptr->Pg_next_shm++;
+
+ pg_ptr = &(Pg_shared_ptr->Pg_shm[new_ipc]);
+ pg_ptr->Pg_shm_key = key;
+ pg_ptr->Pg_shm_handle = hnd;
+ _rel_ipc_sem();
+ return(new_ipc);
+ }
+ }
+
+ /* flags is 0 so we just want the id for the existing mapping */
+ else
+ return(id);
+}
+
+shmdt(char *shmaddr)
+{
+ UnmapViewOfFile(shmaddr);
+}
+
+int
+shmctl(IpcMemoryId shmid, int cmd, struct shmid_ds *buf)
+{
+ int x = 0;
+
+ if (cmd == IPC_RMID)
+ {
+ _get_ipc_sem();
+ CloseHandle(Pg_shared_ptr->Pg_shm[shmid].Pg_shm_handle);
+ _rel_ipc_sem();
+ return(0);
+ }
+ x = x / x;
+}
+
+/* Attach to the already created shared memory segment */
+LPVOID *
+shmat(int shmid, void *shmaddr, int shmflg)
+{
+ LPVOID *ret_addr;
+
+ _get_ipc_sem();
+ ret_addr = MapViewOfFile(Pg_shared_ptr->Pg_shm[shmid].Pg_shm_handle,
+ FILE_MAP_ALL_ACCESS, 0, 0, 0);
+ _rel_ipc_sem();
+ if (ret_addr == NULL)
+ {
+ int jon;
+
+ jon = GetLastError();
+ }
+ return(ret_addr);
+}
+
+/* This is the function that is called when the postmaster starts up.
+** It is here that the shared memory table is created. Also, create
+** the semaphore that will be used to protect the shared memory table.
+** TODO - do something with the return value.
+*/
+_nt_init()
+{
+ HANDLE hnd;
+ int size = sizeof (struct Pg_shared);
+
+ /* Create the file mapping for the shared memory to be
+ ** used to store the ipc table.
+ */
+ hnd = CreateFileMapping((HANDLE)0xffffffff,
+ &sec_attrib, PAGE_READWRITE,
+ 0, size, IPC_NAME);
+
+ if (hnd == NULL)
+ {
+ size = GetLastError();
+ return(-1);
+ }
+
+ Pg_shared_hnd = CreateSemaphore(&sec_attrib, 1, 255, IPC_SEM_NAME);
+ if (Pg_shared_hnd == NULL)
+ {
+ size = GetLastError();
+ return(-1);
+ }
+}
+
+/* This function gets called by every backend at startup time. Its
+** main duty is to put the address of the shared memory table pointed
+** to by Pg_shared_ptr. There's no need to get the IPC_SEM_NAME semaphore
+** because this function is called before we start manipulating the
+** shared memory table.
+*/
+void
+_nt_attach()
+{
+ HANDLE hnd;
+
+ /* Get a handle to the shared memory table */
+ hnd = OpenFileMapping(FILE_MAP_ALL_ACCESS,
+ FALSE, IPC_NAME);
+
+ /* Map the ipc shared memory table into the address space
+ ** of this process at an address returned by MapViewOfFile
+ */
+ Pg_shared_ptr = (struct Pg_shared *) MapViewOfFile(hnd,
+ FILE_MAP_ALL_ACCESS, 0, 0, 0);
+
+ if (Pg_shared_ptr == NULL)
+ {
+ hnd = GetLastError();
+ return(-1);
+ }
+}
+
+_get_ipc_sem()
+{
+ WaitForSingleObject(Pg_shared_hnd, 5000);
+}
+
+_rel_ipc_sem()
+{
+ ReleaseSemaphore(Pg_shared_hnd, 1, NULL);
+}
+
+pg_dlerror(void)
+{
+ int x = 0;
+ x = x / x;
+}
+
+pg_dlclose(void *handle)
+{
+ FreeLibrary(handle);
+}
+
+void *
+pg_dlopen(char *filename)
+{
+ HINSTANCE hinstlib;
+
+ hinstlib = LoadLibrary(filename);
+ return (hinstlib);
+}
+
+void *
+pg_dlsym(void *handle, char *funcname)
+{
+ void *proc;
+
+ proc = GetProcAddress(handle, funcname);
+ return (proc);
+}
+
+void
+ftruncate(int fd, int offset)
+{
+ HANDLE hnd;
+
+ _lseek(fd, offset, SEEK_SET);
+ hnd = _get_osfhandle(fd);
+ SetEndOfFile(hnd);
+}
+
+/* The rest are just stubs that are intended to serve as place holders
+** in case we want to set breakpoints to see what's happening when
+** these routines are called. They'll eventually have to be filled
+** in but they're not necessary to get Postgres95 going.
+*/
+setuid(int i)
+{
+ int x = 1;
+ x = x / x;
+}
+
+setsid()
+{
+ int x = 1;
+ x = x / x;
+}
+
+vfork(void)
+{
+ int x = 0;
+ x = x / x;
+}
+
+ttyname(int y)
+{
+ int x = 0;
+ x = x / x;
+}
+
+step(char *string, char *expbuf)
+{
+ int x = 0;
+ x = x / x;
+}
+
+siglongjmp(int env, int value)
+{
+ int x = 0;
+ x = x / x;
+}
+
+pause(void)
+{
+ int x = 0;
+ x = x / x;
+}
+
+kill(int process, int signal)
+{
+ int x = 1;
+ x = x / x;
+}
+
+getuid(void)
+{
+ int x = 1;
+ x = x / x;
+}
+
+geteuid( void )
+{
+ int x = 1;
+ x = x / x;
+}
+
+int
+fsync(int filedes)
+{
+}
+
+fork(void)
+{
+ int x = 0;
+ x = x / x;
+}
+
+char *
+compile(char *instring,char *expbuf,char *endbuf,int eof)
+{
+ int x = 0;
+ x = x / x;
+}
+
+beginRecipe(char *s)
+{
+ int x = 0;
+ x = x / x;
+}
--- /dev/null
+typedef char * caddr_t;
+typedef unsigned long u_long;
+typedef unsigned int u_int;
+typedef unsigned short u_short;
+typedef unsigned char u_char;
+typedef unsigned int mode_t;
+
+typedef u_int uid_t;
+typedef u_int gid_t;
+typedef int key_t;
+#define IPC_PRIVATE ((key_t)0)
+
+/* Common IPC operation flag definitions. We'll use
+** the Unix values unless we find a reason not to.
+*/
+#define IPC_CREAT 0001000 /* create entry if key doesn't exist */
+#define IPC_EXCL 0002000 /* fail if key exists */
+#define IPC_NOWAIT 0004000 /* error if request must wait */
+
+
+struct sembuf
+{
+ u_short sem_num;
+ short sem_op;
+ short sem_flg;
+};
+
+#define USE_POSIX_TIME
+#define NEED_RINT
+
+#define MAXHOSTNAMELEN 12 /* where is the official definition of this? */
+#define MAXPATHLEN _MAX_PATH /* in winsock.h */
+#define POSTPORT "5432"
+
+/* NT has stricmp not strcasecmp. Which is ANSI? */
+#define strcasecmp(a,b) _stricmp(a,b)
+
+#define isascii(a) __isascii(a)
+
+#define random() rand()
+
+/* These are bogus values used so that we can compile ipc.c */
+#define SETALL 2
+#define SETVAL 3
+#define IPC_RMID 4
+#define GETNCNT 5
+#define GETVAL 6
+
+/* for float.c */
+#define NEED_CBRT
+#define NEED_ISINF
+
+#define POSTGRESDIR "d:\\pglite"
+#define PGDATADIR "d:\\pglite\\data"
--- /dev/null
+# Microsoft Visual C++ Generated NMAKE File, Format Version 2.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+!IF "$(CFG)" == ""
+CFG=Win32 Debug
+!MESSAGE No configuration specified. Defaulting to Win32 Debug.
+!ENDIF
+
+!IF "$(CFG)" != "Win32 Release" && "$(CFG)" != "Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "pglite.mak" CFG="Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+!ERROR An invalid configuration is specified.
+!ENDIF
+
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "Win32 Debug"
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "WinRel"
+# PROP BASE Intermediate_Dir "WinRel"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "g:\users\forrest\pglite"
+# PROP Intermediate_Dir "g:\users\forrest\pglite"
+OUTDIR=g:\users\forrest\pglite
+INTDIR=g:\users\forrest\pglite
+
+ALL : $(OUTDIR)/pglite.exe $(OUTDIR)/pglite.bsc
+
+$(OUTDIR) :
+ if not exist $(OUTDIR)/nul mkdir $(OUTDIR)
+
+# ADD BASE CPP /nologo /W3 /GX /YX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /FR /c
+# ADD CPP /nologo /W3 /GX /YX /Od /I "g:\pglite\src\backend\include" /I "g:\pglite\src\backend" /I "g:\pglite\src\backend\port\win32" /I "g:\pglite\src\backend\obj" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "__STDC__" /D "_POSIX_" /c
+# SUBTRACT CPP /Fr
+CPP_PROJ=/nologo /W3 /GX /YX /Od /I "g:\pglite\src\backend\include" /I\
+ "g:\pglite\src\backend" /I "g:\pglite\src\backend\port\win32" /I\
+ "g:\pglite\src\backend\obj" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "__STDC__"\
+ /Fp$(OUTDIR)/"pglite.pch" /Fo$(INTDIR)/ /D "_POSIX_" /c
+CPP_OBJS=g:\users\forrest\pglite/
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o$(OUTDIR)/"pglite.bsc"
+BSC32_SBRS= \
+
+
+$(OUTDIR)/pglite.bsc : $(OUTDIR) $(BSC32_SBRS)
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /NOLOGO /SUBSYSTEM:console /MACHINE:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /NOLOGO /SUBSYSTEM:console /MACHINE:I386
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /NOLOGO /SUBSYSTEM:console /INCREMENTAL:no\
+ /PDB:$(OUTDIR)/"pglite.pdb" /MACHINE:I386 /OUT:$(OUTDIR)/"pglite.exe"
+DEF_FILE=
+LINK32_OBJS= \
+ $(INTDIR)/scankey.obj \
+ $(INTDIR)/printtup.obj \
+ $(INTDIR)/indexvalid.obj \
+ $(INTDIR)/heaptuple.obj \
+ $(INTDIR)/tupdesc.obj \
+ $(INTDIR)/indextuple.obj \
+ $(INTDIR)/heapvalid.obj \
+ $(INTDIR)/hashinsert.obj \
+ $(INTDIR)/hashstrat.obj \
+ $(INTDIR)/hashutil.obj \
+ $(INTDIR)/hashpage.obj \
+ $(INTDIR)/hashsearch.obj \
+ $(INTDIR)/hashscan.obj \
+ $(INTDIR)/hashfunc.obj \
+ $(INTDIR)/hash.obj \
+ $(INTDIR)/hashovfl.obj \
+ $(INTDIR)/bootstrap.obj \
+ $(INTDIR)/genam.obj \
+ $(INTDIR)/creatinh.obj \
+ $(INTDIR)/nodeSeqscan.obj \
+ $(INTDIR)/nodeUnique.obj \
+ $(INTDIR)/rename.obj \
+ $(INTDIR)/transsup.obj \
+ $(INTDIR)/transam.obj \
+ $(INTDIR)/define.obj \
+ $(INTDIR)/execMain.obj \
+ $(INTDIR)/xid.obj \
+ $(INTDIR)/nodeAgg.obj \
+ $(INTDIR)/nbtpage.obj \
+ $(INTDIR)/execScan.obj \
+ $(INTDIR)/nbtree.obj \
+ $(INTDIR)/rtscan.obj \
+ $(INTDIR)/indexam.obj \
+ $(INTDIR)/execQual.obj \
+ $(INTDIR)/nodeHash.obj \
+ $(INTDIR)/nbtscan.obj \
+ $(INTDIR)/hio.obj \
+ $(INTDIR)/pg_proc.obj \
+ $(INTDIR)/stats.obj \
+ $(INTDIR)/nodeMaterial.obj \
+ $(INTDIR)/varsup.obj \
+ $(INTDIR)/copy.obj \
+ $(INTDIR)/rtproc.obj \
+ $(INTDIR)/functions.obj \
+ $(INTDIR)/nodeHashjoin.obj \
+ $(INTDIR)/catalog.obj \
+ $(INTDIR)/nbtinsert.obj \
+ $(INTDIR)/rtree.obj \
+ $(INTDIR)/version.obj \
+ $(INTDIR)/async.obj \
+ $(INTDIR)/nbtutils.obj \
+ $(INTDIR)/vacuum.obj \
+ $(INTDIR)/rtstrat.obj \
+ $(INTDIR)/execFlatten.obj \
+ $(INTDIR)/nodeTee.obj \
+ $(INTDIR)/nodeIndexscan.obj \
+ $(INTDIR)/remove.obj \
+ $(INTDIR)/indexing.obj \
+ $(INTDIR)/command.obj \
+ $(INTDIR)/nbtsearch.obj \
+ $(INTDIR)/heapam.obj \
+ $(INTDIR)/nodeSort.obj \
+ $(INTDIR)/execProcnode.obj \
+ $(INTDIR)/nodeResult.obj \
+ $(INTDIR)/index.obj \
+ $(INTDIR)/xact.obj \
+ $(INTDIR)/nodeMergejoin.obj \
+ $(INTDIR)/pg_operator.obj \
+ $(INTDIR)/execJunk.obj \
+ $(INTDIR)/pg_aggregate.obj \
+ $(INTDIR)/istrat.obj \
+ $(INTDIR)/execUtils.obj \
+ $(INTDIR)/purge.obj \
+ $(INTDIR)/heap.obj \
+ $(INTDIR)/nbtstrat.obj \
+ $(INTDIR)/execAmi.obj \
+ $(INTDIR)/execTuples.obj \
+ $(INTDIR)/pg_type.obj \
+ $(INTDIR)/view.obj \
+ $(INTDIR)/nodeAppend.obj \
+ $(INTDIR)/defind.obj \
+ $(INTDIR)/nodeNestloop.obj \
+ $(INTDIR)/nbtcompare.obj \
+ $(INTDIR)/rtget.obj \
+ $(INTDIR)/catalog_utils.obj \
+ $(INTDIR)/setrefs.obj \
+ $(INTDIR)/mergeutils.obj \
+ $(INTDIR)/oset.obj \
+ $(INTDIR)/arrayutils.obj \
+ $(INTDIR)/nodeFuncs.obj \
+ $(INTDIR)/rewriteSupport.obj \
+ $(INTDIR)/bufpage.obj \
+ $(INTDIR)/fd.obj \
+ $(INTDIR)/clauseinfo.obj \
+ $(INTDIR)/nabstime.obj \
+ $(INTDIR)/mcxt.obj \
+ $(INTDIR)/ipci.obj \
+ $(INTDIR)/qsort.obj \
+ $(INTDIR)/outfuncs.obj \
+ $(INTDIR)/tqual.obj \
+ $(INTDIR)/keys.obj \
+ $(INTDIR)/clauses.obj \
+ $(INTDIR)/print.obj \
+ $(INTDIR)/postinit.obj \
+ $(INTDIR)/oidchar16.obj \
+ $(INTDIR)/name.obj \
+ $(INTDIR)/tid.obj \
+ $(INTDIR)/"be-fsstubs.obj" \
+ $(INTDIR)/elog.obj \
+ $(INTDIR)/bufmgr.obj \
+ $(INTDIR)/portalbuf.obj \
+ $(INTDIR)/psort.obj \
+ $(INTDIR)/syscache.obj \
+ $(INTDIR)/exc.obj \
+ $(INTDIR)/selfuncs.obj \
+ $(INTDIR)/var.obj \
+ $(INTDIR)/oid.obj \
+ $(INTDIR)/"be-pqexec.obj" \
+ $(INTDIR)/ordering.obj \
+ $(INTDIR)/inv_api.obj \
+ $(INTDIR)/buf_table.obj \
+ $(INTDIR)/acl.obj \
+ $(INTDIR)/costsize.obj \
+ $(INTDIR)/catcache.obj \
+ $(INTDIR)/rewriteRemove.obj \
+ $(INTDIR)/parse_query.obj \
+ $(INTDIR)/excabort.obj \
+ $(INTDIR)/lmgr.obj \
+ $(INTDIR)/excid.obj \
+ $(INTDIR)/int.obj \
+ $(INTDIR)/auth.obj \
+ $(INTDIR)/regexp.obj \
+ $(INTDIR)/proc.obj \
+ $(INTDIR)/dbcommands.obj \
+ $(INTDIR)/dynahash.obj \
+ $(INTDIR)/shmem.obj \
+ $(INTDIR)/relnode.obj \
+ $(INTDIR)/fstack.obj \
+ $(INTDIR)/smgr.obj \
+ $(INTDIR)/magic.obj \
+ $(INTDIR)/relcache.obj \
+ $(INTDIR)/varlena.obj \
+ $(INTDIR)/allpaths.obj \
+ $(INTDIR)/portalmem.obj \
+ $(INTDIR)/bit.obj \
+ $(INTDIR)/readfuncs.obj \
+ $(INTDIR)/nodes.obj \
+ $(INTDIR)/chunk.obj \
+ $(INTDIR)/datum.obj \
+ $(INTDIR)/analyze.obj \
+ $(INTDIR)/oidint4.obj \
+ $(INTDIR)/hasht.obj \
+ $(INTDIR)/numutils.obj \
+ $(INTDIR)/pqcomm.obj \
+ $(INTDIR)/indxpath.obj \
+ $(INTDIR)/lispsort.obj \
+ $(INTDIR)/arrayfuncs.obj \
+ $(INTDIR)/copyfuncs.obj \
+ $(INTDIR)/planmain.obj \
+ $(INTDIR)/makefuncs.obj \
+ $(INTDIR)/lsyscache.obj \
+ $(INTDIR)/multi.obj \
+ $(INTDIR)/freelist.obj \
+ $(INTDIR)/aclchk.obj \
+ $(INTDIR)/initsplan.obj \
+ $(INTDIR)/prune.obj \
+ $(INTDIR)/sinvaladt.obj \
+ $(INTDIR)/orindxpath.obj \
+ $(INTDIR)/joinrels.obj \
+ $(INTDIR)/rewriteManip.obj \
+ $(INTDIR)/itemptr.obj \
+ $(INTDIR)/s_lock.obj \
+ $(INTDIR)/miscinit.obj \
+ $(INTDIR)/postgres.obj \
+ $(INTDIR)/parser.obj \
+ $(INTDIR)/tlist.obj \
+ $(INTDIR)/dt.obj \
+ $(INTDIR)/sinval.obj \
+ $(INTDIR)/pqpacket.obj \
+ $(INTDIR)/assert.obj \
+ $(INTDIR)/utility.obj \
+ $(INTDIR)/bool.obj \
+ $(INTDIR)/md.obj \
+ $(INTDIR)/pqsignal.obj \
+ $(INTDIR)/globals.obj \
+ $(INTDIR)/postmaster.obj \
+ $(INTDIR)/joinpath.obj \
+ $(INTDIR)/fastpath.obj \
+ $(INTDIR)/archive.obj \
+ $(INTDIR)/fcache.obj \
+ $(INTDIR)/mm.obj \
+ $(INTDIR)/createplan.obj \
+ $(INTDIR)/read.obj \
+ $(INTDIR)/stringinfo.obj \
+ $(INTDIR)/hashfn.obj \
+ $(INTDIR)/regproc.obj \
+ $(INTDIR)/main.obj \
+ $(INTDIR)/enbl.obj \
+ $(INTDIR)/prepunion.obj \
+ $(INTDIR)/prepqual.obj \
+ $(INTDIR)/planner.obj \
+ $(INTDIR)/clausesel.obj \
+ $(INTDIR)/portal.obj \
+ $(INTDIR)/spin.obj \
+ $(INTDIR)/lock.obj \
+ $(INTDIR)/single.obj \
+ $(INTDIR)/io.obj \
+ $(INTDIR)/"geo-ops.obj" \
+ $(INTDIR)/dest.obj \
+ $(INTDIR)/rewriteDefine.obj \
+ $(INTDIR)/keywords.obj \
+ $(INTDIR)/hashutils.obj \
+ $(INTDIR)/format.obj \
+ $(INTDIR)/scanner.obj \
+ $(INTDIR)/aset.obj \
+ $(INTDIR)/"geo-selfuncs.obj" \
+ $(INTDIR)/float.obj \
+ $(INTDIR)/pquery.obj \
+ $(INTDIR)/"be-dumpdata.obj" \
+ $(INTDIR)/filename.obj \
+ $(INTDIR)/misc.obj \
+ $(INTDIR)/pathnode.obj \
+ $(INTDIR)/inval.obj \
+ $(INTDIR)/smgrtype.obj \
+ $(INTDIR)/joininfo.obj \
+ $(INTDIR)/lselect.obj \
+ $(INTDIR)/rel.obj \
+ $(INTDIR)/internal.obj \
+ $(INTDIR)/preptlist.obj \
+ $(INTDIR)/joinutils.obj \
+ $(INTDIR)/shmqueue.obj \
+ $(INTDIR)/date.obj \
+ $(INTDIR)/locks.obj \
+ $(INTDIR)/not_in.obj \
+ $(INTDIR)/char.obj \
+ $(INTDIR)/rewriteHandler.obj \
+ $(INTDIR)/sets.obj \
+ $(INTDIR)/palloc.obj \
+ $(INTDIR)/indexnode.obj \
+ $(INTDIR)/equalfuncs.obj \
+ $(INTDIR)/oidint2.obj \
+ $(INTDIR)/list.obj \
+ $(INTDIR)/plancat.obj \
+ $(INTDIR)/fmgr.obj \
+ $(INTDIR)/fmgrtab.obj \
+ $(INTDIR)/dllist.obj \
+ $(INTDIR)/nodeGroup.obj \
+ $(INTDIR)/localbuf.obj \
+ $(INTDIR)/cluster.obj \
+ $(INTDIR)/ipc.obj \
+ $(INTDIR)/nt.obj \
+ $(INTDIR)/getopt.obj \
+ $(INTDIR)/bootscanner.obj \
+ $(INTDIR)/scan.obj \
+ $(INTDIR)/bootparse.obj \
+ $(INTDIR)/gram.obj \
+ $(INTDIR)/findbe.obj \
+ $(INTDIR)/regerror.obj \
+ $(INTDIR)/regfree.obj \
+ $(INTDIR)/regcomp.obj \
+ $(INTDIR)/regexec.obj \
+ $(INTDIR)/nbtsort.obj \
+ $(INTDIR)/buf_init.obj \
+ $(INTDIR)/dfmgr.obj
+
+$(OUTDIR)/pglite.exe : $(OUTDIR) $(DEF_FILE) $(LINK32_OBJS)
+ $(LINK32) @<<
+ $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF "$(CFG)" == "Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "WinDebug"
+# PROP BASE Intermediate_Dir "WinDebug"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "d:\local\forrest\pglite"
+# PROP Intermediate_Dir "d:\local\forrest\pglite"
+OUTDIR=d:\local\forrest\pglite
+INTDIR=d:\local\forrest\pglite
+
+ALL : $(OUTDIR)/pglite.exe $(OUTDIR)/pglite.bsc
+
+$(OUTDIR) :
+ if not exist $(OUTDIR)/nul mkdir $(OUTDIR)
+
+# ADD BASE CPP /nologo /W3 /GX /Zi /YX /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /FR /c
+# ADD CPP /nologo /G5 /W3 /GX /Zi /YX /Od /I "g:\pglite\src\backend" /I "g:\pglite\src\backend\port\win32" /I "g:\pglite\src\backend\obj" /I "g:\pglite\src\backend\include" /I "g:\pglite\src\backend\port/win32/regex" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "__STDC__" /D "_POSIX_" /D "_NTSDK" /D "NO_SECURITY" /D "NEED_RUSAGE" /FR /c
+CPP_PROJ=/nologo /G5 /W3 /GX /Zi /YX /Od /I "g:\pglite\src\backend" /I\
+ "g:\pglite\src\backend\port\win32" /I "g:\pglite\src\backend\obj" /I\
+ "g:\pglite\src\backend\include" /I "g:\pglite\src\backend\port/win32/regex" /D\
+ "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "__STDC__" /D "_POSIX_" /D "_NTSDK" /D\
+ "NO_SECURITY" /D "NEED_RUSAGE" /FR$(INTDIR)/ /Fp$(OUTDIR)/"pglite.pch"\
+ /Fo$(INTDIR)/ /Fd$(OUTDIR)/"pglite.pdb" /c
+CPP_OBJS=d:\local\forrest\pglite/
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o$(OUTDIR)/"pglite.bsc"
+BSC32_SBRS= \
+ $(INTDIR)/scankey.sbr \
+ $(INTDIR)/printtup.sbr \
+ $(INTDIR)/indexvalid.sbr \
+ $(INTDIR)/heaptuple.sbr \
+ $(INTDIR)/tupdesc.sbr \
+ $(INTDIR)/indextuple.sbr \
+ $(INTDIR)/heapvalid.sbr \
+ $(INTDIR)/hashinsert.sbr \
+ $(INTDIR)/hashstrat.sbr \
+ $(INTDIR)/hashutil.sbr \
+ $(INTDIR)/hashpage.sbr \
+ $(INTDIR)/hashsearch.sbr \
+ $(INTDIR)/hashscan.sbr \
+ $(INTDIR)/hashfunc.sbr \
+ $(INTDIR)/hash.sbr \
+ $(INTDIR)/hashovfl.sbr \
+ $(INTDIR)/bootstrap.sbr \
+ $(INTDIR)/genam.sbr \
+ $(INTDIR)/creatinh.sbr \
+ $(INTDIR)/nodeSeqscan.sbr \
+ $(INTDIR)/nodeUnique.sbr \
+ $(INTDIR)/rename.sbr \
+ $(INTDIR)/transsup.sbr \
+ $(INTDIR)/transam.sbr \
+ $(INTDIR)/define.sbr \
+ $(INTDIR)/execMain.sbr \
+ $(INTDIR)/xid.sbr \
+ $(INTDIR)/nodeAgg.sbr \
+ $(INTDIR)/nbtpage.sbr \
+ $(INTDIR)/execScan.sbr \
+ $(INTDIR)/nbtree.sbr \
+ $(INTDIR)/rtscan.sbr \
+ $(INTDIR)/indexam.sbr \
+ $(INTDIR)/execQual.sbr \
+ $(INTDIR)/nodeHash.sbr \
+ $(INTDIR)/nbtscan.sbr \
+ $(INTDIR)/hio.sbr \
+ $(INTDIR)/pg_proc.sbr \
+ $(INTDIR)/stats.sbr \
+ $(INTDIR)/nodeMaterial.sbr \
+ $(INTDIR)/varsup.sbr \
+ $(INTDIR)/copy.sbr \
+ $(INTDIR)/rtproc.sbr \
+ $(INTDIR)/functions.sbr \
+ $(INTDIR)/nodeHashjoin.sbr \
+ $(INTDIR)/catalog.sbr \
+ $(INTDIR)/nbtinsert.sbr \
+ $(INTDIR)/rtree.sbr \
+ $(INTDIR)/version.sbr \
+ $(INTDIR)/async.sbr \
+ $(INTDIR)/nbtutils.sbr \
+ $(INTDIR)/vacuum.sbr \
+ $(INTDIR)/rtstrat.sbr \
+ $(INTDIR)/execFlatten.sbr \
+ $(INTDIR)/nodeTee.sbr \
+ $(INTDIR)/nodeIndexscan.sbr \
+ $(INTDIR)/remove.sbr \
+ $(INTDIR)/indexing.sbr \
+ $(INTDIR)/command.sbr \
+ $(INTDIR)/nbtsearch.sbr \
+ $(INTDIR)/heapam.sbr \
+ $(INTDIR)/nodeSort.sbr \
+ $(INTDIR)/execProcnode.sbr \
+ $(INTDIR)/nodeResult.sbr \
+ $(INTDIR)/index.sbr \
+ $(INTDIR)/xact.sbr \
+ $(INTDIR)/nodeMergejoin.sbr \
+ $(INTDIR)/pg_operator.sbr \
+ $(INTDIR)/execJunk.sbr \
+ $(INTDIR)/pg_aggregate.sbr \
+ $(INTDIR)/istrat.sbr \
+ $(INTDIR)/execUtils.sbr \
+ $(INTDIR)/purge.sbr \
+ $(INTDIR)/heap.sbr \
+ $(INTDIR)/nbtstrat.sbr \
+ $(INTDIR)/execAmi.sbr \
+ $(INTDIR)/execTuples.sbr \
+ $(INTDIR)/pg_type.sbr \
+ $(INTDIR)/view.sbr \
+ $(INTDIR)/nodeAppend.sbr \
+ $(INTDIR)/defind.sbr \
+ $(INTDIR)/nodeNestloop.sbr \
+ $(INTDIR)/nbtcompare.sbr \
+ $(INTDIR)/rtget.sbr \
+ $(INTDIR)/catalog_utils.sbr \
+ $(INTDIR)/setrefs.sbr \
+ $(INTDIR)/mergeutils.sbr \
+ $(INTDIR)/oset.sbr \
+ $(INTDIR)/arrayutils.sbr \
+ $(INTDIR)/nodeFuncs.sbr \
+ $(INTDIR)/rewriteSupport.sbr \
+ $(INTDIR)/bufpage.sbr \
+ $(INTDIR)/fd.sbr \
+ $(INTDIR)/clauseinfo.sbr \
+ $(INTDIR)/nabstime.sbr \
+ $(INTDIR)/mcxt.sbr \
+ $(INTDIR)/ipci.sbr \
+ $(INTDIR)/qsort.sbr \
+ $(INTDIR)/outfuncs.sbr \
+ $(INTDIR)/tqual.sbr \
+ $(INTDIR)/keys.sbr \
+ $(INTDIR)/clauses.sbr \
+ $(INTDIR)/print.sbr \
+ $(INTDIR)/postinit.sbr \
+ $(INTDIR)/oidchar16.sbr \
+ $(INTDIR)/name.sbr \
+ $(INTDIR)/tid.sbr \
+ $(INTDIR)/"be-fsstubs.sbr" \
+ $(INTDIR)/elog.sbr \
+ $(INTDIR)/bufmgr.sbr \
+ $(INTDIR)/portalbuf.sbr \
+ $(INTDIR)/psort.sbr \
+ $(INTDIR)/syscache.sbr \
+ $(INTDIR)/exc.sbr \
+ $(INTDIR)/selfuncs.sbr \
+ $(INTDIR)/var.sbr \
+ $(INTDIR)/oid.sbr \
+ $(INTDIR)/"be-pqexec.sbr" \
+ $(INTDIR)/ordering.sbr \
+ $(INTDIR)/inv_api.sbr \
+ $(INTDIR)/buf_table.sbr \
+ $(INTDIR)/acl.sbr \
+ $(INTDIR)/costsize.sbr \
+ $(INTDIR)/catcache.sbr \
+ $(INTDIR)/rewriteRemove.sbr \
+ $(INTDIR)/parse_query.sbr \
+ $(INTDIR)/excabort.sbr \
+ $(INTDIR)/lmgr.sbr \
+ $(INTDIR)/excid.sbr \
+ $(INTDIR)/int.sbr \
+ $(INTDIR)/auth.sbr \
+ $(INTDIR)/regexp.sbr \
+ $(INTDIR)/proc.sbr \
+ $(INTDIR)/dbcommands.sbr \
+ $(INTDIR)/dynahash.sbr \
+ $(INTDIR)/shmem.sbr \
+ $(INTDIR)/relnode.sbr \
+ $(INTDIR)/fstack.sbr \
+ $(INTDIR)/smgr.sbr \
+ $(INTDIR)/magic.sbr \
+ $(INTDIR)/relcache.sbr \
+ $(INTDIR)/varlena.sbr \
+ $(INTDIR)/allpaths.sbr \
+ $(INTDIR)/portalmem.sbr \
+ $(INTDIR)/bit.sbr \
+ $(INTDIR)/readfuncs.sbr \
+ $(INTDIR)/nodes.sbr \
+ $(INTDIR)/chunk.sbr \
+ $(INTDIR)/datum.sbr \
+ $(INTDIR)/analyze.sbr \
+ $(INTDIR)/oidint4.sbr \
+ $(INTDIR)/hasht.sbr \
+ $(INTDIR)/numutils.sbr \
+ $(INTDIR)/pqcomm.sbr \
+ $(INTDIR)/indxpath.sbr \
+ $(INTDIR)/lispsort.sbr \
+ $(INTDIR)/arrayfuncs.sbr \
+ $(INTDIR)/copyfuncs.sbr \
+ $(INTDIR)/planmain.sbr \
+ $(INTDIR)/makefuncs.sbr \
+ $(INTDIR)/lsyscache.sbr \
+ $(INTDIR)/multi.sbr \
+ $(INTDIR)/freelist.sbr \
+ $(INTDIR)/aclchk.sbr \
+ $(INTDIR)/initsplan.sbr \
+ $(INTDIR)/prune.sbr \
+ $(INTDIR)/sinvaladt.sbr \
+ $(INTDIR)/orindxpath.sbr \
+ $(INTDIR)/joinrels.sbr \
+ $(INTDIR)/rewriteManip.sbr \
+ $(INTDIR)/itemptr.sbr \
+ $(INTDIR)/s_lock.sbr \
+ $(INTDIR)/miscinit.sbr \
+ $(INTDIR)/postgres.sbr \
+ $(INTDIR)/parser.sbr \
+ $(INTDIR)/tlist.sbr \
+ $(INTDIR)/dt.sbr \
+ $(INTDIR)/sinval.sbr \
+ $(INTDIR)/pqpacket.sbr \
+ $(INTDIR)/assert.sbr \
+ $(INTDIR)/utility.sbr \
+ $(INTDIR)/bool.sbr \
+ $(INTDIR)/md.sbr \
+ $(INTDIR)/pqsignal.sbr \
+ $(INTDIR)/globals.sbr \
+ $(INTDIR)/postmaster.sbr \
+ $(INTDIR)/joinpath.sbr \
+ $(INTDIR)/fastpath.sbr \
+ $(INTDIR)/archive.sbr \
+ $(INTDIR)/fcache.sbr \
+ $(INTDIR)/mm.sbr \
+ $(INTDIR)/createplan.sbr \
+ $(INTDIR)/read.sbr \
+ $(INTDIR)/stringinfo.sbr \
+ $(INTDIR)/hashfn.sbr \
+ $(INTDIR)/regproc.sbr \
+ $(INTDIR)/main.sbr \
+ $(INTDIR)/enbl.sbr \
+ $(INTDIR)/prepunion.sbr \
+ $(INTDIR)/prepqual.sbr \
+ $(INTDIR)/planner.sbr \
+ $(INTDIR)/clausesel.sbr \
+ $(INTDIR)/portal.sbr \
+ $(INTDIR)/spin.sbr \
+ $(INTDIR)/lock.sbr \
+ $(INTDIR)/single.sbr \
+ $(INTDIR)/io.sbr \
+ $(INTDIR)/"geo-ops.sbr" \
+ $(INTDIR)/dest.sbr \
+ $(INTDIR)/rewriteDefine.sbr \
+ $(INTDIR)/keywords.sbr \
+ $(INTDIR)/hashutils.sbr \
+ $(INTDIR)/format.sbr \
+ $(INTDIR)/scanner.sbr \
+ $(INTDIR)/aset.sbr \
+ $(INTDIR)/"geo-selfuncs.sbr" \
+ $(INTDIR)/float.sbr \
+ $(INTDIR)/pquery.sbr \
+ $(INTDIR)/"be-dumpdata.sbr" \
+ $(INTDIR)/filename.sbr \
+ $(INTDIR)/misc.sbr \
+ $(INTDIR)/pathnode.sbr \
+ $(INTDIR)/inval.sbr \
+ $(INTDIR)/smgrtype.sbr \
+ $(INTDIR)/joininfo.sbr \
+ $(INTDIR)/lselect.sbr \
+ $(INTDIR)/rel.sbr \
+ $(INTDIR)/internal.sbr \
+ $(INTDIR)/preptlist.sbr \
+ $(INTDIR)/joinutils.sbr \
+ $(INTDIR)/shmqueue.sbr \
+ $(INTDIR)/date.sbr \
+ $(INTDIR)/locks.sbr \
+ $(INTDIR)/not_in.sbr \
+ $(INTDIR)/char.sbr \
+ $(INTDIR)/rewriteHandler.sbr \
+ $(INTDIR)/sets.sbr \
+ $(INTDIR)/palloc.sbr \
+ $(INTDIR)/indexnode.sbr \
+ $(INTDIR)/equalfuncs.sbr \
+ $(INTDIR)/oidint2.sbr \
+ $(INTDIR)/list.sbr \
+ $(INTDIR)/plancat.sbr \
+ $(INTDIR)/fmgr.sbr \
+ $(INTDIR)/fmgrtab.sbr \
+ $(INTDIR)/dllist.sbr \
+ $(INTDIR)/nodeGroup.sbr \
+ $(INTDIR)/localbuf.sbr \
+ $(INTDIR)/cluster.sbr \
+ $(INTDIR)/ipc.sbr \
+ $(INTDIR)/nt.sbr \
+ $(INTDIR)/getopt.sbr \
+ $(INTDIR)/bootscanner.sbr \
+ $(INTDIR)/scan.sbr \
+ $(INTDIR)/bootparse.sbr \
+ $(INTDIR)/gram.sbr \
+ $(INTDIR)/findbe.sbr \
+ $(INTDIR)/regerror.sbr \
+ $(INTDIR)/regfree.sbr \
+ $(INTDIR)/regcomp.sbr \
+ $(INTDIR)/regexec.sbr \
+ $(INTDIR)/nbtsort.sbr \
+ $(INTDIR)/buf_init.sbr \
+ $(INTDIR)/dfmgr.sbr
+
+$(OUTDIR)/pglite.bsc : $(OUTDIR) $(BSC32_SBRS)
+ $(BSC32) @<<
+ $(BSC32_FLAGS) $(BSC32_SBRS)
+<<
+
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /NOLOGO /SUBSYSTEM:console /DEBUG /MACHINE:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib /NOLOGO /SUBSYSTEM:console /DEBUG /MACHINE:I386
+# SUBTRACT LINK32 /PDB:none
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib wsock32.lib /NOLOGO /SUBSYSTEM:console /INCREMENTAL:yes\
+ /PDB:$(OUTDIR)/"pglite.pdb" /DEBUG /MACHINE:I386 /OUT:$(OUTDIR)/"pglite.exe"
+DEF_FILE=
+LINK32_OBJS= \
+ $(INTDIR)/scankey.obj \
+ $(INTDIR)/printtup.obj \
+ $(INTDIR)/indexvalid.obj \
+ $(INTDIR)/heaptuple.obj \
+ $(INTDIR)/tupdesc.obj \
+ $(INTDIR)/indextuple.obj \
+ $(INTDIR)/heapvalid.obj \
+ $(INTDIR)/hashinsert.obj \
+ $(INTDIR)/hashstrat.obj \
+ $(INTDIR)/hashutil.obj \
+ $(INTDIR)/hashpage.obj \
+ $(INTDIR)/hashsearch.obj \
+ $(INTDIR)/hashscan.obj \
+ $(INTDIR)/hashfunc.obj \
+ $(INTDIR)/hash.obj \
+ $(INTDIR)/hashovfl.obj \
+ $(INTDIR)/bootstrap.obj \
+ $(INTDIR)/genam.obj \
+ $(INTDIR)/creatinh.obj \
+ $(INTDIR)/nodeSeqscan.obj \
+ $(INTDIR)/nodeUnique.obj \
+ $(INTDIR)/rename.obj \
+ $(INTDIR)/transsup.obj \
+ $(INTDIR)/transam.obj \
+ $(INTDIR)/define.obj \
+ $(INTDIR)/execMain.obj \
+ $(INTDIR)/xid.obj \
+ $(INTDIR)/nodeAgg.obj \
+ $(INTDIR)/nbtpage.obj \
+ $(INTDIR)/execScan.obj \
+ $(INTDIR)/nbtree.obj \
+ $(INTDIR)/rtscan.obj \
+ $(INTDIR)/indexam.obj \
+ $(INTDIR)/execQual.obj \
+ $(INTDIR)/nodeHash.obj \
+ $(INTDIR)/nbtscan.obj \
+ $(INTDIR)/hio.obj \
+ $(INTDIR)/pg_proc.obj \
+ $(INTDIR)/stats.obj \
+ $(INTDIR)/nodeMaterial.obj \
+ $(INTDIR)/varsup.obj \
+ $(INTDIR)/copy.obj \
+ $(INTDIR)/rtproc.obj \
+ $(INTDIR)/functions.obj \
+ $(INTDIR)/nodeHashjoin.obj \
+ $(INTDIR)/catalog.obj \
+ $(INTDIR)/nbtinsert.obj \
+ $(INTDIR)/rtree.obj \
+ $(INTDIR)/version.obj \
+ $(INTDIR)/async.obj \
+ $(INTDIR)/nbtutils.obj \
+ $(INTDIR)/vacuum.obj \
+ $(INTDIR)/rtstrat.obj \
+ $(INTDIR)/execFlatten.obj \
+ $(INTDIR)/nodeTee.obj \
+ $(INTDIR)/nodeIndexscan.obj \
+ $(INTDIR)/remove.obj \
+ $(INTDIR)/indexing.obj \
+ $(INTDIR)/command.obj \
+ $(INTDIR)/nbtsearch.obj \
+ $(INTDIR)/heapam.obj \
+ $(INTDIR)/nodeSort.obj \
+ $(INTDIR)/execProcnode.obj \
+ $(INTDIR)/nodeResult.obj \
+ $(INTDIR)/index.obj \
+ $(INTDIR)/xact.obj \
+ $(INTDIR)/nodeMergejoin.obj \
+ $(INTDIR)/pg_operator.obj \
+ $(INTDIR)/execJunk.obj \
+ $(INTDIR)/pg_aggregate.obj \
+ $(INTDIR)/istrat.obj \
+ $(INTDIR)/execUtils.obj \
+ $(INTDIR)/purge.obj \
+ $(INTDIR)/heap.obj \
+ $(INTDIR)/nbtstrat.obj \
+ $(INTDIR)/execAmi.obj \
+ $(INTDIR)/execTuples.obj \
+ $(INTDIR)/pg_type.obj \
+ $(INTDIR)/view.obj \
+ $(INTDIR)/nodeAppend.obj \
+ $(INTDIR)/defind.obj \
+ $(INTDIR)/nodeNestloop.obj \
+ $(INTDIR)/nbtcompare.obj \
+ $(INTDIR)/rtget.obj \
+ $(INTDIR)/catalog_utils.obj \
+ $(INTDIR)/setrefs.obj \
+ $(INTDIR)/mergeutils.obj \
+ $(INTDIR)/oset.obj \
+ $(INTDIR)/arrayutils.obj \
+ $(INTDIR)/nodeFuncs.obj \
+ $(INTDIR)/rewriteSupport.obj \
+ $(INTDIR)/bufpage.obj \
+ $(INTDIR)/fd.obj \
+ $(INTDIR)/clauseinfo.obj \
+ $(INTDIR)/nabstime.obj \
+ $(INTDIR)/mcxt.obj \
+ $(INTDIR)/ipci.obj \
+ $(INTDIR)/qsort.obj \
+ $(INTDIR)/outfuncs.obj \
+ $(INTDIR)/tqual.obj \
+ $(INTDIR)/keys.obj \
+ $(INTDIR)/clauses.obj \
+ $(INTDIR)/print.obj \
+ $(INTDIR)/postinit.obj \
+ $(INTDIR)/oidchar16.obj \
+ $(INTDIR)/name.obj \
+ $(INTDIR)/tid.obj \
+ $(INTDIR)/"be-fsstubs.obj" \
+ $(INTDIR)/elog.obj \
+ $(INTDIR)/bufmgr.obj \
+ $(INTDIR)/portalbuf.obj \
+ $(INTDIR)/psort.obj \
+ $(INTDIR)/syscache.obj \
+ $(INTDIR)/exc.obj \
+ $(INTDIR)/selfuncs.obj \
+ $(INTDIR)/var.obj \
+ $(INTDIR)/oid.obj \
+ $(INTDIR)/"be-pqexec.obj" \
+ $(INTDIR)/ordering.obj \
+ $(INTDIR)/inv_api.obj \
+ $(INTDIR)/buf_table.obj \
+ $(INTDIR)/acl.obj \
+ $(INTDIR)/costsize.obj \
+ $(INTDIR)/catcache.obj \
+ $(INTDIR)/rewriteRemove.obj \
+ $(INTDIR)/parse_query.obj \
+ $(INTDIR)/excabort.obj \
+ $(INTDIR)/lmgr.obj \
+ $(INTDIR)/excid.obj \
+ $(INTDIR)/int.obj \
+ $(INTDIR)/auth.obj \
+ $(INTDIR)/regexp.obj \
+ $(INTDIR)/proc.obj \
+ $(INTDIR)/dbcommands.obj \
+ $(INTDIR)/dynahash.obj \
+ $(INTDIR)/shmem.obj \
+ $(INTDIR)/relnode.obj \
+ $(INTDIR)/fstack.obj \
+ $(INTDIR)/smgr.obj \
+ $(INTDIR)/magic.obj \
+ $(INTDIR)/relcache.obj \
+ $(INTDIR)/varlena.obj \
+ $(INTDIR)/allpaths.obj \
+ $(INTDIR)/portalmem.obj \
+ $(INTDIR)/bit.obj \
+ $(INTDIR)/readfuncs.obj \
+ $(INTDIR)/nodes.obj \
+ $(INTDIR)/chunk.obj \
+ $(INTDIR)/datum.obj \
+ $(INTDIR)/analyze.obj \
+ $(INTDIR)/oidint4.obj \
+ $(INTDIR)/hasht.obj \
+ $(INTDIR)/numutils.obj \
+ $(INTDIR)/pqcomm.obj \
+ $(INTDIR)/indxpath.obj \
+ $(INTDIR)/lispsort.obj \
+ $(INTDIR)/arrayfuncs.obj \
+ $(INTDIR)/copyfuncs.obj \
+ $(INTDIR)/planmain.obj \
+ $(INTDIR)/makefuncs.obj \
+ $(INTDIR)/lsyscache.obj \
+ $(INTDIR)/multi.obj \
+ $(INTDIR)/freelist.obj \
+ $(INTDIR)/aclchk.obj \
+ $(INTDIR)/initsplan.obj \
+ $(INTDIR)/prune.obj \
+ $(INTDIR)/sinvaladt.obj \
+ $(INTDIR)/orindxpath.obj \
+ $(INTDIR)/joinrels.obj \
+ $(INTDIR)/rewriteManip.obj \
+ $(INTDIR)/itemptr.obj \
+ $(INTDIR)/s_lock.obj \
+ $(INTDIR)/miscinit.obj \
+ $(INTDIR)/postgres.obj \
+ $(INTDIR)/parser.obj \
+ $(INTDIR)/tlist.obj \
+ $(INTDIR)/dt.obj \
+ $(INTDIR)/sinval.obj \
+ $(INTDIR)/pqpacket.obj \
+ $(INTDIR)/assert.obj \
+ $(INTDIR)/utility.obj \
+ $(INTDIR)/bool.obj \
+ $(INTDIR)/md.obj \
+ $(INTDIR)/pqsignal.obj \
+ $(INTDIR)/globals.obj \
+ $(INTDIR)/postmaster.obj \
+ $(INTDIR)/joinpath.obj \
+ $(INTDIR)/fastpath.obj \
+ $(INTDIR)/archive.obj \
+ $(INTDIR)/fcache.obj \
+ $(INTDIR)/mm.obj \
+ $(INTDIR)/createplan.obj \
+ $(INTDIR)/read.obj \
+ $(INTDIR)/stringinfo.obj \
+ $(INTDIR)/hashfn.obj \
+ $(INTDIR)/regproc.obj \
+ $(INTDIR)/main.obj \
+ $(INTDIR)/enbl.obj \
+ $(INTDIR)/prepunion.obj \
+ $(INTDIR)/prepqual.obj \
+ $(INTDIR)/planner.obj \
+ $(INTDIR)/clausesel.obj \
+ $(INTDIR)/portal.obj \
+ $(INTDIR)/spin.obj \
+ $(INTDIR)/lock.obj \
+ $(INTDIR)/single.obj \
+ $(INTDIR)/io.obj \
+ $(INTDIR)/"geo-ops.obj" \
+ $(INTDIR)/dest.obj \
+ $(INTDIR)/rewriteDefine.obj \
+ $(INTDIR)/keywords.obj \
+ $(INTDIR)/hashutils.obj \
+ $(INTDIR)/format.obj \
+ $(INTDIR)/scanner.obj \
+ $(INTDIR)/aset.obj \
+ $(INTDIR)/"geo-selfuncs.obj" \
+ $(INTDIR)/float.obj \
+ $(INTDIR)/pquery.obj \
+ $(INTDIR)/"be-dumpdata.obj" \
+ $(INTDIR)/filename.obj \
+ $(INTDIR)/misc.obj \
+ $(INTDIR)/pathnode.obj \
+ $(INTDIR)/inval.obj \
+ $(INTDIR)/smgrtype.obj \
+ $(INTDIR)/joininfo.obj \
+ $(INTDIR)/lselect.obj \
+ $(INTDIR)/rel.obj \
+ $(INTDIR)/internal.obj \
+ $(INTDIR)/preptlist.obj \
+ $(INTDIR)/joinutils.obj \
+ $(INTDIR)/shmqueue.obj \
+ $(INTDIR)/date.obj \
+ $(INTDIR)/locks.obj \
+ $(INTDIR)/not_in.obj \
+ $(INTDIR)/char.obj \
+ $(INTDIR)/rewriteHandler.obj \
+ $(INTDIR)/sets.obj \
+ $(INTDIR)/palloc.obj \
+ $(INTDIR)/indexnode.obj \
+ $(INTDIR)/equalfuncs.obj \
+ $(INTDIR)/oidint2.obj \
+ $(INTDIR)/list.obj \
+ $(INTDIR)/plancat.obj \
+ $(INTDIR)/fmgr.obj \
+ $(INTDIR)/fmgrtab.obj \
+ $(INTDIR)/dllist.obj \
+ $(INTDIR)/nodeGroup.obj \
+ $(INTDIR)/localbuf.obj \
+ $(INTDIR)/cluster.obj \
+ $(INTDIR)/ipc.obj \
+ $(INTDIR)/nt.obj \
+ $(INTDIR)/getopt.obj \
+ $(INTDIR)/bootscanner.obj \
+ $(INTDIR)/scan.obj \
+ $(INTDIR)/bootparse.obj \
+ $(INTDIR)/gram.obj \
+ $(INTDIR)/findbe.obj \
+ $(INTDIR)/regerror.obj \
+ $(INTDIR)/regfree.obj \
+ $(INTDIR)/regcomp.obj \
+ $(INTDIR)/regexec.obj \
+ $(INTDIR)/nbtsort.obj \
+ $(INTDIR)/buf_init.obj \
+ $(INTDIR)/dfmgr.obj
+
+$(OUTDIR)/pglite.exe : $(OUTDIR) $(DEF_FILE) $(LINK32_OBJS)
+ $(LINK32) @<<
+ $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ENDIF
+
+.c{$(CPP_OBJS)}.obj:
+ $(CPP) $(CPP_PROJ) $<
+
+.cpp{$(CPP_OBJS)}.obj:
+ $(CPP) $(CPP_PROJ) $<
+
+.cxx{$(CPP_OBJS)}.obj:
+ $(CPP) $(CPP_PROJ) $<
+
+################################################################################
+# Begin Group "Source Files"
+
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\common\scankey.c
+
+$(INTDIR)/scankey.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\common\printtup.c
+
+$(INTDIR)/printtup.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\common\indexvalid.c
+
+$(INTDIR)/indexvalid.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\common\heaptuple.c
+
+$(INTDIR)/heaptuple.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\common\tupdesc.c
+
+$(INTDIR)/tupdesc.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\common\indextuple.c
+
+$(INTDIR)/indextuple.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\common\heapvalid.c
+
+$(INTDIR)/heapvalid.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\hash\hashinsert.c
+
+$(INTDIR)/hashinsert.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\hash\hashstrat.c
+
+$(INTDIR)/hashstrat.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\hash\hashutil.c
+
+$(INTDIR)/hashutil.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\hash\hashpage.c
+
+$(INTDIR)/hashpage.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\hash\hashsearch.c
+
+$(INTDIR)/hashsearch.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\hash\hashscan.c
+
+$(INTDIR)/hashscan.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\hash\hashfunc.c
+
+$(INTDIR)/hashfunc.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\hash\hash.c
+
+$(INTDIR)/hash.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\hash\hashovfl.c
+
+$(INTDIR)/hashovfl.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\bootstrap\bootstrap.c
+
+$(INTDIR)/bootstrap.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\index\genam.c
+
+$(INTDIR)/genam.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\commands\creatinh.c
+
+$(INTDIR)/creatinh.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\nodeSeqscan.c
+
+$(INTDIR)/nodeSeqscan.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\nodeUnique.c
+
+$(INTDIR)/nodeUnique.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\commands\rename.c
+
+$(INTDIR)/rename.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\transam\transsup.c
+
+$(INTDIR)/transsup.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\transam\transam.c
+
+$(INTDIR)/transam.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\commands\define.c
+
+$(INTDIR)/define.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\execMain.c
+
+$(INTDIR)/execMain.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\transam\xid.c
+
+$(INTDIR)/xid.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\nodeAgg.c
+
+$(INTDIR)/nodeAgg.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\nbtree\nbtpage.c
+
+$(INTDIR)/nbtpage.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\execScan.c
+
+$(INTDIR)/execScan.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\nbtree\nbtree.c
+
+$(INTDIR)/nbtree.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\rtree\rtscan.c
+
+$(INTDIR)/rtscan.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\index\indexam.c
+
+$(INTDIR)/indexam.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\execQual.c
+
+$(INTDIR)/execQual.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\nodeHash.c
+
+$(INTDIR)/nodeHash.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\nbtree\nbtscan.c
+
+$(INTDIR)/nbtscan.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\heap\hio.c
+
+$(INTDIR)/hio.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\catalog\pg_proc.c
+
+$(INTDIR)/pg_proc.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\heap\stats.c
+
+$(INTDIR)/stats.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\nodeMaterial.c
+
+$(INTDIR)/nodeMaterial.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\transam\varsup.c
+
+$(INTDIR)/varsup.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\commands\copy.c
+
+$(INTDIR)/copy.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\rtree\rtproc.c
+
+$(INTDIR)/rtproc.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\functions.c
+
+$(INTDIR)/functions.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\nodeHashjoin.c
+
+$(INTDIR)/nodeHashjoin.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\catalog\catalog.c
+
+$(INTDIR)/catalog.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\nbtree\nbtinsert.c
+
+$(INTDIR)/nbtinsert.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\rtree\rtree.c
+
+$(INTDIR)/rtree.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\commands\version.c
+
+$(INTDIR)/version.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\commands\async.c
+
+$(INTDIR)/async.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\nbtree\nbtutils.c
+
+$(INTDIR)/nbtutils.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\commands\vacuum.c
+
+$(INTDIR)/vacuum.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\rtree\rtstrat.c
+
+$(INTDIR)/rtstrat.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\execFlatten.c
+
+$(INTDIR)/execFlatten.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\nodeTee.c
+
+$(INTDIR)/nodeTee.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\nodeIndexscan.c
+
+$(INTDIR)/nodeIndexscan.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\commands\remove.c
+
+$(INTDIR)/remove.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\catalog\indexing.c
+
+$(INTDIR)/indexing.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\commands\command.c
+
+$(INTDIR)/command.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\nbtree\nbtsearch.c
+
+$(INTDIR)/nbtsearch.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\heap\heapam.c
+
+$(INTDIR)/heapam.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\nodeSort.c
+
+$(INTDIR)/nodeSort.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\execProcnode.c
+
+$(INTDIR)/execProcnode.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\nodeResult.c
+
+$(INTDIR)/nodeResult.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\catalog\index.c
+
+$(INTDIR)/index.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\transam\xact.c
+
+$(INTDIR)/xact.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\nodeMergejoin.c
+
+$(INTDIR)/nodeMergejoin.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\catalog\pg_operator.c
+
+$(INTDIR)/pg_operator.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\execJunk.c
+
+$(INTDIR)/execJunk.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\catalog\pg_aggregate.c
+
+$(INTDIR)/pg_aggregate.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\index\istrat.c
+
+$(INTDIR)/istrat.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\execUtils.c
+
+$(INTDIR)/execUtils.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\commands\purge.c
+
+$(INTDIR)/purge.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\catalog\heap.c
+
+$(INTDIR)/heap.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\nbtree\nbtstrat.c
+
+$(INTDIR)/nbtstrat.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\execAmi.c
+
+$(INTDIR)/execAmi.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\execTuples.c
+
+$(INTDIR)/execTuples.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\catalog\pg_type.c
+
+$(INTDIR)/pg_type.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\commands\view.c
+
+$(INTDIR)/view.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\nodeAppend.c
+
+$(INTDIR)/nodeAppend.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\commands\defind.c
+
+$(INTDIR)/defind.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\nodeNestloop.c
+
+$(INTDIR)/nodeNestloop.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\nbtree\nbtcompare.c
+
+$(INTDIR)/nbtcompare.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\rtree\rtget.c
+
+$(INTDIR)/rtget.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\parser\catalog_utils.c
+
+$(INTDIR)/catalog_utils.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\plan\setrefs.c
+
+$(INTDIR)/setrefs.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\path\mergeutils.c
+
+$(INTDIR)/mergeutils.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\mmgr\oset.c
+
+$(INTDIR)/oset.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\arrayutils.c
+
+$(INTDIR)/arrayutils.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\nodes\nodeFuncs.c
+
+$(INTDIR)/nodeFuncs.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\rewrite\rewriteSupport.c
+
+$(INTDIR)/rewriteSupport.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\page\bufpage.c
+
+$(INTDIR)/bufpage.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\file\fd.c
+
+$(INTDIR)/fd.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\util\clauseinfo.c
+
+$(INTDIR)/clauseinfo.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\nabstime.c
+
+$(INTDIR)/nabstime.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\mmgr\mcxt.c
+
+$(INTDIR)/mcxt.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\ipc\ipci.c
+
+$(INTDIR)/ipci.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\lib\qsort.c
+
+$(INTDIR)/qsort.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\nodes\outfuncs.c
+
+$(INTDIR)/outfuncs.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\time\tqual.c
+
+$(INTDIR)/tqual.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\util\keys.c
+
+$(INTDIR)/keys.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\util\clauses.c
+
+$(INTDIR)/clauses.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\nodes\print.c
+
+$(INTDIR)/print.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\init\postinit.c
+
+$(INTDIR)/postinit.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\oidchar16.c
+
+$(INTDIR)/oidchar16.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\name.c
+
+$(INTDIR)/name.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\tid.c
+
+$(INTDIR)/tid.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE="G:\pglite\src\backend\libpq\be-fsstubs.c"
+
+$(INTDIR)/"be-fsstubs.obj" : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\error\elog.c
+
+$(INTDIR)/elog.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\buffer\bufmgr.c
+
+$(INTDIR)/bufmgr.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\libpq\portalbuf.c
+
+$(INTDIR)/portalbuf.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\sort\psort.c
+
+$(INTDIR)/psort.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\cache\syscache.c
+
+$(INTDIR)/syscache.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\error\exc.c
+
+$(INTDIR)/exc.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\selfuncs.c
+
+$(INTDIR)/selfuncs.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\util\var.c
+
+$(INTDIR)/var.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\oid.c
+
+$(INTDIR)/oid.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE="G:\pglite\src\backend\libpq\be-pqexec.c"
+
+$(INTDIR)/"be-pqexec.obj" : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\util\ordering.c
+
+$(INTDIR)/ordering.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\large_object\inv_api.c
+
+$(INTDIR)/inv_api.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\buffer\buf_table.c
+
+$(INTDIR)/buf_table.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\acl.c
+
+$(INTDIR)/acl.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\path\costsize.c
+
+$(INTDIR)/costsize.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\cache\catcache.c
+
+$(INTDIR)/catcache.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\rewrite\rewriteRemove.c
+
+$(INTDIR)/rewriteRemove.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\parser\parse_query.c
+
+$(INTDIR)/parse_query.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\error\excabort.c
+
+$(INTDIR)/excabort.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\lmgr\lmgr.c
+
+$(INTDIR)/lmgr.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\error\excid.c
+
+$(INTDIR)/excid.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\int.c
+
+$(INTDIR)/int.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\libpq\auth.c
+
+$(INTDIR)/auth.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\regexp.c
+
+$(INTDIR)/regexp.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\lmgr\proc.c
+
+$(INTDIR)/proc.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\parser\dbcommands.c
+
+$(INTDIR)/dbcommands.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\hash\dynahash.c
+
+$(INTDIR)/dynahash.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\ipc\shmem.c
+
+$(INTDIR)/shmem.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\util\relnode.c
+
+$(INTDIR)/relnode.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\lib\fstack.c
+
+$(INTDIR)/fstack.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\smgr\smgr.c
+
+$(INTDIR)/smgr.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\init\magic.c
+
+$(INTDIR)/magic.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\cache\relcache.c
+
+$(INTDIR)/relcache.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\varlena.c
+
+$(INTDIR)/varlena.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\path\allpaths.c
+
+$(INTDIR)/allpaths.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\mmgr\portalmem.c
+
+$(INTDIR)/portalmem.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\lib\bit.c
+
+$(INTDIR)/bit.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\nodes\readfuncs.c
+
+$(INTDIR)/readfuncs.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\nodes\nodes.c
+
+$(INTDIR)/nodes.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\chunk.c
+
+$(INTDIR)/chunk.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\datum.c
+
+$(INTDIR)/datum.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\parser\analyze.c
+
+$(INTDIR)/analyze.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\oidint4.c
+
+$(INTDIR)/oidint4.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\lib\hasht.c
+
+$(INTDIR)/hasht.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\numutils.c
+
+$(INTDIR)/numutils.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\libpq\pqcomm.c
+
+$(INTDIR)/pqcomm.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\path\indxpath.c
+
+$(INTDIR)/indxpath.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\lib\lispsort.c
+
+$(INTDIR)/lispsort.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\arrayfuncs.c
+
+$(INTDIR)/arrayfuncs.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\nodes\copyfuncs.c
+
+$(INTDIR)/copyfuncs.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\plan\planmain.c
+
+$(INTDIR)/planmain.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\nodes\makefuncs.c
+
+$(INTDIR)/makefuncs.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\cache\lsyscache.c
+
+$(INTDIR)/lsyscache.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\lmgr\multi.c
+
+$(INTDIR)/multi.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\buffer\freelist.c
+
+$(INTDIR)/freelist.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\tcop\aclchk.c
+
+$(INTDIR)/aclchk.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\plan\initsplan.c
+
+$(INTDIR)/initsplan.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\path\prune.c
+
+$(INTDIR)/prune.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\ipc\sinvaladt.c
+
+$(INTDIR)/sinvaladt.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\path\orindxpath.c
+
+$(INTDIR)/orindxpath.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\path\joinrels.c
+
+$(INTDIR)/joinrels.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\rewrite\rewriteManip.c
+
+$(INTDIR)/rewriteManip.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\page\itemptr.c
+
+$(INTDIR)/itemptr.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\ipc\s_lock.c
+
+$(INTDIR)/s_lock.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\init\miscinit.c
+
+$(INTDIR)/miscinit.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\tcop\postgres.c
+
+$(INTDIR)/postgres.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\parser\parser.c
+
+$(INTDIR)/parser.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\util\tlist.c
+
+$(INTDIR)/tlist.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\dt.c
+
+$(INTDIR)/dt.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\ipc\sinval.c
+
+$(INTDIR)/sinval.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\libpq\pqpacket.c
+
+$(INTDIR)/pqpacket.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\error\assert.c
+
+$(INTDIR)/assert.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\tcop\utility.c
+
+$(INTDIR)/utility.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\bool.c
+
+$(INTDIR)/bool.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\smgr\md.c
+
+$(INTDIR)/md.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\libpq\pqsignal.c
+
+$(INTDIR)/pqsignal.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\init\globals.c
+
+$(INTDIR)/globals.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\postmaster\postmaster.c
+
+$(INTDIR)/postmaster.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\path\joinpath.c
+
+$(INTDIR)/joinpath.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\tcop\fastpath.c
+
+$(INTDIR)/fastpath.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\prep\archive.c
+
+$(INTDIR)/archive.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\cache\fcache.c
+
+$(INTDIR)/fcache.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\smgr\mm.c
+
+$(INTDIR)/mm.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\plan\createplan.c
+
+$(INTDIR)/createplan.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\nodes\read.c
+
+$(INTDIR)/read.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\lib\stringinfo.c
+
+$(INTDIR)/stringinfo.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\hash\hashfn.c
+
+$(INTDIR)/hashfn.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\regproc.c
+
+$(INTDIR)/regproc.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\main\main.c
+
+$(INTDIR)/main.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\init\enbl.c
+
+$(INTDIR)/enbl.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\prep\prepunion.c
+
+$(INTDIR)/prepunion.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\prep\prepqual.c
+
+$(INTDIR)/prepqual.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\plan\planner.c
+
+$(INTDIR)/planner.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\path\clausesel.c
+
+$(INTDIR)/clausesel.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\libpq\portal.c
+
+$(INTDIR)/portal.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\ipc\spin.c
+
+$(INTDIR)/spin.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\lmgr\lock.c
+
+$(INTDIR)/lock.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\lmgr\single.c
+
+$(INTDIR)/single.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\parser\io.c
+
+$(INTDIR)/io.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE="G:\pglite\src\backend\utils\adt\geo-ops.c"
+
+$(INTDIR)/"geo-ops.obj" : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\tcop\dest.c
+
+$(INTDIR)/dest.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\rewrite\rewriteDefine.c
+
+$(INTDIR)/rewriteDefine.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\parser\keywords.c
+
+$(INTDIR)/keywords.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\path\hashutils.c
+
+$(INTDIR)/hashutils.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\error\format.c
+
+$(INTDIR)/format.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\parser\scanner.c
+
+$(INTDIR)/scanner.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\mmgr\aset.c
+
+$(INTDIR)/aset.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE="G:\pglite\src\backend\utils\adt\geo-selfuncs.c"
+
+$(INTDIR)/"geo-selfuncs.obj" : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\float.c
+
+$(INTDIR)/float.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\tcop\pquery.c
+
+$(INTDIR)/pquery.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE="G:\pglite\src\backend\libpq\be-dumpdata.c"
+
+$(INTDIR)/"be-dumpdata.obj" : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\filename.c
+
+$(INTDIR)/filename.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\misc.c
+
+$(INTDIR)/misc.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\util\pathnode.c
+
+$(INTDIR)/pathnode.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\cache\inval.c
+
+$(INTDIR)/inval.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\smgr\smgrtype.c
+
+$(INTDIR)/smgrtype.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\util\joininfo.c
+
+$(INTDIR)/joininfo.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\sort\lselect.c
+
+$(INTDIR)/lselect.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\cache\rel.c
+
+$(INTDIR)/rel.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\util\internal.c
+
+$(INTDIR)/internal.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\prep\preptlist.c
+
+$(INTDIR)/preptlist.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\path\joinutils.c
+
+$(INTDIR)/joinutils.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\ipc\shmqueue.c
+
+$(INTDIR)/shmqueue.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\date.c
+
+$(INTDIR)/date.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\rewrite\locks.c
+
+$(INTDIR)/locks.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\not_in.c
+
+$(INTDIR)/not_in.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\char.c
+
+$(INTDIR)/char.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\rewrite\rewriteHandler.c
+
+$(INTDIR)/rewriteHandler.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\sets.c
+
+$(INTDIR)/sets.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\mmgr\palloc.c
+
+$(INTDIR)/palloc.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\util\indexnode.c
+
+$(INTDIR)/indexnode.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\nodes\equalfuncs.c
+
+$(INTDIR)/equalfuncs.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\adt\oidint2.c
+
+$(INTDIR)/oidint2.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\nodes\list.c
+
+$(INTDIR)/list.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\optimizer\util\plancat.c
+
+$(INTDIR)/plancat.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\fmgr\fmgr.c
+
+$(INTDIR)/fmgr.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\obj\fmgrtab.c
+
+$(INTDIR)/fmgrtab.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\lib\dllist.c
+
+$(INTDIR)/dllist.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\executor\nodeGroup.c
+
+$(INTDIR)/nodeGroup.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\buffer\localbuf.c
+
+$(INTDIR)/localbuf.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\commands\cluster.c
+
+$(INTDIR)/cluster.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\ipc\ipc.c
+
+$(INTDIR)/ipc.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\port\win32\nt.c
+
+$(INTDIR)/nt.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\port\win32\getopt.c
+
+$(INTDIR)/getopt.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\obj\bootscanner.c
+
+$(INTDIR)/bootscanner.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\obj\scan.c
+
+$(INTDIR)/scan.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\obj\bootparse.c
+
+$(INTDIR)/bootparse.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\obj\gram.c
+
+$(INTDIR)/gram.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\init\findbe.c
+
+$(INTDIR)/findbe.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\port\win32\regex\regerror.c
+
+$(INTDIR)/regerror.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\port\win32\regex\regfree.c
+
+$(INTDIR)/regfree.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\port\win32\regex\regcomp.c
+
+$(INTDIR)/regcomp.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\port\win32\regex\regexec.c
+
+$(INTDIR)/regexec.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\access\nbtree\nbtsort.c
+
+$(INTDIR)/nbtsort.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\storage\buffer\buf_init.c
+
+$(INTDIR)/buf_init.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=G:\pglite\src\backend\utils\fmgr\dfmgr.c
+
+$(INTDIR)/dfmgr.obj : $(SOURCE) $(INTDIR)
+ $(CPP) $(CPP_PROJ) $(SOURCE)
+
+# End Source File
+# End Group
+# End Project
+################################################################################
--- /dev/null
+Copyright 1992, 1993, 1994 Henry Spencer. All rights reserved.
+This software is not subject to any license of the American Telephone
+and Telegraph Company or of the Regents of the University of California.
+
+Permission is granted to anyone to use this software for any purpose on
+any computer system, and to alter it and redistribute it, subject
+to the following restrictions:
+
+1. The author is not responsible for the consequences of use of this
+ software, no matter how awful, even if they arise from flaws in it.
+
+2. The origin of this software must not be misrepresented, either by
+ explicit claim or by omission. Since few users ever read sources,
+ credits must appear in the documentation.
+
+3. Altered versions must be plainly marked as such, and must not be
+ misrepresented as being the original software. Since few users
+ ever read sources, credits must appear in the documentation.
+
+4. This notice may not be removed or altered.
+
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+/*-
+ * Copyright (c) 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)COPYRIGHT 8.1 (Berkeley) 3/16/94
+ */
--- /dev/null
+# @(#)Makefile.inc 8.1 (Berkeley) 6/4/93
+
+# regex sources
+.PATH: ${.CURDIR}/regex
+
+CFLAGS+=-DPOSIX_MISTAKE
+
+SRCS+= regcomp.c regerror.c regexec.c regfree.c
+
+MAN3+= regex.0
+MAN7+= re_format.0
+
+MLINKS+=regex.3 regcomp.3 regex.3 regexec.3 regex.3 regerror.3
+MLINKS+=regexec.3 regfree.3
--- /dev/null
+# @(#)WHATSNEW 8.3 (Berkeley) 3/18/94
+
+New in alpha3.4: The complex bug alluded to below has been fixed (in a
+slightly kludgey temporary way that may hurt efficiency a bit; this is
+another "get it out the door for 4.4" release). The tests at the end of
+the tests file have accordingly been uncommented. The primary sign of
+the bug was that something like a?b matching ab matched b rather than ab.
+(The bug was essentially specific to this exact situation, else it would
+have shown up earlier.)
+
+New in alpha3.3: The definition of word boundaries has been altered
+slightly, to more closely match the usual programming notion that "_"
+is an alphabetic. Stuff used for pre-ANSI systems is now in a subdir,
+and the makefile no longer alludes to it in mysterious ways. The
+makefile has generally been cleaned up some. Fixes have been made
+(again!) so that the regression test will run without -DREDEBUG, at
+the cost of weaker checking. A workaround for a bug in some folks'
+
has been added. And some more things have been added to+tests, including a couple right at the end which are commented out
+because the code currently flunks them (complex bug; fix coming).
+Plus the usual minor cleanup.
+
+New in alpha3.2: Assorted bits of cleanup and portability improvement
+(the development base is now a BSDI system using GCC instead of an ancient
+Sun system, and the newer compiler exposed some glitches). Fix for a
+serious bug that affected REs using many [] (including REG_ICASE REs
+because of the way they are implemented), *sometimes*, depending on
+memory-allocation patterns. The header-file prototypes no longer name
+the parameters, avoiding possible name conflicts. The possibility that
+some clot has defined CHAR_MIN as (say) `-128' instead of `(-128)' is
+now handled gracefully. "uchar" is no longer used as an internal type
+name (too many people have the same idea). Still the same old lousy
+performance, alas.
+
+New in alpha3.1: Basically nothing, this release is just a bookkeeping
+convenience. Stay tuned.
+
+New in alpha3.0: Performance is no better, alas, but some fixes have been
+made and some functionality has been added. (This is basically the "get
+it out the door in time for 4.4" release.) One bug fix: regfree() didn't
+free the main internal structure (how embarrassing). It is now possible
+to put NULs in either the RE or the target string, using (resp.) a new
+REG_PEND flag and the old REG_STARTEND flag. The REG_NOSPEC flag to
+regcomp() makes all characters ordinary, so you can match a literal
+string easily (this will become more useful when performance improves!).
+There are now primitives to match beginnings and ends of words, although
+the syntax is disgusting and so is the implementation. The REG_ATOI
+debugging interface has changed a bit. And there has been considerable
+internal cleanup of various kinds.
+
+New in alpha2.3: Split change list out of README, and moved flags notes
+into Makefile. Macro-ized the name of regex(7) in regex(3), since it has
+to change for 4.4BSD. Cleanup work in engine.c, and some new regression
+tests to catch tricky cases thereof.
+
+New in alpha2.2: Out-of-date manpages updated. Regerror() acquires two
+small extensions -- REG_ITOA and REG_ATOI -- which avoid debugging kludges
+in my own test program and might be useful to others for similar purposes.
+The regression test will now compile (and run) without REDEBUG. The
+BRE \$ bug is fixed. Most uses of "uchar" are gone; it's all chars now.
+Char/uchar parameters are now written int/unsigned, to avoid possible
+portability problems with unpromoted parameters. Some unsigned casts have
+been introduced to minimize portability problems with shifting into sign
+bits.
+
+New in alpha2.1: Lots of little stuff, cleanup and fixes. The one big
+thing is that regex.h is now generated, using mkh, rather than being
+supplied in the distribution; due to circularities in dependencies,
+you have to build regex.h explicitly by "make h". The two known bugs
+have been fixed (and the regression test now checks for them), as has a
+problem with assertions not being suppressed in the absence of REDEBUG.
+No performance work yet.
+
+New in alpha2: Backslash-anything is an ordinary character, not an
+error (except, of course, for the handful of backslashed metacharacters
+in BREs), which should reduce script breakage. The regression test
+checks *where* null strings are supposed to match, and has generally
+been tightened up somewhat. Small bug fixes in parameter passing (not
+harmful, but technically errors) and some other areas. Debugging
+invoked by defining REDEBUG rather than not defining NDEBUG.
+
+New in alpha+3: full prototyping for internal routines, using a little
+helper program, mkh, which extracts prototypes given in stylized comments.
+More minor cleanup. Buglet fix: it's CHAR_BIT, not CHAR_BITS. Simple
+pre-screening of input when a literal string is known to be part of the
+RE; this does wonders for performance.
+
+New in alpha+2: minor bits of cleanup. Notably, the number "32" for the
+word width isn't hardwired into regexec.c any more, the public header
+file prototypes the functions if __STDC__ is defined, and some small typos
+in the manpages have been fixed.
+
+New in alpha+1: improvements to the manual pages, and an important
+extension, the REG_STARTEND option to regexec().
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)cclass.h 8.3 (Berkeley) 3/20/94
+ */
+
+/* character-class table */
+static struct cclass {
+ char *name;
+ char *chars;
+ char *multis;
+} cclasses[] = {
+ "alnum", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
+0123456789", "",
+ "alpha", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+ "",
+ "blank", " \t", "",
+ "cntrl", "\007\b\t\n\v\f\r\1\2\3\4\5\6\16\17\20\21\22\23\24\
+\25\26\27\30\31\32\33\34\35\36\37\177", "",
+ "digit", "0123456789", "",
+ "graph", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
+0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
+ "",
+ "lower", "abcdefghijklmnopqrstuvwxyz",
+ "",
+ "print", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
+0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ",
+ "",
+ "punct", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
+ "",
+ "space", "\t\n\v\f\r ", "",
+ "upper", "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+ "",
+ "xdigit", "0123456789ABCDEFabcdef",
+ "",
+ NULL, 0, ""
+};
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)cname.h 8.3 (Berkeley) 3/20/94
+ */
+
+/* character-name table */
+static struct cname {
+ char *name;
+ char code;
+} cnames[] = {
+ "NUL", '\0',
+ "SOH", '\001',
+ "STX", '\002',
+ "ETX", '\003',
+ "EOT", '\004',
+ "ENQ", '\005',
+ "ACK", '\006',
+ "BEL", '\007',
+ "alert", '\007',
+ "BS", '\010',
+ "backspace", '\b',
+ "HT", '\011',
+ "tab", '\t',
+ "LF", '\012',
+ "newline", '\n',
+ "VT", '\013',
+ "vertical-tab", '\v',
+ "FF", '\014',
+ "form-feed", '\f',
+ "CR", '\015',
+ "carriage-return", '\r',
+ "SO", '\016',
+ "SI", '\017',
+ "DLE", '\020',
+ "DC1", '\021',
+ "DC2", '\022',
+ "DC3", '\023',
+ "DC4", '\024',
+ "NAK", '\025',
+ "SYN", '\026',
+ "ETB", '\027',
+ "CAN", '\030',
+ "EM", '\031',
+ "SUB", '\032',
+ "ESC", '\033',
+ "IS4", '\034',
+ "FS", '\034',
+ "IS3", '\035',
+ "GS", '\035',
+ "IS2", '\036',
+ "RS", '\036',
+ "IS1", '\037',
+ "US", '\037',
+ "space", ' ',
+ "exclamation-mark", '!',
+ "quotation-mark", '"',
+ "number-sign", '#',
+ "dollar-sign", '$',
+ "percent-sign", '%',
+ "ampersand", '&',
+ "apostrophe", '\'',
+ "left-parenthesis", '(',
+ "right-parenthesis", ')',
+ "asterisk", '*',
+ "plus-sign", '+',
+ "comma", ',',
+ "hyphen", '-',
+ "hyphen-minus", '-',
+ "period", '.',
+ "full-stop", '.',
+ "slash", '/',
+ "solidus", '/',
+ "zero", '0',
+ "one", '1',
+ "two", '2',
+ "three", '3',
+ "four", '4',
+ "five", '5',
+ "six", '6',
+ "seven", '7',
+ "eight", '8',
+ "nine", '9',
+ "colon", ':',
+ "semicolon", ';',
+ "less-than-sign", '<',
+ "equals-sign", '=',
+ "greater-than-sign", '>',
+ "question-mark", '?',
+ "commercial-at", '@',
+ "left-square-bracket", '[',
+ "backslash", '\\',
+ "reverse-solidus", '\\',
+ "right-square-bracket", ']',
+ "circumflex", '^',
+ "circumflex-accent", '^',
+ "underscore", '_',
+ "low-line", '_',
+ "grave-accent", '`',
+ "left-brace", '{',
+ "left-curly-bracket", '{',
+ "vertical-line", '|',
+ "right-brace", '}',
+ "right-curly-bracket", '}',
+ "tilde", '~',
+ "DEL", '\177',
+ NULL, 0,
+};
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)engine.c 8.5 (Berkeley) 3/20/94
+ */
+
+/*
+ * The matching engine and friends. This file is #included by regexec.c
+ * after suitable #defines of a variety of macros used herein, so that
+ * different state representations can be used without duplicating masses
+ * of code.
+ */
+
+#ifdef SNAMES
+#define matcher smatcher
+#define fast sfast
+#define slow sslow
+#define dissect sdissect
+#define backref sbackref
+#define step sstep
+#define print sprint
+#define at sat
+#define match smat
+#endif
+#ifdef LNAMES
+#define matcher lmatcher
+#define fast lfast
+#define slow lslow
+#define dissect ldissect
+#define backref lbackref
+#define step lstep
+#define print lprint
+#define at lat
+#define match lmat
+#endif
+
+/* another structure passed up and down to avoid zillions of parameters */
+struct match {
+ struct re_guts *g;
+ int eflags;
+ regmatch_t *pmatch; /* [nsub+1] (0 element unused) */
+ char *offp; /* offsets work from here */
+ char *beginp; /* start of string -- virtual NUL precedes */
+ char *endp; /* end of string -- virtual NUL here */
+ char *coldp; /* can be no match starting before here */
+ char **lastpos; /* [nplus+1] */
+ STATEVARS;
+ states st; /* current states */
+ states fresh; /* states for a fresh start */
+ states tmp; /* temporary */
+ states empty; /* empty set of states */
+};
+
+/* ========= begin header generated by ./mkh ========= */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* === engine.c === */
+static int matcher __P((struct re_guts *g, char *string, size_t nmatch, regmatch_t pmatch[], int eflags));
+static char *dissect __P((struct match *m, char *start, char *stop, sopno startst, sopno stopst));
+static char *backref __P((struct match *m, char *start, char *stop, sopno startst, sopno stopst, sopno lev));
+static char *fast __P((struct match *m, char *start, char *stop, sopno startst, sopno stopst));
+static char *slow __P((struct match *m, char *start, char *stop, sopno startst, sopno stopst));
+static states step __P((struct re_guts *g, sopno start, sopno stop, states bef, int ch, states aft));
+#define BOL (OUT+1)
+#define EOL (BOL+1)
+#define BOLEOL (BOL+2)
+#define NOTHING (BOL+3)
+#define BOW (BOL+4)
+#define EOW (BOL+5)
+#define CODEMAX (BOL+5) /* highest code used */
+#define NONCHAR(c) ((c) > CHAR_MAX)
+#define NNONCHAR (CODEMAX-CHAR_MAX)
+#ifdef REDEBUG
+static void print __P((struct match *m, char *caption, states st, int ch, FILE *d));
+#endif
+#ifdef REDEBUG
+static void at __P((struct match *m, char *title, char *start, char *stop, sopno startst, sopno stopst));
+#endif
+#ifdef REDEBUG
+static char *pchar __P((int ch));
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+/* ========= end header generated by ./mkh ========= */
+
+#ifdef REDEBUG
+#define SP(t, s, c) print(m, t, s, c, stdout)
+#define AT(t, p1, p2, s1, s2) at(m, t, p1, p2, s1, s2)
+#define NOTE(str) { if (m->eflags®_TRACE) printf("=%s\n", (str)); }
+#else
+#define SP(t, s, c) /* nothing */
+#define AT(t, p1, p2, s1, s2) /* nothing */
+#define NOTE(s) /* nothing */
+#endif
+
+/*
+ - matcher - the actual matching engine
+ == static int matcher(register struct re_guts *g, char *string, \
+ == size_t nmatch, regmatch_t pmatch[], int eflags);
+ */
+static int /* 0 success, REG_NOMATCH failure */
+matcher(g, string, nmatch, pmatch, eflags)
+register struct re_guts *g;
+char *string;
+size_t nmatch;
+regmatch_t pmatch[];
+int eflags;
+{
+ register char *endp;
+ register int i;
+ struct match mv;
+ register struct match *m = &mv;
+ register char *dp;
+ const register sopno gf = g->firststate+1; /* +1 for OEND */
+ const register sopno gl = g->laststate;
+ char *start;
+ char *stop;
+
+ /* simplify the situation where possible */
+ if (g->cflags®_NOSUB)
+ nmatch = 0;
+ if (eflags®_STARTEND) {
+ start = string + pmatch[0].rm_so;
+ stop = string + pmatch[0].rm_eo;
+ } else {
+ start = string;
+ stop = start + strlen(start);
+ }
+ if (stop < start)
+ return(REG_INVARG);
+
+ /* prescreening; this does wonders for this rather slow code */
+ if (g->must != NULL) {
+ for (dp = start; dp < stop; dp++)
+ if (*dp == g->must[0] && stop - dp >= g->mlen &&
+ memcmp(dp, g->must, (size_t)g->mlen) == 0)
+ break;
+ if (dp == stop) /* we didn't find g->must */
+ return(REG_NOMATCH);
+ }
+
+ /* match struct setup */
+ m->g = g;
+ m->eflags = eflags;
+ m->pmatch = NULL;
+ m->lastpos = NULL;
+ m->offp = string;
+ m->beginp = start;
+ m->endp = stop;
+ STATESETUP(m, 4);
+ SETUP(m->st);
+ SETUP(m->fresh);
+ SETUP(m->tmp);
+ SETUP(m->empty);
+ CLEAR(m->empty);
+
+ /* this loop does only one repetition except for backrefs */
+ for (;;) {
+ endp = fast(m, start, stop, gf, gl);
+ if (endp == NULL) { /* a miss */
+ STATETEARDOWN(m);
+ return(REG_NOMATCH);
+ }
+ if (nmatch == 0 && !g->backrefs)
+ break; /* no further info needed */
+
+ /* where? */
+ assert(m->coldp != NULL);
+ for (;;) {
+ NOTE("finding start");
+ endp = slow(m, m->coldp, stop, gf, gl);
+ if (endp != NULL)
+ break;
+ assert(m->coldp < m->endp);
+ m->coldp++;
+ }
+ if (nmatch == 1 && !g->backrefs)
+ break; /* no further info needed */
+
+ /* oh my, he wants the subexpressions... */
+ if (m->pmatch == NULL)
+ m->pmatch = (regmatch_t *)malloc((m->g->nsub + 1) *
+ sizeof(regmatch_t));
+ if (m->pmatch == NULL) {
+ STATETEARDOWN(m);
+ return(REG_ESPACE);
+ }
+ for (i = 1; i <= m->g->nsub; i++)
+ m->pmatch[i].rm_so = m->pmatch[i].rm_eo = -1;
+ if (!g->backrefs && !(m->eflags®_BACKR)) {
+ NOTE("dissecting");
+ dp = dissect(m, m->coldp, endp, gf, gl);
+ } else {
+ if (g->nplus > 0 && m->lastpos == NULL)
+ m->lastpos = (char **)malloc((g->nplus+1) *
+ sizeof(char *));
+ if (g->nplus > 0 && m->lastpos == NULL) {
+ free(m->pmatch);
+ STATETEARDOWN(m);
+ return(REG_ESPACE);
+ }
+ NOTE("backref dissect");
+ dp = backref(m, m->coldp, endp, gf, gl, (sopno)0);
+ }
+ if (dp != NULL)
+ break;
+
+ /* uh-oh... we couldn't find a subexpression-level match */
+ assert(g->backrefs); /* must be back references doing it */
+ assert(g->nplus == 0 || m->lastpos != NULL);
+ for (;;) {
+ if (dp != NULL || endp <= m->coldp)
+ break; /* defeat */
+ NOTE("backoff");
+ endp = slow(m, m->coldp, endp-1, gf, gl);
+ if (endp == NULL)
+ break; /* defeat */
+ /* try it on a shorter possibility */
+#ifndef NDEBUG
+ for (i = 1; i <= m->g->nsub; i++) {
+ assert(m->pmatch[i].rm_so == -1);
+ assert(m->pmatch[i].rm_eo == -1);
+ }
+#endif
+ NOTE("backoff dissect");
+ dp = backref(m, m->coldp, endp, gf, gl, (sopno)0);
+ }
+ assert(dp == NULL || dp == endp);
+ if (dp != NULL) /* found a shorter one */
+ break;
+
+ /* despite initial appearances, there is no match here */
+ NOTE("false alarm");
+ start = m->coldp + 1; /* recycle starting later */
+ assert(start <= stop);
+ }
+
+ /* fill in the details if requested */
+ if (nmatch > 0) {
+ pmatch[0].rm_so = m->coldp - m->offp;
+ pmatch[0].rm_eo = endp - m->offp;
+ }
+ if (nmatch > 1) {
+ assert(m->pmatch != NULL);
+ for (i = 1; i < nmatch; i++)
+ if (i <= m->g->nsub)
+ pmatch[i] = m->pmatch[i];
+ else {
+ pmatch[i].rm_so = -1;
+ pmatch[i].rm_eo = -1;
+ }
+ }
+
+ if (m->pmatch != NULL)
+ free((char *)m->pmatch);
+ if (m->lastpos != NULL)
+ free((char *)m->lastpos);
+ STATETEARDOWN(m);
+ return(0);
+}
+
+/*
+ - dissect - figure out what matched what, no back references
+ == static char *dissect(register struct match *m, char *start, \
+ == char *stop, sopno startst, sopno stopst);
+ */
+static char * /* == stop (success) always */
+dissect(m, start, stop, startst, stopst)
+register struct match *m;
+char *start;
+char *stop;
+sopno startst;
+sopno stopst;
+{
+ register int i;
+ register sopno ss; /* start sop of current subRE */
+ register sopno es; /* end sop of current subRE */
+ register char *sp; /* start of string matched by it */
+ register char *stp; /* string matched by it cannot pass here */
+ register char *rest; /* start of rest of string */
+ register char *tail; /* string unmatched by rest of RE */
+ register sopno ssub; /* start sop of subsubRE */
+ register sopno esub; /* end sop of subsubRE */
+ register char *ssp; /* start of string matched by subsubRE */
+ register char *sep; /* end of string matched by subsubRE */
+ register char *oldssp; /* previous ssp */
+ register char *dp;
+
+ AT("diss", start, stop, startst, stopst);
+ sp = start;
+ for (ss = startst; ss < stopst; ss = es) {
+ /* identify end of subRE */
+ es = ss;
+ switch (OP(m->g->strip[es])) {
+ case OPLUS_:
+ case OQUEST_:
+ es += OPND(m->g->strip[es]);
+ break;
+ case OCH_:
+ while (OP(m->g->strip[es]) != O_CH)
+ es += OPND(m->g->strip[es]);
+ break;
+ }
+ es++;
+
+ /* figure out what it matched */
+ switch (OP(m->g->strip[ss])) {
+ case OEND:
+ assert(nope);
+ break;
+ case OCHAR:
+ sp++;
+ break;
+ case OBOL:
+ case OEOL:
+ case OBOW:
+ case OEOW:
+ break;
+ case OANY:
+ case OANYOF:
+ sp++;
+ break;
+ case OBACK_:
+ case O_BACK:
+ assert(nope);
+ break;
+ /* cases where length of match is hard to find */
+ case OQUEST_:
+ stp = stop;
+ for (;;) {
+ /* how long could this one be? */
+ rest = slow(m, sp, stp, ss, es);
+ assert(rest != NULL); /* it did match */
+ /* could the rest match the rest? */
+ tail = slow(m, rest, stop, es, stopst);
+ if (tail == stop)
+ break; /* yes! */
+ /* no -- try a shorter match for this one */
+ stp = rest - 1;
+ assert(stp >= sp); /* it did work */
+ }
+ ssub = ss + 1;
+ esub = es - 1;
+ /* did innards match? */
+ if (slow(m, sp, rest, ssub, esub) != NULL) {
+ dp = dissect(m, sp, rest, ssub, esub);
+ assert(dp == rest);
+ } else /* no */
+ assert(sp == rest);
+ sp = rest;
+ break;
+ case OPLUS_:
+ stp = stop;
+ for (;;) {
+ /* how long could this one be? */
+ rest = slow(m, sp, stp, ss, es);
+ assert(rest != NULL); /* it did match */
+ /* could the rest match the rest? */
+ tail = slow(m, rest, stop, es, stopst);
+ if (tail == stop)
+ break; /* yes! */
+ /* no -- try a shorter match for this one */
+ stp = rest - 1;
+ assert(stp >= sp); /* it did work */
+ }
+ ssub = ss + 1;
+ esub = es - 1;
+ ssp = sp;
+ oldssp = ssp;
+ for (;;) { /* find last match of innards */
+ sep = slow(m, ssp, rest, ssub, esub);
+ if (sep == NULL || sep == ssp)
+ break; /* failed or matched null */
+ oldssp = ssp; /* on to next try */
+ ssp = sep;
+ }
+ if (sep == NULL) {
+ /* last successful match */
+ sep = ssp;
+ ssp = oldssp;
+ }
+ assert(sep == rest); /* must exhaust substring */
+ assert(slow(m, ssp, sep, ssub, esub) == rest);
+ dp = dissect(m, ssp, sep, ssub, esub);
+ assert(dp == sep);
+ sp = rest;
+ break;
+ case OCH_:
+ stp = stop;
+ for (;;) {
+ /* how long could this one be? */
+ rest = slow(m, sp, stp, ss, es);
+ assert(rest != NULL); /* it did match */
+ /* could the rest match the rest? */
+ tail = slow(m, rest, stop, es, stopst);
+ if (tail == stop)
+ break; /* yes! */
+ /* no -- try a shorter match for this one */
+ stp = rest - 1;
+ assert(stp >= sp); /* it did work */
+ }
+ ssub = ss + 1;
+ esub = ss + OPND(m->g->strip[ss]) - 1;
+ assert(OP(m->g->strip[esub]) == OOR1);
+ for (;;) { /* find first matching branch */
+ if (slow(m, sp, rest, ssub, esub) == rest)
+ break; /* it matched all of it */
+ /* that one missed, try next one */
+ assert(OP(m->g->strip[esub]) == OOR1);
+ esub++;
+ assert(OP(m->g->strip[esub]) == OOR2);
+ ssub = esub + 1;
+ esub += OPND(m->g->strip[esub]);
+ if (OP(m->g->strip[esub]) == OOR2)
+ esub--;
+ else
+ assert(OP(m->g->strip[esub]) == O_CH);
+ }
+ dp = dissect(m, sp, rest, ssub, esub);
+ assert(dp == rest);
+ sp = rest;
+ break;
+ case O_PLUS:
+ case O_QUEST:
+ case OOR1:
+ case OOR2:
+ case O_CH:
+ assert(nope);
+ break;
+ case OLPAREN:
+ i = OPND(m->g->strip[ss]);
+ assert(0 < i && i <= m->g->nsub);
+ m->pmatch[i].rm_so = sp - m->offp;
+ break;
+ case ORPAREN:
+ i = OPND(m->g->strip[ss]);
+ assert(0 < i && i <= m->g->nsub);
+ m->pmatch[i].rm_eo = sp - m->offp;
+ break;
+ default: /* uh oh */
+ assert(nope);
+ break;
+ }
+ }
+
+ assert(sp == stop);
+ return(sp);
+}
+
+/*
+ - backref - figure out what matched what, figuring in back references
+ == static char *backref(register struct match *m, char *start, \
+ == char *stop, sopno startst, sopno stopst, sopno lev);
+ */
+static char * /* == stop (success) or NULL (failure) */
+backref(m, start, stop, startst, stopst, lev)
+register struct match *m;
+char *start;
+char *stop;
+sopno startst;
+sopno stopst;
+sopno lev; /* PLUS nesting level */
+{
+ register int i;
+ register sopno ss; /* start sop of current subRE */
+ register char *sp; /* start of string matched by it */
+ register sopno ssub; /* start sop of subsubRE */
+ register sopno esub; /* end sop of subsubRE */
+ register char *ssp; /* start of string matched by subsubRE */
+ register char *dp;
+ register size_t len;
+ register int hard;
+ register sop s;
+ register regoff_t offsave;
+ register cset *cs;
+
+ AT("back", start, stop, startst, stopst);
+ sp = start;
+
+ /* get as far as we can with easy stuff */
+ hard = 0;
+ for (ss = startst; !hard && ss < stopst; ss++)
+ switch (OP(s = m->g->strip[ss])) {
+ case OCHAR:
+ if (sp == stop || *sp++ != (char)OPND(s))
+ return(NULL);
+ break;
+ case OANY:
+ if (sp == stop)
+ return(NULL);
+ sp++;
+ break;
+ case OANYOF:
+ cs = &m->g->sets[OPND(s)];
+ if (sp == stop || !CHIN(cs, *sp++))
+ return(NULL);
+ break;
+ case OBOL:
+ if ( (sp == m->beginp && !(m->eflags®_NOTBOL)) ||
+ (sp < m->endp && *(sp-1) == '\n' &&
+ (m->g->cflags®_NEWLINE)) )
+ { /* yes */ }
+ else
+ return(NULL);
+ break;
+ case OEOL:
+ if ( (sp == m->endp && !(m->eflags®_NOTEOL)) ||
+ (sp < m->endp && *sp == '\n' &&
+ (m->g->cflags®_NEWLINE)) )
+ { /* yes */ }
+ else
+ return(NULL);
+ break;
+ case OBOW:
+ if (( (sp == m->beginp && !(m->eflags®_NOTBOL)) ||
+ (sp < m->endp && *(sp-1) == '\n' &&
+ (m->g->cflags®_NEWLINE)) ||
+ (sp > m->beginp &&
+ !ISWORD(*(sp-1))) ) &&
+ (sp < m->endp && ISWORD(*sp)) )
+ { /* yes */ }
+ else
+ return(NULL);
+ break;
+ case OEOW:
+ if (( (sp == m->endp && !(m->eflags®_NOTEOL)) ||
+ (sp < m->endp && *sp == '\n' &&
+ (m->g->cflags®_NEWLINE)) ||
+ (sp < m->endp && !ISWORD(*sp)) ) &&
+ (sp > m->beginp && ISWORD(*(sp-1))) )
+ { /* yes */ }
+ else
+ return(NULL);
+ break;
+ case O_QUEST:
+ break;
+ case OOR1: /* matches null but needs to skip */
+ ss++;
+ s = m->g->strip[ss];
+ do {
+ assert(OP(s) == OOR2);
+ ss += OPND(s);
+ } while (OP(s = m->g->strip[ss]) != O_CH);
+ /* note that the ss++ gets us past the O_CH */
+ break;
+ default: /* have to make a choice */
+ hard = 1;
+ break;
+ }
+ if (!hard) { /* that was it! */
+ if (sp != stop)
+ return(NULL);
+ return(sp);
+ }
+ ss--; /* adjust for the for's final increment */
+
+ /* the hard stuff */
+ AT("hard", sp, stop, ss, stopst);
+ s = m->g->strip[ss];
+ switch (OP(s)) {
+ case OBACK_: /* the vilest depths */
+ i = OPND(s);
+ assert(0 < i && i <= m->g->nsub);
+ if (m->pmatch[i].rm_eo == -1)
+ return(NULL);
+ assert(m->pmatch[i].rm_so != -1);
+ len = m->pmatch[i].rm_eo - m->pmatch[i].rm_so;
+ assert(stop - m->beginp >= len);
+ if (sp > stop - len)
+ return(NULL); /* not enough left to match */
+ ssp = m->offp + m->pmatch[i].rm_so;
+ if (memcmp(sp, ssp, len) != 0)
+ return(NULL);
+ while (m->g->strip[ss] != SOP(O_BACK, i))
+ ss++;
+ return(backref(m, sp+len, stop, ss+1, stopst, lev));
+ break;
+ case OQUEST_: /* to null or not */
+ dp = backref(m, sp, stop, ss+1, stopst, lev);
+ if (dp != NULL)
+ return(dp); /* not */
+ return(backref(m, sp, stop, ss+OPND(s)+1, stopst, lev));
+ break;
+ case OPLUS_:
+ assert(m->lastpos != NULL);
+ assert(lev+1 <= m->g->nplus);
+ m->lastpos[lev+1] = sp;
+ return(backref(m, sp, stop, ss+1, stopst, lev+1));
+ break;
+ case O_PLUS:
+ if (sp == m->lastpos[lev]) /* last pass matched null */
+ return(backref(m, sp, stop, ss+1, stopst, lev-1));
+ /* try another pass */
+ m->lastpos[lev] = sp;
+ dp = backref(m, sp, stop, ss-OPND(s)+1, stopst, lev);
+ if (dp == NULL)
+ return(backref(m, sp, stop, ss+1, stopst, lev-1));
+ else
+ return(dp);
+ break;
+ case OCH_: /* find the right one, if any */
+ ssub = ss + 1;
+ esub = ss + OPND(s) - 1;
+ assert(OP(m->g->strip[esub]) == OOR1);
+ for (;;) { /* find first matching branch */
+ dp = backref(m, sp, stop, ssub, esub, lev);
+ if (dp != NULL)
+ return(dp);
+ /* that one missed, try next one */
+ if (OP(m->g->strip[esub]) == O_CH)
+ return(NULL); /* there is none */
+ esub++;
+ assert(OP(m->g->strip[esub]) == OOR2);
+ ssub = esub + 1;
+ esub += OPND(m->g->strip[esub]);
+ if (OP(m->g->strip[esub]) == OOR2)
+ esub--;
+ else
+ assert(OP(m->g->strip[esub]) == O_CH);
+ }
+ break;
+ case OLPAREN: /* must undo assignment if rest fails */
+ i = OPND(s);
+ assert(0 < i && i <= m->g->nsub);
+ offsave = m->pmatch[i].rm_so;
+ m->pmatch[i].rm_so = sp - m->offp;
+ dp = backref(m, sp, stop, ss+1, stopst, lev);
+ if (dp != NULL)
+ return(dp);
+ m->pmatch[i].rm_so = offsave;
+ return(NULL);
+ break;
+ case ORPAREN: /* must undo assignment if rest fails */
+ i = OPND(s);
+ assert(0 < i && i <= m->g->nsub);
+ offsave = m->pmatch[i].rm_eo;
+ m->pmatch[i].rm_eo = sp - m->offp;
+ dp = backref(m, sp, stop, ss+1, stopst, lev);
+ if (dp != NULL)
+ return(dp);
+ m->pmatch[i].rm_eo = offsave;
+ return(NULL);
+ break;
+ default: /* uh oh */
+ assert(nope);
+ break;
+ }
+
+ /* "can't happen" */
+ assert(nope);
+ /* NOTREACHED */
+}
+
+/*
+ - fast - step through the string at top speed
+ == static char *fast(register struct match *m, char *start, \
+ == char *stop, sopno startst, sopno stopst);
+ */
+static char * /* where tentative match ended, or NULL */
+fast(m, start, stop, startst, stopst)
+register struct match *m;
+char *start;
+char *stop;
+sopno startst;
+sopno stopst;
+{
+ register states st = m->st;
+ register states fresh = m->fresh;
+ register states tmp = m->tmp;
+ register char *p = start;
+ register int c = (start == m->beginp) ? OUT : *(start-1);
+ register int lastc; /* previous c */
+ register int flagch;
+ register int i;
+ register char *coldp; /* last p after which no match was underway */
+
+ CLEAR(st);
+ SET1(st, startst);
+ st = step(m->g, startst, stopst, st, NOTHING, st);
+ ASSIGN(fresh, st);
+ SP("start", st, *p);
+ coldp = NULL;
+ for (;;) {
+ /* next character */
+ lastc = c;
+ c = (p == m->endp) ? OUT : *p;
+ if (EQ(st, fresh))
+ coldp = p;
+
+ /* is there an EOL and/or BOL between lastc and c? */
+ flagch = '\0';
+ i = 0;
+ if ( (lastc == '\n' && m->g->cflags®_NEWLINE) ||
+ (lastc == OUT && !(m->eflags®_NOTBOL)) ) {
+ flagch = BOL;
+ i = m->g->nbol;
+ }
+ if ( (c == '\n' && m->g->cflags®_NEWLINE) ||
+ (c == OUT && !(m->eflags®_NOTEOL)) ) {
+ flagch = (flagch == BOL) ? BOLEOL : EOL;
+ i += m->g->neol;
+ }
+ if (i != 0) {
+ for (; i > 0; i--)
+ st = step(m->g, startst, stopst, st, flagch, st);
+ SP("boleol", st, c);
+ }
+
+ /* how about a word boundary? */
+ if ( (flagch == BOL || (lastc != OUT && !ISWORD(lastc))) &&
+ (c != OUT && ISWORD(c)) ) {
+ flagch = BOW;
+ }
+ if ( (lastc != OUT && ISWORD(lastc)) &&
+ (flagch == EOL || (c != OUT && !ISWORD(c))) ) {
+ flagch = EOW;
+ }
+ if (flagch == BOW || flagch == EOW) {
+ st = step(m->g, startst, stopst, st, flagch, st);
+ SP("boweow", st, c);
+ }
+
+ /* are we done? */
+ if (ISSET(st, stopst) || p == stop)
+ break; /* NOTE BREAK OUT */
+
+ /* no, we must deal with this character */
+ ASSIGN(tmp, st);
+ ASSIGN(st, fresh);
+ assert(c != OUT);
+ st = step(m->g, startst, stopst, tmp, c, st);
+ SP("aft", st, c);
+ assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st));
+ p++;
+ }
+
+ assert(coldp != NULL);
+ m->coldp = coldp;
+ if (ISSET(st, stopst))
+ return(p+1);
+ else
+ return(NULL);
+}
+
+/*
+ - slow - step through the string more deliberately
+ == static char *slow(register struct match *m, char *start, \
+ == char *stop, sopno startst, sopno stopst);
+ */
+static char * /* where it ended */
+slow(m, start, stop, startst, stopst)
+register struct match *m;
+char *start;
+char *stop;
+sopno startst;
+sopno stopst;
+{
+ register states st = m->st;
+ register states empty = m->empty;
+ register states tmp = m->tmp;
+ register char *p = start;
+ register int c = (start == m->beginp) ? OUT : *(start-1);
+ register int lastc; /* previous c */
+ register int flagch;
+ register int i;
+ register char *matchp; /* last p at which a match ended */
+
+ AT("slow", start, stop, startst, stopst);
+ CLEAR(st);
+ SET1(st, startst);
+ SP("sstart", st, *p);
+ st = step(m->g, startst, stopst, st, NOTHING, st);
+ matchp = NULL;
+ for (;;) {
+ /* next character */
+ lastc = c;
+ c = (p == m->endp) ? OUT : *p;
+
+ /* is there an EOL and/or BOL between lastc and c? */
+ flagch = '\0';
+ i = 0;
+ if ( (lastc == '\n' && m->g->cflags®_NEWLINE) ||
+ (lastc == OUT && !(m->eflags®_NOTBOL)) ) {
+ flagch = BOL;
+ i = m->g->nbol;
+ }
+ if ( (c == '\n' && m->g->cflags®_NEWLINE) ||
+ (c == OUT && !(m->eflags®_NOTEOL)) ) {
+ flagch = (flagch == BOL) ? BOLEOL : EOL;
+ i += m->g->neol;
+ }
+ if (i != 0) {
+ for (; i > 0; i--)
+ st = step(m->g, startst, stopst, st, flagch, st);
+ SP("sboleol", st, c);
+ }
+
+ /* how about a word boundary? */
+ if ( (flagch == BOL || (lastc != OUT && !ISWORD(lastc))) &&
+ (c != OUT && ISWORD(c)) ) {
+ flagch = BOW;
+ }
+ if ( (lastc != OUT && ISWORD(lastc)) &&
+ (flagch == EOL || (c != OUT && !ISWORD(c))) ) {
+ flagch = EOW;
+ }
+ if (flagch == BOW || flagch == EOW) {
+ st = step(m->g, startst, stopst, st, flagch, st);
+ SP("sboweow", st, c);
+ }
+
+ /* are we done? */
+ if (ISSET(st, stopst))
+ matchp = p;
+ if (EQ(st, empty) || p == stop)
+ break; /* NOTE BREAK OUT */
+
+ /* no, we must deal with this character */
+ ASSIGN(tmp, st);
+ ASSIGN(st, empty);
+ assert(c != OUT);
+ st = step(m->g, startst, stopst, tmp, c, st);
+ SP("saft", st, c);
+ assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st));
+ p++;
+ }
+
+ return(matchp);
+}
+
+
+/*
+ - step - map set of states reachable before char to set reachable after
+ == static states step(register struct re_guts *g, sopno start, sopno stop, \
+ == register states bef, int ch, register states aft);
+ == #define BOL (OUT+1)
+ == #define EOL (BOL+1)
+ == #define BOLEOL (BOL+2)
+ == #define NOTHING (BOL+3)
+ == #define BOW (BOL+4)
+ == #define EOW (BOL+5)
+ == #define CODEMAX (BOL+5) // highest code used
+ == #define NONCHAR(c) ((c) > CHAR_MAX)
+ == #define NNONCHAR (CODEMAX-CHAR_MAX)
+ */
+static states
+step(g, start, stop, bef, ch, aft)
+register struct re_guts *g;
+sopno start; /* start state within strip */
+sopno stop; /* state after stop state within strip */
+register states bef; /* states reachable before */
+int ch; /* character or NONCHAR code */
+register states aft; /* states already known reachable after */
+{
+ register cset *cs;
+ register sop s;
+ register sopno pc;
+ register onestate here; /* note, macros know this name */
+ register sopno look;
+ register int i;
+
+ for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here)) {
+ s = g->strip[pc];
+ switch (OP(s)) {
+ case OEND:
+ assert(pc == stop-1);
+ break;
+ case OCHAR:
+ /* only characters can match */
+ assert(!NONCHAR(ch) || ch != (char)OPND(s));
+ if (ch == (char)OPND(s))
+ FWD(aft, bef, 1);
+ break;
+ case OBOL:
+ if (ch == BOL || ch == BOLEOL)
+ FWD(aft, bef, 1);
+ break;
+ case OEOL:
+ if (ch == EOL || ch == BOLEOL)
+ FWD(aft, bef, 1);
+ break;
+ case OBOW:
+ if (ch == BOW)
+ FWD(aft, bef, 1);
+ break;
+ case OEOW:
+ if (ch == EOW)
+ FWD(aft, bef, 1);
+ break;
+ case OANY:
+ if (!NONCHAR(ch))
+ FWD(aft, bef, 1);
+ break;
+ case OANYOF:
+ cs = &g->sets[OPND(s)];
+ if (!NONCHAR(ch) && CHIN(cs, ch))
+ FWD(aft, bef, 1);
+ break;
+ case OBACK_: /* ignored here */
+ case O_BACK:
+ FWD(aft, aft, 1);
+ break;
+ case OPLUS_: /* forward, this is just an empty */
+ FWD(aft, aft, 1);
+ break;
+ case O_PLUS: /* both forward and back */
+ FWD(aft, aft, 1);
+ i = ISSETBACK(aft, OPND(s));
+ BACK(aft, aft, OPND(s));
+ if (!i && ISSETBACK(aft, OPND(s))) {
+ /* oho, must reconsider loop body */
+ pc -= OPND(s) + 1;
+ INIT(here, pc);
+ }
+ break;
+ case OQUEST_: /* two branches, both forward */
+ FWD(aft, aft, 1);
+ FWD(aft, aft, OPND(s));
+ break;
+ case O_QUEST: /* just an empty */
+ FWD(aft, aft, 1);
+ break;
+ case OLPAREN: /* not significant here */
+ case ORPAREN:
+ FWD(aft, aft, 1);
+ break;
+ case OCH_: /* mark the first two branches */
+ FWD(aft, aft, 1);
+ assert(OP(g->strip[pc+OPND(s)]) == OOR2);
+ FWD(aft, aft, OPND(s));
+ break;
+ case OOR1: /* done a branch, find the O_CH */
+ if (ISSTATEIN(aft, here)) {
+ for (look = 1;
+ OP(s = g->strip[pc+look]) != O_CH;
+ look += OPND(s))
+ assert(OP(s) == OOR2);
+ FWD(aft, aft, look);
+ }
+ break;
+ case OOR2: /* propagate OCH_'s marking */
+ FWD(aft, aft, 1);
+ if (OP(g->strip[pc+OPND(s)]) != O_CH) {
+ assert(OP(g->strip[pc+OPND(s)]) == OOR2);
+ FWD(aft, aft, OPND(s));
+ }
+ break;
+ case O_CH: /* just empty */
+ FWD(aft, aft, 1);
+ break;
+ default: /* ooooops... */
+ assert(nope);
+ break;
+ }
+ }
+
+ return(aft);
+}
+
+#ifdef REDEBUG
+/*
+ - print - print a set of states
+ == #ifdef REDEBUG
+ == static void print(struct match *m, char *caption, states st, \
+ == int ch, FILE *d);
+ == #endif
+ */
+static void
+print(m, caption, st, ch, d)
+struct match *m;
+char *caption;
+states st;
+int ch;
+FILE *d;
+{
+ register struct re_guts *g = m->g;
+ register int i;
+ register int first = 1;
+
+ if (!(m->eflags®_TRACE))
+ return;
+
+ fprintf(d, "%s", caption);
+ if (ch != '\0')
+ fprintf(d, " %s", pchar(ch));
+ for (i = 0; i < g->nstates; i++)
+ if (ISSET(st, i)) {
+ fprintf(d, "%s%d", (first) ? "\t" : ", ", i);
+ first = 0;
+ }
+ fprintf(d, "\n");
+}
+
+/*
+ - at - print current situation
+ == #ifdef REDEBUG
+ == static void at(struct match *m, char *title, char *start, char *stop, \
+ == sopno startst, sopno stopst);
+ == #endif
+ */
+static void
+at(m, title, start, stop, startst, stopst)
+struct match *m;
+char *title;
+char *start;
+char *stop;
+sopno startst;
+sopno stopst;
+{
+ if (!(m->eflags®_TRACE))
+ return;
+
+ printf("%s %s-", title, pchar(*start));
+ printf("%s ", pchar(*stop));
+ printf("%ld-%ld\n", (long)startst, (long)stopst);
+}
+
+#ifndef PCHARDONE
+#define PCHARDONE /* never again */
+/*
+ - pchar - make a character printable
+ == #ifdef REDEBUG
+ == static char *pchar(int ch);
+ == #endif
+ *
+ * Is this identical to regchar() over in debug.c? Well, yes. But a
+ * duplicate here avoids having a debugging-capable regexec.o tied to
+ * a matching debug.o, and this is convenient. It all disappears in
+ * the non-debug compilation anyway, so it doesn't matter much.
+ */
+static char * /* -> representation */
+pchar(ch)
+int ch;
+{
+ static char pbuf[10];
+
+ if (isprint(ch) || ch == ' ')
+ sprintf(pbuf, "%c", ch);
+ else
+ sprintf(pbuf, "\\%o", ch);
+ return(pbuf);
+}
+#endif
+#endif
+
+#undef matcher
+#undef fast
+#undef slow
+#undef dissect
+#undef backref
+#undef step
+#undef print
+#undef at
+#undef match
--- /dev/null
+.\" Copyright (c) 1992, 1993, 1994 Henry Spencer.
+.\" Copyright (c) 1992, 1993, 1994
+.\" The Regents of the University of California. All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Henry Spencer.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\" notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\" notice, this list of conditions and the following disclaimer in the
+.\" documentation and/or other materials provided with the distribution.
+.\" 3. All advertising materials mentioning features or use of this software
+.\" must display the following acknowledgement:
+.\" This product includes software developed by the University of
+.\" California, Berkeley and its contributors.
+.\" 4. Neither the name of the University nor the names of its contributors
+.\" may be used to endorse or promote products derived from this software
+.\" without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\" @(#)re_format.7 8.3 (Berkeley) 3/20/94
+.\"
+.TH RE_FORMAT 7 "March 20, 1994"
+.SH NAME
+re_format \- POSIX 1003.2 regular expressions
+.SH DESCRIPTION
+Regular expressions (``RE''s),
+as defined in POSIX 1003.2, come in two forms:
+modern REs (roughly those of
+.IR egrep ;
+1003.2 calls these ``extended'' REs)
+and obsolete REs (roughly those of
+.IR ed ;
+1003.2 ``basic'' REs).
+Obsolete REs mostly exist for backward compatibility in some old programs;
+they will be discussed at the end.
+1003.2 leaves some aspects of RE syntax and semantics open;
+`\(dg' marks decisions on these aspects that
+may not be fully portable to other 1003.2 implementations.
+.PP
+A (modern) RE is one\(dg or more non-empty\(dg \fIbranches\fR,
+separated by `|'.
+It matches anything that matches one of the branches.
+.PP
+A branch is one\(dg or more \fIpieces\fR, concatenated.
+It matches a match for the first, followed by a match for the second, etc.
+.PP
+A piece is an \fIatom\fR possibly followed
+by a single\(dg `*', `+', `?', or \fIbound\fR.
+An atom followed by `*' matches a sequence of 0 or more matches of the atom.
+An atom followed by `+' matches a sequence of 1 or more matches of the atom.
+An atom followed by `?' matches a sequence of 0 or 1 matches of the atom.
+.PP
+A \fIbound\fR is `{' followed by an unsigned decimal integer,
+possibly followed by `,'
+possibly followed by another unsigned decimal integer,
+always followed by `}'.
+The integers must lie between 0 and RE_DUP_MAX (255\(dg) inclusive,
+and if there are two of them, the first may not exceed the second.
+An atom followed by a bound containing one integer \fIi\fR
+and no comma matches
+a sequence of exactly \fIi\fR matches of the atom.
+An atom followed by a bound
+containing one integer \fIi\fR and a comma matches
+a sequence of \fIi\fR or more matches of the atom.
+An atom followed by a bound
+containing two integers \fIi\fR and \fIj\fR matches
+a sequence of \fIi\fR through \fIj\fR (inclusive) matches of the atom.
+.PP
+An atom is a regular expression enclosed in `()' (matching a match for the
+regular expression),
+an empty set of `()' (matching the null string)\(dg,
+a \fIbracket expression\fR (see below), `.'
+(matching any single character), `^' (matching the null string at the
+beginning of a line), `$' (matching the null string at the
+end of a line), a `\e' followed by one of the characters
+`^.[$()|*+?{\e'
+(matching that character taken as an ordinary character),
+a `\e' followed by any other character\(dg
+(matching that character taken as an ordinary character,
+as if the `\e' had not been present\(dg),
+or a single character with no other significance (matching that character).
+A `{' followed by a character other than a digit is an ordinary
+character, not the beginning of a bound\(dg.
+It is illegal to end an RE with `\e'.
+.PP
+A \fIbracket expression\fR is a list of characters enclosed in `[]'.
+It normally matches any single character from the list (but see below).
+If the list begins with `^',
+it matches any single character
+(but see below) \fInot\fR from the rest of the list.
+If two characters in the list are separated by `\-', this is shorthand
+for the full \fIrange\fR of characters between those two (inclusive) in the
+collating sequence,
+e.g. `[0-9]' in ASCII matches any decimal digit.
+It is illegal\(dg for two ranges to share an
+endpoint, e.g. `a-c-e'.
+Ranges are very collating-sequence-dependent,
+and portable programs should avoid relying on them.
+.PP
+To include a literal `]' in the list, make it the first character
+(following a possible `^').
+To include a literal `\-', make it the first or last character,
+or the second endpoint of a range.
+To use a literal `\-' as the first endpoint of a range,
+enclose it in `[.' and `.]' to make it a collating element (see below).
+With the exception of these and some combinations using `[' (see next
+paragraphs), all other special characters, including `\e', lose their
+special significance within a bracket expression.
+.PP
+Within a bracket expression, a collating element (a character,
+a multi-character sequence that collates as if it were a single character,
+or a collating-sequence name for either)
+enclosed in `[.' and `.]' stands for the
+sequence of characters of that collating element.
+The sequence is a single element of the bracket expression's list.
+A bracket expression containing a multi-character collating element
+can thus match more than one character,
+e.g. if the collating sequence includes a `ch' collating element,
+then the RE `[[.ch.]]*c' matches the first five characters
+of `chchcc'.
+.PP
+Within a bracket expression, a collating element enclosed in `[=' and
+`=]' is an equivalence class, standing for the sequences of characters
+of all collating elements equivalent to that one, including itself.
+(If there are no other equivalent collating elements,
+the treatment is as if the enclosing delimiters were `[.' and `.]'.)
+For example, if o and \o'o^' are the members of an equivalence class,
+then `[[=o=]]', `[[=\o'o^'=]]', and `[o\o'o^']' are all synonymous.
+An equivalence class may not\(dg be an endpoint
+of a range.
+.PP
+Within a bracket expression, the name of a \fIcharacter class\fR enclosed
+in `[:' and `:]' stands for the list of all characters belonging to that
+class.
+Standard character class names are:
+.PP
+.RS
+.nf
+.ta 3c 6c 9c
+alnum digit punct
+alpha graph space
+blank lower upper
+cntrl print xdigit
+.fi
+.RE
+.PP
+These stand for the character classes defined in
+.IR ctype (3).
+A locale may provide others.
+A character class may not be used as an endpoint of a range.
+.PP
+There are two special cases\(dg of bracket expressions:
+the bracket expressions `[[:<:]]' and `[[:>:]]' match the null string at
+the beginning and end of a word respectively.
+A word is defined as a sequence of
+word characters
+which is neither preceded nor followed by
+word characters.
+A word character is an
+.I alnum
+character (as defined by
+.IR ctype (3))
+or an underscore.
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+.PP
+In the event that an RE could match more than one substring of a given
+string,
+the RE matches the one starting earliest in the string.
+If the RE could match more than one substring starting at that point,
+it matches the longest.
+Subexpressions also match the longest possible substrings, subject to
+the constraint that the whole match be as long as possible,
+with subexpressions starting earlier in the RE taking priority over
+ones starting later.
+Note that higher-level subexpressions thus take priority over
+their lower-level component subexpressions.
+.PP
+Match lengths are measured in characters, not collating elements.
+A null string is considered longer than no match at all.
+For example,
+`bb*' matches the three middle characters of `abbbc',
+`(wee|week)(knights|nights)' matches all ten characters of `weeknights',
+when `(.*).*' is matched against `abc' the parenthesized subexpression
+matches all three characters, and
+when `(a*)*' is matched against `bc' both the whole RE and the parenthesized
+subexpression match the null string.
+.PP
+If case-independent matching is specified,
+the effect is much as if all case distinctions had vanished from the
+alphabet.
+When an alphabetic that exists in multiple cases appears as an
+ordinary character outside a bracket expression, it is effectively
+transformed into a bracket expression containing both cases,
+e.g. `x' becomes `[xX]'.
+When it appears inside a bracket expression, all case counterparts
+of it are added to the bracket expression, so that (e.g.) `[x]'
+becomes `[xX]' and `[^x]' becomes `[^xX]'.
+.PP
+No particular limit is imposed on the length of REs\(dg.
+Programs intended to be portable should not employ REs longer
+than 256 bytes,
+as an implementation can refuse to accept such REs and remain
+POSIX-compliant.
+.PP
+Obsolete (``basic'') regular expressions differ in several respects.
+`|', `+', and `?' are ordinary characters and there is no equivalent
+for their functionality.
+The delimiters for bounds are `\e{' and `\e}',
+with `{' and `}' by themselves ordinary characters.
+The parentheses for nested subexpressions are `\e(' and `\e)',
+with `(' and `)' by themselves ordinary characters.
+`^' is an ordinary character except at the beginning of the
+RE or\(dg the beginning of a parenthesized subexpression,
+`$' is an ordinary character except at the end of the
+RE or\(dg the end of a parenthesized subexpression,
+and `*' is an ordinary character if it appears at the beginning of the
+RE or the beginning of a parenthesized subexpression
+(after a possible leading `^').
+Finally, there is one new type of atom, a \fIback reference\fR:
+`\e' followed by a non-zero decimal digit \fId\fR
+matches the same sequence of characters
+matched by the \fId\fRth parenthesized subexpression
+(numbering subexpressions by the positions of their opening parentheses,
+left to right),
+so that (e.g.) `\e([bc]\e)\e1' matches `bb' or `cc' but not `bc'.
+.SH SEE ALSO
+regex(3)
+.PP
+POSIX 1003.2, section 2.8 (Regular Expression Notation).
+.SH BUGS
+Having two kinds of REs is a botch.
+.PP
+The current 1003.2 spec says that `)' is an ordinary character in
+the absence of an unmatched `(';
+this was an unintentional result of a wording error,
+and change is likely.
+Avoid relying on it.
+.PP
+Back references are a dreadful botch,
+posing major problems for efficient implementations.
+They are also somewhat vaguely defined
+(does
+`a\e(\e(b\e)*\e2\e)*d' match `abbbd'?).
+Avoid using them.
+.PP
+1003.2's specification of case-independent matching is vague.
+The ``one case implies all cases'' definition given above
+is current consensus among implementors as to the right interpretation.
+.PP
+The syntax for word boundaries is incredibly ugly.
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)regcomp.c 8.5 (Berkeley) 3/20/94
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)regcomp.c 8.5 (Berkeley) 3/20/94";
+#endif /* LIBC_SCCS and not lint */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "utils.h"
+#include "regex2.h"
+
+#include "cclass.h"
+#include "cname.h"
+
+/*
+ * parse structure, passed up and down to avoid global variables and
+ * other clumsinesses
+ */
+struct parse {
+ char *next; /* next character in RE */
+ char *end; /* end of string (-> NUL normally) */
+ int error; /* has an error been seen? */
+ sop *strip; /* malloced strip */
+ sopno ssize; /* malloced strip size (allocated) */
+ sopno slen; /* malloced strip length (used) */
+ int ncsalloc; /* number of csets allocated */
+ struct re_guts *g;
+# define NPAREN 10 /* we need to remember () 1-9 for back refs */
+ sopno pbegin[NPAREN]; /* -> ( ([0] unused) */
+ sopno pend[NPAREN]; /* -> ) ([0] unused) */
+};
+
+/* ========= begin header generated by ./mkh ========= */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* === regcomp.c === */
+static void p_ere __P((struct parse *p, int stop));
+static void p_ere_exp __P((struct parse *p));
+static void p_str __P((struct parse *p));
+static void p_bre __P((struct parse *p, int end1, int end2));
+static int p_simp_re __P((struct parse *p, int starordinary));
+static int p_count __P((struct parse *p));
+static void p_bracket __P((struct parse *p));
+static void p_b_term __P((struct parse *p, cset *cs));
+static void p_b_cclass __P((struct parse *p, cset *cs));
+static void p_b_eclass __P((struct parse *p, cset *cs));
+static char p_b_symbol __P((struct parse *p));
+static char p_b_coll_elem __P((struct parse *p, int endc));
+static char othercase __P((int ch));
+static void bothcases __P((struct parse *p, int ch));
+static void ordinary __P((struct parse *p, int ch));
+static void nonnewline __P((struct parse *p));
+static void repeat __P((struct parse *p, sopno start, int from, int to));
+static int seterr __P((struct parse *p, int e));
+static cset *allocset __P((struct parse *p));
+static void freeset __P((struct parse *p, cset *cs));
+static int freezeset __P((struct parse *p, cset *cs));
+static int firstch __P((struct parse *p, cset *cs));
+static int nch __P((struct parse *p, cset *cs));
+static void mcadd __P((struct parse *p, cset *cs, char *cp));
+static void mcsub __P((cset *cs, char *cp));
+static int mcin __P((cset *cs, char *cp));
+static char *mcfind __P((cset *cs, char *cp));
+static void mcinvert __P((struct parse *p, cset *cs));
+static void mccase __P((struct parse *p, cset *cs));
+static int isinsets __P((struct re_guts *g, int c));
+static int samesets __P((struct re_guts *g, int c1, int c2));
+static void categorize __P((struct parse *p, struct re_guts *g));
+static sopno dupl __P((struct parse *p, sopno start, sopno finish));
+static void doemit __P((struct parse *p, sop op, size_t opnd));
+static void doinsert __P((struct parse *p, sop op, size_t opnd, sopno pos));
+static void dofwd __P((struct parse *p, sopno pos, sop value));
+static void enlarge __P((struct parse *p, sopno size));
+static void stripsnug __P((struct parse *p, struct re_guts *g));
+static void findmust __P((struct parse *p, struct re_guts *g));
+static sopno pluscount __P((struct parse *p, struct re_guts *g));
+
+#ifdef __cplusplus
+}
+#endif
+/* ========= end header generated by ./mkh ========= */
+
+static char nuls[10]; /* place to point scanner in event of error */
+
+/*
+ * macros for use with parse structure
+ * BEWARE: these know that the parse structure is named `p' !!!
+ */
+#define PEEK() (*p->next)
+#define PEEK2() (*(p->next+1))
+#define MORE() (p->next < p->end)
+#define MORE2() (p->next+1 < p->end)
+#define SEE(c) (MORE() && PEEK() == (c))
+#define SEETWO(a, b) (MORE() && MORE2() && PEEK() == (a) && PEEK2() == (b))
+#define EAT(c) ((SEE(c)) ? (NEXT(), 1) : 0)
+#define EATTWO(a, b) ((SEETWO(a, b)) ? (NEXT2(), 1) : 0)
+#define NEXT() (p->next++)
+#define NEXT2() (p->next += 2)
+#define NEXTn(n) (p->next += (n))
+#define GETNEXT() (*p->next++)
+#define SETERROR(e) seterr(p, (e))
+#define REQUIRE(co, e) ((co) || SETERROR(e))
+#define MUSTSEE(c, e) (REQUIRE(MORE() && PEEK() == (c), e))
+#define MUSTEAT(c, e) (REQUIRE(MORE() && GETNEXT() == (c), e))
+#define MUSTNOTSEE(c, e) (REQUIRE(!MORE() || PEEK() != (c), e))
+#define EMIT(op, sopnd) doemit(p, (sop)(op), (size_t)(sopnd))
+#define INSERT(op, pos) doinsert(p, (sop)(op), HERE()-(pos)+1, pos)
+#define AHEAD(pos) dofwd(p, pos, HERE()-(pos))
+#define ASTERN(sop, pos) EMIT(sop, HERE()-pos)
+#define HERE() (p->slen)
+#define THERE() (p->slen - 1)
+#define THERETHERE() (p->slen - 2)
+#define DROP(n) (p->slen -= (n))
+
+#ifndef NDEBUG
+static int never = 0; /* for use in asserts; shuts lint up */
+#else
+#define never 0 /* some
s have bugs too */+#endif
+
+/*
+ - regcomp - interface for parser and compilation
+ = extern int regcomp(regex_t *, const char *, int);
+ = #define REG_BASIC 0000
+ = #define REG_EXTENDED 0001
+ = #define REG_ICASE 0002
+ = #define REG_NOSUB 0004
+ = #define REG_NEWLINE 0010
+ = #define REG_NOSPEC 0020
+ = #define REG_PEND 0040
+ = #define REG_DUMP 0200
+ */
+int /* 0 success, otherwise REG_something */
+regcomp(preg, pattern, cflags)
+regex_t *preg;
+const char *pattern;
+int cflags;
+{
+ struct parse pa;
+ register struct re_guts *g;
+ register struct parse *p = &pa;
+ register int i;
+ register size_t len;
+#ifdef REDEBUG
+# define GOODFLAGS(f) (f)
+#else
+# define GOODFLAGS(f) ((f)&~REG_DUMP)
+#endif
+
+ cflags = GOODFLAGS(cflags);
+ if ((cflags®_EXTENDED) && (cflags®_NOSPEC))
+ return(REG_INVARG);
+
+ if (cflags®_PEND) {
+ if (preg->re_endp < pattern)
+ return(REG_INVARG);
+ len = preg->re_endp - pattern;
+ } else
+ len = strlen((char *)pattern);
+
+ /* do the mallocs early so failure handling is easy */
+ g = (struct re_guts *)malloc(sizeof(struct re_guts) +
+ (NC-1)*sizeof(cat_t));
+ if (g == NULL)
+ return(REG_ESPACE);
+ p->ssize = len/(size_t)2*(size_t)3 + (size_t)1; /* ugh */
+ p->strip = (sop *)malloc(p->ssize * sizeof(sop));
+ p->slen = 0;
+ if (p->strip == NULL) {
+ free((char *)g);
+ return(REG_ESPACE);
+ }
+
+ /* set things up */
+ p->g = g;
+ p->next = (char *)pattern; /* convenience; we do not modify it */
+ p->end = p->next + len;
+ p->error = 0;
+ p->ncsalloc = 0;
+ for (i = 0; i < NPAREN; i++) {
+ p->pbegin[i] = 0;
+ p->pend[i] = 0;
+ }
+ g->csetsize = NC;
+ g->sets = NULL;
+ g->setbits = NULL;
+ g->ncsets = 0;
+ g->cflags = cflags;
+ g->iflags = 0;
+ g->nbol = 0;
+ g->neol = 0;
+ g->must = NULL;
+ g->mlen = 0;
+ g->nsub = 0;
+ g->ncategories = 1; /* category 0 is "everything else" */
+ g->categories = &g->catspace[-(CHAR_MIN)];
+ (void) memset((char *)g->catspace, 0, NC*sizeof(cat_t));
+ g->backrefs = 0;
+
+ /* do it */
+ EMIT(OEND, 0);
+ g->firststate = THERE();
+ if (cflags®_EXTENDED)
+ p_ere(p, OUT);
+ else if (cflags®_NOSPEC)
+ p_str(p);
+ else
+ p_bre(p, OUT, OUT);
+ EMIT(OEND, 0);
+ g->laststate = THERE();
+
+ /* tidy up loose ends and fill things in */
+ categorize(p, g);
+ stripsnug(p, g);
+ findmust(p, g);
+ g->nplus = pluscount(p, g);
+ g->magic = MAGIC2;
+ preg->re_nsub = g->nsub;
+ preg->re_g = g;
+ preg->re_magic = MAGIC1;
+#ifndef REDEBUG
+ /* not debugging, so can't rely on the assert() in regexec() */
+ if (g->iflags&BAD)
+ SETERROR(REG_ASSERT);
+#endif
+
+ /* win or lose, we're done */
+ if (p->error != 0) /* lose */
+ regfree(preg);
+ return(p->error);
+}
+
+/*
+ - p_ere - ERE parser top level, concatenation and alternation
+ == static void p_ere(register struct parse *p, int stop);
+ */
+static void
+p_ere(p, stop)
+register struct parse *p;
+int stop; /* character this ERE should end at */
+{
+ register char c;
+ register sopno prevback;
+ register sopno prevfwd;
+ register sopno conc;
+ register int first = 1; /* is this the first alternative? */
+
+ for (;;) {
+ /* do a bunch of concatenated expressions */
+ conc = HERE();
+ while (MORE() && (c = PEEK()) != '|' && c != stop)
+ p_ere_exp(p);
+ REQUIRE(HERE() != conc, REG_EMPTY); /* require nonempty */
+
+ if (!EAT('|'))
+ break; /* NOTE BREAK OUT */
+
+ if (first) {
+ INSERT(OCH_, conc); /* offset is wrong */
+ prevfwd = conc;
+ prevback = conc;
+ first = 0;
+ }
+ ASTERN(OOR1, prevback);
+ prevback = THERE();
+ AHEAD(prevfwd); /* fix previous offset */
+ prevfwd = HERE();
+ EMIT(OOR2, 0); /* offset is very wrong */
+ }
+
+ if (!first) { /* tail-end fixups */
+ AHEAD(prevfwd);
+ ASTERN(O_CH, prevback);
+ }
+
+ assert(!MORE() || SEE(stop));
+}
+
+/*
+ - p_ere_exp - parse one subERE, an atom possibly followed by a repetition op
+ == static void p_ere_exp(register struct parse *p);
+ */
+static void
+p_ere_exp(p)
+register struct parse *p;
+{
+ register char c;
+ register sopno pos;
+ register int count;
+ register int count2;
+ register sopno subno;
+ int wascaret = 0;
+
+ assert(MORE()); /* caller should have ensured this */
+ c = GETNEXT();
+
+ pos = HERE();
+ switch (c) {
+ case '(':
+ REQUIRE(MORE(), REG_EPAREN);
+ p->g->nsub++;
+ subno = p->g->nsub;
+ if (subno < NPAREN)
+ p->pbegin[subno] = HERE();
+ EMIT(OLPAREN, subno);
+ if (!SEE(')'))
+ p_ere(p, ')');
+ if (subno < NPAREN) {
+ p->pend[subno] = HERE();
+ assert(p->pend[subno] != 0);
+ }
+ EMIT(ORPAREN, subno);
+ MUSTEAT(')', REG_EPAREN);
+ break;
+#ifndef POSIX_MISTAKE
+ case ')': /* happens only if no current unmatched ( */
+ /*
+ * You may ask, why the ifndef? Because I didn't notice
+ * this until slightly too late for 1003.2, and none of the
+ * other 1003.2 regular-expression reviewers noticed it at
+ * all. So an unmatched ) is legal POSIX, at least until
+ * we can get it fixed.
+ */
+ SETERROR(REG_EPAREN);
+ break;
+#endif
+ case '^':
+ EMIT(OBOL, 0);
+ p->g->iflags |= USEBOL;
+ p->g->nbol++;
+ wascaret = 1;
+ break;
+ case '$':
+ EMIT(OEOL, 0);
+ p->g->iflags |= USEEOL;
+ p->g->neol++;
+ break;
+ case '|':
+ SETERROR(REG_EMPTY);
+ break;
+ case '*':
+ case '+':
+ case '?':
+ SETERROR(REG_BADRPT);
+ break;
+ case '.':
+ if (p->g->cflags®_NEWLINE)
+ nonnewline(p);
+ else
+ EMIT(OANY, 0);
+ break;
+ case '[':
+ p_bracket(p);
+ break;
+ case '\\':
+ REQUIRE(MORE(), REG_EESCAPE);
+ c = GETNEXT();
+ ordinary(p, c);
+ break;
+ case '{': /* okay as ordinary except if digit follows */
+ REQUIRE(!MORE() || !isdigit(PEEK()), REG_BADRPT);
+ /* FALLTHROUGH */
+ default:
+ ordinary(p, c);
+ break;
+ }
+
+ if (!MORE())
+ return;
+ c = PEEK();
+ /* we call { a repetition if followed by a digit */
+ if (!( c == '*' || c == '+' || c == '?' ||
+ (c == '{' && MORE2() && isdigit(PEEK2())) ))
+ return; /* no repetition, we're done */
+ NEXT();
+
+ REQUIRE(!wascaret, REG_BADRPT);
+ switch (c) {
+ case '*': /* implemented as +? */
+ /* this case does not require the (y|) trick, noKLUDGE */
+ INSERT(OPLUS_, pos);
+ ASTERN(O_PLUS, pos);
+ INSERT(OQUEST_, pos);
+ ASTERN(O_QUEST, pos);
+ break;
+ case '+':
+ INSERT(OPLUS_, pos);
+ ASTERN(O_PLUS, pos);
+ break;
+ case '?':
+ /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
+ INSERT(OCH_, pos); /* offset slightly wrong */
+ ASTERN(OOR1, pos); /* this one's right */
+ AHEAD(pos); /* fix the OCH_ */
+ EMIT(OOR2, 0); /* offset very wrong... */
+ AHEAD(THERE()); /* ...so fix it */
+ ASTERN(O_CH, THERETHERE());
+ break;
+ case '{':
+ count = p_count(p);
+ if (EAT(',')) {
+ if (isdigit(PEEK())) {
+ count2 = p_count(p);
+ REQUIRE(count <= count2, REG_BADBR);
+ } else /* single number with comma */
+ count2 = INFINITY;
+ } else /* just a single number */
+ count2 = count;
+ repeat(p, pos, count, count2);
+ if (!EAT('}')) { /* error heuristics */
+ while (MORE() && PEEK() != '}')
+ NEXT();
+ REQUIRE(MORE(), REG_EBRACE);
+ SETERROR(REG_BADBR);
+ }
+ break;
+ }
+
+ if (!MORE())
+ return;
+ c = PEEK();
+ if (!( c == '*' || c == '+' || c == '?' ||
+ (c == '{' && MORE2() && isdigit(PEEK2())) ) )
+ return;
+ SETERROR(REG_BADRPT);
+}
+
+/*
+ - p_str - string (no metacharacters) "parser"
+ == static void p_str(register struct parse *p);
+ */
+static void
+p_str(p)
+register struct parse *p;
+{
+ REQUIRE(MORE(), REG_EMPTY);
+ while (MORE())
+ ordinary(p, GETNEXT());
+}
+
+/*
+ - p_bre - BRE parser top level, anchoring and concatenation
+ == static void p_bre(register struct parse *p, register int end1, \
+ == register int end2);
+ * Giving end1 as OUT essentially eliminates the end1/end2 check.
+ *
+ * This implementation is a bit of a kludge, in that a trailing $ is first
+ * taken as an ordinary character and then revised to be an anchor. The
+ * only undesirable side effect is that '$' gets included as a character
+ * category in such cases. This is fairly harmless; not worth fixing.
+ * The amount of lookahead needed to avoid this kludge is excessive.
+ */
+static void
+p_bre(p, end1, end2)
+register struct parse *p;
+register int end1; /* first terminating character */
+register int end2; /* second terminating character */
+{
+ register sopno start = HERE();
+ register int first = 1; /* first subexpression? */
+ register int wasdollar = 0;
+
+ if (EAT('^')) {
+ EMIT(OBOL, 0);
+ p->g->iflags |= USEBOL;
+ p->g->nbol++;
+ }
+ while (MORE() && !SEETWO(end1, end2)) {
+ wasdollar = p_simp_re(p, first);
+ first = 0;
+ }
+ if (wasdollar) { /* oops, that was a trailing anchor */
+ DROP(1);
+ EMIT(OEOL, 0);
+ p->g->iflags |= USEEOL;
+ p->g->neol++;
+ }
+
+ REQUIRE(HERE() != start, REG_EMPTY); /* require nonempty */
+}
+
+/*
+ - p_simp_re - parse a simple RE, an atom possibly followed by a repetition
+ == static int p_simp_re(register struct parse *p, int starordinary);
+ */
+static int /* was the simple RE an unbackslashed $? */
+p_simp_re(p, starordinary)
+register struct parse *p;
+int starordinary; /* is a leading * an ordinary character? */
+{
+ register int c;
+ register int count;
+ register int count2;
+ register sopno pos;
+ register int i;
+ register sopno subno;
+# define BACKSL (1<
+
+ pos = HERE(); /* repetion op, if any, covers from here */
+
+ assert(MORE()); /* caller should have ensured this */
+ c = GETNEXT();
+ if (c == '\\') {
+ REQUIRE(MORE(), REG_EESCAPE);
+ c = BACKSL | (unsigned char)GETNEXT();
+ }
+ switch (c) {
+ case '.':
+ if (p->g->cflags®_NEWLINE)
+ nonnewline(p);
+ else
+ EMIT(OANY, 0);
+ break;
+ case '[':
+ p_bracket(p);
+ break;
+ case BACKSL|'{':
+ SETERROR(REG_BADRPT);
+ break;
+ case BACKSL|'(':
+ p->g->nsub++;
+ subno = p->g->nsub;
+ if (subno < NPAREN)
+ p->pbegin[subno] = HERE();
+ EMIT(OLPAREN, subno);
+ /* the MORE here is an error heuristic */
+ if (MORE() && !SEETWO('\\', ')'))
+ p_bre(p, '\\', ')');
+ if (subno < NPAREN) {
+ p->pend[subno] = HERE();
+ assert(p->pend[subno] != 0);
+ }
+ EMIT(ORPAREN, subno);
+ REQUIRE(EATTWO('\\', ')'), REG_EPAREN);
+ break;
+ case BACKSL|')': /* should not get here -- must be user */
+ case BACKSL|'}':
+ SETERROR(REG_EPAREN);
+ break;
+ case BACKSL|'1':
+ case BACKSL|'2':
+ case BACKSL|'3':
+ case BACKSL|'4':
+ case BACKSL|'5':
+ case BACKSL|'6':
+ case BACKSL|'7':
+ case BACKSL|'8':
+ case BACKSL|'9':
+ i = (c&~BACKSL) - '0';
+ assert(i < NPAREN);
+ if (p->pend[i] != 0) {
+ assert(i <= p->g->nsub);
+ EMIT(OBACK_, i);
+ assert(p->pbegin[i] != 0);
+ assert(OP(p->strip[p->pbegin[i]]) == OLPAREN);
+ assert(OP(p->strip[p->pend[i]]) == ORPAREN);
+ (void) dupl(p, p->pbegin[i]+1, p->pend[i]);
+ EMIT(O_BACK, i);
+ } else
+ SETERROR(REG_ESUBREG);
+ p->g->backrefs = 1;
+ break;
+ case '*':
+ REQUIRE(starordinary, REG_BADRPT);
+ /* FALLTHROUGH */
+ default:
+ ordinary(p, c &~ BACKSL);
+ break;
+ }
+
+ if (EAT('*')) { /* implemented as +? */
+ /* this case does not require the (y|) trick, noKLUDGE */
+ INSERT(OPLUS_, pos);
+ ASTERN(O_PLUS, pos);
+ INSERT(OQUEST_, pos);
+ ASTERN(O_QUEST, pos);
+ } else if (EATTWO('\\', '{')) {
+ count = p_count(p);
+ if (EAT(',')) {
+ if (MORE() && isdigit(PEEK())) {
+ count2 = p_count(p);
+ REQUIRE(count <= count2, REG_BADBR);
+ } else /* single number with comma */
+ count2 = INFINITY;
+ } else /* just a single number */
+ count2 = count;
+ repeat(p, pos, count, count2);
+ if (!EATTWO('\\', '}')) { /* error heuristics */
+ while (MORE() && !SEETWO('\\', '}'))
+ NEXT();
+ REQUIRE(MORE(), REG_EBRACE);
+ SETERROR(REG_BADBR);
+ }
+ } else if (c == (unsigned char)'$') /* $ (but not \$) ends it */
+ return(1);
+
+ return(0);
+}
+
+/*
+ - p_count - parse a repetition count
+ == static int p_count(register struct parse *p);
+ */
+static int /* the value */
+p_count(p)
+register struct parse *p;
+{
+ register int count = 0;
+ register int ndigits = 0;
+
+ while (MORE() && isdigit(PEEK()) && count <= DUPMAX) {
+ count = count*10 + (GETNEXT() - '0');
+ ndigits++;
+ }
+
+ REQUIRE(ndigits > 0 && count <= DUPMAX, REG_BADBR);
+ return(count);
+}
+
+/*
+ - p_bracket - parse a bracketed character list
+ == static void p_bracket(register struct parse *p);
+ *
+ * Note a significant property of this code: if the allocset() did SETERROR,
+ * no set operations are done.
+ */
+static void
+p_bracket(p)
+register struct parse *p;
+{
+ register char c;
+ register cset *cs = allocset(p);
+ register int invert = 0;
+
+ /* Dept of Truly Sickening Special-Case Kludges */
+ if (p->next + 5 < p->end && strncmp(p->next, "[:<:]]", 6) == 0) {
+ EMIT(OBOW, 0);
+ NEXTn(6);
+ return;
+ }
+ if (p->next + 5 < p->end && strncmp(p->next, "[:>:]]", 6) == 0) {
+ EMIT(OEOW, 0);
+ NEXTn(6);
+ return;
+ }
+
+ if (EAT('^'))
+ invert++; /* make note to invert set at end */
+ if (EAT(']'))
+ CHadd(cs, ']');
+ else if (EAT('-'))
+ CHadd(cs, '-');
+ while (MORE() && PEEK() != ']' && !SEETWO('-', ']'))
+ p_b_term(p, cs);
+ if (EAT('-'))
+ CHadd(cs, '-');
+ MUSTEAT(']', REG_EBRACK);
+
+ if (p->error != 0) /* don't mess things up further */
+ return;
+
+ if (p->g->cflags®_ICASE) {
+ register int i;
+ register int ci;
+
+ for (i = p->g->csetsize - 1; i >= 0; i--)
+ if (CHIN(cs, i) && isalpha(i)) {
+ ci = othercase(i);
+ if (ci != i)
+ CHadd(cs, ci);
+ }
+ if (cs->multis != NULL)
+ mccase(p, cs);
+ }
+ if (invert) {
+ register int i;
+
+ for (i = p->g->csetsize - 1; i >= 0; i--)
+ if (CHIN(cs, i))
+ CHsub(cs, i);
+ else
+ CHadd(cs, i);
+ if (p->g->cflags®_NEWLINE)
+ CHsub(cs, '\n');
+ if (cs->multis != NULL)
+ mcinvert(p, cs);
+ }
+
+ assert(cs->multis == NULL); /* xxx */
+
+ if (nch(p, cs) == 1) { /* optimize singleton sets */
+ ordinary(p, firstch(p, cs));
+ freeset(p, cs);
+ } else
+ EMIT(OANYOF, freezeset(p, cs));
+}
+
+/*
+ - p_b_term - parse one term of a bracketed character list
+ == static void p_b_term(register struct parse *p, register cset *cs);
+ */
+static void
+p_b_term(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ register char c;
+ register char start, finish;
+ register int i;
+
+ /* classify what we've got */
+ switch ((MORE()) ? PEEK() : '\0') {
+ case '[':
+ c = (MORE2()) ? PEEK2() : '\0';
+ break;
+ case '-':
+ SETERROR(REG_ERANGE);
+ return; /* NOTE RETURN */
+ break;
+ default:
+ c = '\0';
+ break;
+ }
+
+ switch (c) {
+ case ':': /* character class */
+ NEXT2();
+ REQUIRE(MORE(), REG_EBRACK);
+ c = PEEK();
+ REQUIRE(c != '-' && c != ']', REG_ECTYPE);
+ p_b_cclass(p, cs);
+ REQUIRE(MORE(), REG_EBRACK);
+ REQUIRE(EATTWO(':', ']'), REG_ECTYPE);
+ break;
+ case '=': /* equivalence class */
+ NEXT2();
+ REQUIRE(MORE(), REG_EBRACK);
+ c = PEEK();
+ REQUIRE(c != '-' && c != ']', REG_ECOLLATE);
+ p_b_eclass(p, cs);
+ REQUIRE(MORE(), REG_EBRACK);
+ REQUIRE(EATTWO('=', ']'), REG_ECOLLATE);
+ break;
+ default: /* symbol, ordinary character, or range */
+/* xxx revision needed for multichar stuff */
+ start = p_b_symbol(p);
+ if (SEE('-') && MORE2() && PEEK2() != ']') {
+ /* range */
+ NEXT();
+ if (EAT('-'))
+ finish = '-';
+ else
+ finish = p_b_symbol(p);
+ } else
+ finish = start;
+/* xxx what about signed chars here... */
+ REQUIRE(start <= finish, REG_ERANGE);
+ for (i = start; i <= finish; i++)
+ CHadd(cs, i);
+ break;
+ }
+}
+
+/*
+ - p_b_cclass - parse a character-class name and deal with it
+ == static void p_b_cclass(register struct parse *p, register cset *cs);
+ */
+static void
+p_b_cclass(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ register char *sp = p->next;
+ register struct cclass *cp;
+ register size_t len;
+ register char *u;
+ register char c;
+
+ while (MORE() && isalpha(PEEK()))
+ NEXT();
+ len = p->next - sp;
+ for (cp = cclasses; cp->name != NULL; cp++)
+ if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')
+ break;
+ if (cp->name == NULL) {
+ /* oops, didn't find it */
+ SETERROR(REG_ECTYPE);
+ return;
+ }
+
+ u = cp->chars;
+ while ((c = *u++) != '\0')
+ CHadd(cs, c);
+ for (u = cp->multis; *u != '\0'; u += strlen(u) + 1)
+ MCadd(p, cs, u);
+}
+
+/*
+ - p_b_eclass - parse an equivalence-class name and deal with it
+ == static void p_b_eclass(register struct parse *p, register cset *cs);
+ *
+ * This implementation is incomplete. xxx
+ */
+static void
+p_b_eclass(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ register char c;
+
+ c = p_b_coll_elem(p, '=');
+ CHadd(cs, c);
+}
+
+/*
+ - p_b_symbol - parse a character or [..]ed multicharacter collating symbol
+ == static char p_b_symbol(register struct parse *p);
+ */
+static char /* value of symbol */
+p_b_symbol(p)
+register struct parse *p;
+{
+ register char value;
+
+ REQUIRE(MORE(), REG_EBRACK);
+ if (!EATTWO('[', '.'))
+ return(GETNEXT());
+
+ /* collating symbol */
+ value = p_b_coll_elem(p, '.');
+ REQUIRE(EATTWO('.', ']'), REG_ECOLLATE);
+ return(value);
+}
+
+/*
+ - p_b_coll_elem - parse a collating-element name and look it up
+ == static char p_b_coll_elem(register struct parse *p, int endc);
+ */
+static char /* value of collating element */
+p_b_coll_elem(p, endc)
+register struct parse *p;
+int endc; /* name ended by endc,']' */
+{
+ register char *sp = p->next;
+ register struct cname *cp;
+ register int len;
+ register char c;
+
+ while (MORE() && !SEETWO(endc, ']'))
+ NEXT();
+ if (!MORE()) {
+ SETERROR(REG_EBRACK);
+ return(0);
+ }
+ len = p->next - sp;
+ for (cp = cnames; cp->name != NULL; cp++)
+ if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')
+ return(cp->code); /* known name */
+ if (len == 1)
+ return(*sp); /* single character */
+ SETERROR(REG_ECOLLATE); /* neither */
+ return(0);
+}
+
+/*
+ - othercase - return the case counterpart of an alphabetic
+ == static char othercase(int ch);
+ */
+static char /* if no counterpart, return ch */
+othercase(ch)
+int ch;
+{
+ assert(isalpha(ch));
+ if (isupper(ch))
+ return(tolower(ch));
+ else if (islower(ch))
+ return(toupper(ch));
+ else /* peculiar, but could happen */
+ return(ch);
+}
+
+/*
+ - bothcases - emit a dualcase version of a two-case character
+ == static void bothcases(register struct parse *p, int ch);
+ *
+ * Boy, is this implementation ever a kludge...
+ */
+static void
+bothcases(p, ch)
+register struct parse *p;
+int ch;
+{
+ register char *oldnext = p->next;
+ register char *oldend = p->end;
+ char bracket[3];
+
+ assert(othercase(ch) != ch); /* p_bracket() would recurse */
+ p->next = bracket;
+ p->end = bracket+2;
+ bracket[0] = ch;
+ bracket[1] = ']';
+ bracket[2] = '\0';
+ p_bracket(p);
+ assert(p->next == bracket+2);
+ p->next = oldnext;
+ p->end = oldend;
+}
+
+/*
+ - ordinary - emit an ordinary character
+ == static void ordinary(register struct parse *p, register int ch);
+ */
+static void
+ordinary(p, ch)
+register struct parse *p;
+register int ch;
+{
+ register cat_t *cap = p->g->categories;
+
+ if ((p->g->cflags®_ICASE) && isalpha(ch) && othercase(ch) != ch)
+ bothcases(p, ch);
+ else {
+ EMIT(OCHAR, (unsigned char)ch);
+ if (cap[ch] == 0)
+ cap[ch] = p->g->ncategories++;
+ }
+}
+
+/*
+ - nonnewline - emit REG_NEWLINE version of OANY
+ == static void nonnewline(register struct parse *p);
+ *
+ * Boy, is this implementation ever a kludge...
+ */
+static void
+nonnewline(p)
+register struct parse *p;
+{
+ register char *oldnext = p->next;
+ register char *oldend = p->end;
+ char bracket[4];
+
+ p->next = bracket;
+ p->end = bracket+3;
+ bracket[0] = '^';
+ bracket[1] = '\n';
+ bracket[2] = ']';
+ bracket[3] = '\0';
+ p_bracket(p);
+ assert(p->next == bracket+3);
+ p->next = oldnext;
+ p->end = oldend;
+}
+
+/*
+ - repeat - generate code for a bounded repetition, recursively if needed
+ == static void repeat(register struct parse *p, sopno start, int from, int to);
+ */
+static void
+repeat(p, start, from, to)
+register struct parse *p;
+sopno start; /* operand from here to end of strip */
+int from; /* repeated from this number */
+int to; /* to this number of times (maybe INFINITY) */
+{
+ register 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)
+ register sopno copy;
+
+ if (p->error != 0) /* head off possible runaway recursion */
+ return;
+
+ assert(from <= to);
+
+ switch (REP(MAP(from), MAP(to))) {
+ case REP(0, 0): /* must be user doing this */
+ DROP(finish-start); /* drop the operand */
+ break;
+ case REP(0, 1): /* as x{1,1}? */
+ case REP(0, N): /* as x{1,n}? */
+ case REP(0, INF): /* as x{1,}? */
+ /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
+ INSERT(OCH_, start); /* offset is wrong... */
+ repeat(p, start+1, 1, to);
+ ASTERN(OOR1, start);
+ AHEAD(start); /* ... fix it */
+ EMIT(OOR2, 0);
+ AHEAD(THERE());
+ ASTERN(O_CH, THERETHERE());
+ break;
+ case REP(1, 1): /* trivial case */
+ /* done */
+ break;
+ case REP(1, N): /* as x?x{1,n-1} */
+ /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
+ INSERT(OCH_, start);
+ ASTERN(OOR1, start);
+ AHEAD(start);
+ EMIT(OOR2, 0); /* offset very wrong... */
+ AHEAD(THERE()); /* ...so fix it */
+ ASTERN(O_CH, THERETHERE());
+ copy = dupl(p, start+1, finish+1);
+ assert(copy == finish+4);
+ repeat(p, copy, 1, to-1);
+ break;
+ case REP(1, INF): /* as x+ */
+ INSERT(OPLUS_, start);
+ ASTERN(O_PLUS, start);
+ break;
+ case REP(N, N): /* as xx{m-1,n-1} */
+ copy = dupl(p, start, finish);
+ repeat(p, copy, from-1, to-1);
+ break;
+ case REP(N, INF): /* as xx{n-1,INF} */
+ copy = dupl(p, start, finish);
+ repeat(p, copy, from-1, to);
+ break;
+ default: /* "can't happen" */
+ SETERROR(REG_ASSERT); /* just in case */
+ break;
+ }
+}
+
+/*
+ - seterr - set an error condition
+ == static int seterr(register struct parse *p, int e);
+ */
+static int /* useless but makes type checking happy */
+seterr(p, e)
+register struct parse *p;
+int e;
+{
+ if (p->error == 0) /* keep earliest error condition */
+ p->error = e;
+ p->next = nuls; /* try to bring things to a halt */
+ p->end = nuls;
+ return(0); /* make the return value well-defined */
+}
+
+/*
+ - allocset - allocate a set of characters for []
+ == static cset *allocset(register struct parse *p);
+ */
+static cset *
+allocset(p)
+register struct parse *p;
+{
+ register int no = p->g->ncsets++;
+ register size_t nc;
+ register size_t nbytes;
+ register cset *cs;
+ register size_t css = (size_t)p->g->csetsize;
+ register int i;
+
+ if (no >= p->ncsalloc) { /* need another column of space */
+ p->ncsalloc += CHAR_BIT;
+ nc = p->ncsalloc;
+ assert(nc % CHAR_BIT == 0);
+ nbytes = nc / CHAR_BIT * css;
+ if (p->g->sets == NULL)
+ p->g->sets = (cset *)malloc(nc * sizeof(cset));
+ else
+ p->g->sets = (cset *)realloc((char *)p->g->sets,
+ nc * sizeof(cset));
+ if (p->g->setbits == NULL)
+ p->g->setbits = (uch *)malloc(nbytes);
+ else {
+ p->g->setbits = (uch *)realloc((char *)p->g->setbits,
+ nbytes);
+ /* xxx this isn't right if setbits is now NULL */
+ for (i = 0; i < no; i++)
+ p->g->sets[i].ptr = p->g->setbits + css*(i/CHAR_BIT);
+ }
+ if (p->g->sets != NULL && p->g->setbits != NULL)
+ (void) memset((char *)p->g->setbits + (nbytes - css),
+ 0, css);
+ else {
+ no = 0;
+ SETERROR(REG_ESPACE);
+ /* caller's responsibility not to do set ops */
+ }
+ }
+
+ assert(p->g->sets != NULL); /* xxx */
+ cs = &p->g->sets[no];
+ cs->ptr = p->g->setbits + css*((no)/CHAR_BIT);
+ cs->mask = 1 << ((no) % CHAR_BIT);
+ cs->hash = 0;
+ cs->smultis = 0;
+ cs->multis = NULL;
+
+ return(cs);
+}
+
+/*
+ - freeset - free a now-unused set
+ == static void freeset(register struct parse *p, register cset *cs);
+ */
+static void
+freeset(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ register int i;
+ register cset *top = &p->g->sets[p->g->ncsets];
+ register size_t css = (size_t)p->g->csetsize;
+
+ for (i = 0; i < css; i++)
+ CHsub(cs, i);
+ if (cs == top-1) /* recover only the easy case */
+ p->g->ncsets--;
+}
+
+/*
+ - freezeset - final processing on a set of characters
+ == static int freezeset(register struct parse *p, register cset *cs);
+ *
+ * The main task here is merging identical sets. This is usually a waste
+ * of time (although the hash code minimizes the overhead), but can win
+ * big if REG_ICASE is being used. REG_ICASE, by the way, is why the hash
+ * is done using addition rather than xor -- all ASCII [aA] sets xor to
+ * the same value!
+ */
+static int /* set number */
+freezeset(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ register uch h = cs->hash;
+ register int i;
+ register cset *top = &p->g->sets[p->g->ncsets];
+ register cset *cs2;
+ register 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++)
+ if (cs2->hash == h && cs2 != cs) {
+ /* maybe */
+ for (i = 0; i < css; i++)
+ if (!!CHIN(cs2, i) != !!CHIN(cs, i))
+ break; /* no */
+ if (i == css)
+ break; /* yes */
+ }
+
+ if (cs2 < top) { /* found one */
+ freeset(p, cs);
+ cs = cs2;
+ }
+
+ return((int)(cs - p->g->sets));
+}
+
+/*
+ - firstch - return first character in a set (which must have at least one)
+ == static int firstch(register struct parse *p, register cset *cs);
+ */
+static int /* character; there is no "none" value */
+firstch(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ register int i;
+ register size_t css = (size_t)p->g->csetsize;
+
+ for (i = 0; i < css; i++)
+ if (CHIN(cs, i))
+ return((char)i);
+ assert(never);
+ return(0); /* arbitrary */
+}
+
+/*
+ - nch - number of characters in a set
+ == static int nch(register struct parse *p, register cset *cs);
+ */
+static int
+nch(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ register int i;
+ register size_t css = (size_t)p->g->csetsize;
+ register int n = 0;
+
+ for (i = 0; i < css; i++)
+ if (CHIN(cs, i))
+ n++;
+ return(n);
+}
+
+/*
+ - mcadd - add a collating element to a cset
+ == static void mcadd(register struct parse *p, register cset *cs, \
+ == register char *cp);
+ */
+static void
+mcadd(p, cs, cp)
+register struct parse *p;
+register cset *cs;
+register char *cp;
+{
+ register size_t oldend = cs->smultis;
+
+ cs->smultis += strlen(cp) + 1;
+ if (cs->multis == NULL)
+ cs->multis = malloc(cs->smultis);
+ else
+ cs->multis = realloc(cs->multis, cs->smultis);
+ if (cs->multis == NULL) {
+ SETERROR(REG_ESPACE);
+ return;
+ }
+
+ (void) strcpy(cs->multis + oldend - 1, cp);
+ cs->multis[cs->smultis - 1] = '\0';
+}
+
+/*
+ - mcsub - subtract a collating element from a cset
+ == static void mcsub(register cset *cs, register char *cp);
+ */
+static void
+mcsub(cs, cp)
+register cset *cs;
+register char *cp;
+{
+ register char *fp = mcfind(cs, cp);
+ register size_t len = strlen(fp);
+
+ assert(fp != NULL);
+ (void) memmove(fp, fp + len + 1,
+ cs->smultis - (fp + len + 1 - cs->multis));
+ cs->smultis -= len;
+
+ if (cs->smultis == 0) {
+ free(cs->multis);
+ cs->multis = NULL;
+ return;
+ }
+
+ cs->multis = realloc(cs->multis, cs->smultis);
+ assert(cs->multis != NULL);
+}
+
+/*
+ - mcin - is a collating element in a cset?
+ == static int mcin(register cset *cs, register char *cp);
+ */
+static int
+mcin(cs, cp)
+register cset *cs;
+register char *cp;
+{
+ return(mcfind(cs, cp) != NULL);
+}
+
+/*
+ - mcfind - find a collating element in a cset
+ == static char *mcfind(register cset *cs, register char *cp);
+ */
+static char *
+mcfind(cs, cp)
+register cset *cs;
+register char *cp;
+{
+ register char *p;
+
+ if (cs->multis == NULL)
+ return(NULL);
+ for (p = cs->multis; *p != '\0'; p += strlen(p) + 1)
+ if (strcmp(cp, p) == 0)
+ return(p);
+ return(NULL);
+}
+
+/*
+ - mcinvert - invert the list of collating elements in a cset
+ == static void mcinvert(register struct parse *p, register cset *cs);
+ *
+ * This would have to know the set of possibilities. Implementation
+ * is deferred.
+ */
+static void
+mcinvert(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ assert(cs->multis == NULL); /* xxx */
+}
+
+/*
+ - mccase - add case counterparts of the list of collating elements in a cset
+ == static void mccase(register struct parse *p, register cset *cs);
+ *
+ * This would have to know the set of possibilities. Implementation
+ * is deferred.
+ */
+static void
+mccase(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ assert(cs->multis == NULL); /* xxx */
+}
+
+/*
+ - isinsets - is this character in any sets?
+ == static int isinsets(register struct re_guts *g, int c);
+ */
+static int /* predicate */
+isinsets(g, c)
+register struct re_guts *g;
+int c;
+{
+ register uch *col;
+ register int i;
+ register int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
+ register unsigned uc = (unsigned char)c;
+
+ for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
+ if (col[uc] != 0)
+ return(1);
+ return(0);
+}
+
+/*
+ - samesets - are these two characters in exactly the same sets?
+ == static int samesets(register struct re_guts *g, int c1, int c2);
+ */
+static int /* predicate */
+samesets(g, c1, c2)
+register struct re_guts *g;
+int c1;
+int c2;
+{
+ register uch *col;
+ register int i;
+ register int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
+ register unsigned uc1 = (unsigned char)c1;
+ register unsigned uc2 = (unsigned char)c2;
+
+ for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
+ if (col[uc1] != col[uc2])
+ return(0);
+ return(1);
+}
+
+/*
+ - categorize - sort out character categories
+ == static void categorize(struct parse *p, register struct re_guts *g);
+ */
+static void
+categorize(p, g)
+struct parse *p;
+register struct re_guts *g;
+{
+ register cat_t *cats = g->categories;
+ register int c;
+ register int c2;
+ register cat_t cat;
+
+ /* avoid making error situations worse */
+ if (p->error != 0)
+ return;
+
+ for (c = CHAR_MIN; c <= CHAR_MAX; c++)
+ if (cats[c] == 0 && isinsets(g, c)) {
+ cat = g->ncategories++;
+ cats[c] = cat;
+ for (c2 = c+1; c2 <= CHAR_MAX; c2++)
+ if (cats[c2] == 0 && samesets(g, c, c2))
+ cats[c2] = cat;
+ }
+}
+
+/*
+ - dupl - emit a duplicate of a bunch of sops
+ == static sopno dupl(register struct parse *p, sopno start, sopno finish);
+ */
+static sopno /* start of duplicate */
+dupl(p, start, finish)
+register struct parse *p;
+sopno start; /* from here */
+sopno finish; /* to this less one */
+{
+ register sopno ret = HERE();
+ register sopno len = finish - start;
+
+ assert(finish >= start);
+ if (len == 0)
+ return(ret);
+ enlarge(p, p->ssize + len); /* this many unexpected additions */
+ assert(p->ssize >= p->slen + len);
+ (void) memcpy((char *)(p->strip + p->slen),
+ (char *)(p->strip + start), (size_t)len*sizeof(sop));
+ p->slen += len;
+ return(ret);
+}
+
+/*
+ - doemit - emit a strip operator
+ == static void doemit(register struct parse *p, sop op, size_t opnd);
+ *
+ * It might seem better to implement this as a macro with a function as
+ * hard-case backup, but it's just too big and messy unless there are
+ * some changes to the data structures. Maybe later.
+ */
+static void
+doemit(p, op, opnd)
+register struct parse *p;
+sop op;
+size_t opnd;
+{
+ /* avoid making error situations worse */
+ if (p->error != 0)
+ return;
+
+ /* deal with oversize operands ("can't happen", more or less) */
+ assert(opnd < 1<
+
+ /* deal with undersized strip */
+ if (p->slen >= p->ssize)
+ enlarge(p, (p->ssize+1) / 2 * 3); /* +50% */
+ assert(p->slen < p->ssize);
+
+ /* finally, it's all reduced to the easy case */
+ p->strip[p->slen++] = SOP(op, opnd);
+}
+
+/*
+ - doinsert - insert a sop into the strip
+ == static void doinsert(register struct parse *p, sop op, size_t opnd, sopno pos);
+ */
+static void
+doinsert(p, op, opnd, pos)
+register struct parse *p;
+sop op;
+size_t opnd;
+sopno pos;
+{
+ register sopno sn;
+ register sop s;
+ register int i;
+
+ /* avoid making error situations worse */
+ if (p->error != 0)
+ return;
+
+ sn = HERE();
+ EMIT(op, opnd); /* do checks, ensure space */
+ assert(HERE() == sn+1);
+ s = p->strip[sn];
+
+ /* adjust paren pointers */
+ assert(pos > 0);
+ for (i = 1; i < NPAREN; i++) {
+ if (p->pbegin[i] >= pos) {
+ p->pbegin[i]++;
+ }
+ if (p->pend[i] >= pos) {
+ p->pend[i]++;
+ }
+ }
+
+ memmove((char *)&p->strip[pos+1], (char *)&p->strip[pos],
+ (HERE()-pos-1)*sizeof(sop));
+ p->strip[pos] = s;
+}
+
+/*
+ - dofwd - complete a forward reference
+ == static void dofwd(register struct parse *p, sopno pos, sop value);
+ */
+static void
+dofwd(p, pos, value)
+register struct parse *p;
+register sopno pos;
+sop value;
+{
+ /* avoid making error situations worse */
+ if (p->error != 0)
+ return;
+
+ assert(value < 1<
+ p->strip[pos] = OP(p->strip[pos]) | value;
+}
+
+/*
+ - enlarge - enlarge the strip
+ == static void enlarge(register struct parse *p, sopno size);
+ */
+static void
+enlarge(p, size)
+register struct parse *p;
+register sopno size;
+{
+ register sop *sp;
+
+ if (p->ssize >= size)
+ return;
+
+ sp = (sop *)realloc(p->strip, size*sizeof(sop));
+ if (sp == NULL) {
+ SETERROR(REG_ESPACE);
+ return;
+ }
+ p->strip = sp;
+ p->ssize = size;
+}
+
+/*
+ - stripsnug - compact the strip
+ == static void stripsnug(register struct parse *p, register struct re_guts *g);
+ */
+static void
+stripsnug(p, g)
+register struct parse *p;
+register struct re_guts *g;
+{
+ g->nstates = p->slen;
+ g->strip = (sop *)realloc((char *)p->strip, p->slen * sizeof(sop));
+ if (g->strip == NULL) {
+ SETERROR(REG_ESPACE);
+ g->strip = p->strip;
+ }
+}
+
+/*
+ - findmust - fill in must and mlen with longest mandatory literal string
+ == static void findmust(register struct parse *p, register struct re_guts *g);
+ *
+ * This algorithm could do fancy things like analyzing the operands of |
+ * for common subsequences. Someday. This code is simple and finds most
+ * of the interesting cases.
+ *
+ * Note that must and mlen got initialized during setup.
+ */
+static void
+findmust(p, g)
+struct parse *p;
+register struct re_guts *g;
+{
+ register sop *scan;
+ sop *start;
+ register sop *newstart;
+ register sopno newlen;
+ register sop s;
+ register char *cp;
+ register sopno i;
+
+ /* avoid making error situations worse */
+ if (p->error != 0)
+ return;
+
+ /* find the longest OCHAR sequence in strip */
+ newlen = 0;
+ scan = g->strip + 1;
+ do {
+ s = *scan++;
+ switch (OP(s)) {
+ case OCHAR: /* sequence member */
+ if (newlen == 0) /* new sequence */
+ newstart = scan - 1;
+ newlen++;
+ break;
+ case OPLUS_: /* things that don't break one */
+ case OLPAREN:
+ case ORPAREN:
+ break;
+ case OQUEST_: /* things that must be skipped */
+ case OCH_:
+ scan--;
+ do {
+ scan += OPND(s);
+ s = *scan;
+ /* assert() interferes w debug printouts */
+ if (OP(s) != O_QUEST && OP(s) != O_CH &&
+ OP(s) != OOR2) {
+ g->iflags |= BAD;
+ return;
+ }
+ } while (OP(s) != O_QUEST && OP(s) != O_CH);
+ /* fallthrough */
+ default: /* things that break a sequence */
+ if (newlen > g->mlen) { /* ends one */
+ start = newstart;
+ g->mlen = newlen;
+ }
+ newlen = 0;
+ break;
+ }
+ } while (OP(s) != OEND);
+
+ if (g->mlen == 0) /* there isn't one */
+ return;
+
+ /* turn it into a character string */
+ g->must = malloc((size_t)g->mlen + 1);
+ if (g->must == NULL) { /* argh; just forget it */
+ g->mlen = 0;
+ return;
+ }
+ cp = g->must;
+ scan = start;
+ for (i = g->mlen; i > 0; i--) {
+ while (OP(s = *scan++) != OCHAR)
+ continue;
+ assert(cp < g->must + g->mlen);
+ *cp++ = (char)OPND(s);
+ }
+ assert(cp == g->must + g->mlen);
+ *cp++ = '\0'; /* just on general principles */
+}
+
+/*
+ - pluscount - count + nesting
+ == static sopno pluscount(register struct parse *p, register struct re_guts *g);
+ */
+static sopno /* nesting depth */
+pluscount(p, g)
+struct parse *p;
+register struct re_guts *g;
+{
+ register sop *scan;
+ register sop s;
+ register sopno plusnest = 0;
+ register sopno maxnest = 0;
+
+ if (p->error != 0)
+ return(0); /* there may not be an OEND */
+
+ scan = g->strip + 1;
+ do {
+ s = *scan++;
+ switch (OP(s)) {
+ case OPLUS_:
+ plusnest++;
+ break;
+ case O_PLUS:
+ if (plusnest > maxnest)
+ maxnest = plusnest;
+ plusnest--;
+ break;
+ }
+ } while (OP(s) != OEND);
+ if (plusnest != 0)
+ g->iflags |= BAD;
+ return(maxnest);
+}
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)regerror.c 8.4 (Berkeley) 3/20/94
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)regerror.c 8.4 (Berkeley) 3/20/94";
+#endif /* LIBC_SCCS and not lint */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "utils.h"
+
+/* ========= begin header generated by ./mkh ========= */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* === regerror.c === */
+static char *regatoi __P((const regex_t *preg, char *localbuf));
+
+#ifdef __cplusplus
+}
+#endif
+/* ========= end header generated by ./mkh ========= */
+/*
+ = #define REG_NOMATCH 1
+ = #define REG_BADPAT 2
+ = #define REG_ECOLLATE 3
+ = #define REG_ECTYPE 4
+ = #define REG_EESCAPE 5
+ = #define REG_ESUBREG 6
+ = #define REG_EBRACK 7
+ = #define REG_EPAREN 8
+ = #define REG_EBRACE 9
+ = #define REG_BADBR 10
+ = #define REG_ERANGE 11
+ = #define REG_ESPACE 12
+ = #define REG_BADRPT 13
+ = #define REG_EMPTY 14
+ = #define REG_ASSERT 15
+ = #define REG_INVARG 16
+ = #define REG_ATOI 255 // convert name to number (!)
+ = #define REG_ITOA 0400 // convert number to name (!)
+ */
+static struct rerr {
+ int code;
+ char *name;
+ char *explain;
+} rerrs[] = {
+ REG_NOMATCH, "REG_NOMATCH", "regexec() failed to match",
+ REG_BADPAT, "REG_BADPAT", "invalid regular expression",
+ REG_ECOLLATE, "REG_ECOLLATE", "invalid collating element",
+ REG_ECTYPE, "REG_ECTYPE", "invalid character class",
+ REG_EESCAPE, "REG_EESCAPE", "trailing backslash (\\)",
+ REG_ESUBREG, "REG_ESUBREG", "invalid backreference number",
+ REG_EBRACK, "REG_EBRACK", "brackets ([ ]) not balanced",
+ REG_EPAREN, "REG_EPAREN", "parentheses not balanced",
+ REG_EBRACE, "REG_EBRACE", "braces not balanced",
+ REG_BADBR, "REG_BADBR", "invalid repetition count(s)",
+ REG_ERANGE, "REG_ERANGE", "invalid character range",
+ REG_ESPACE, "REG_ESPACE", "out of memory",
+ REG_BADRPT, "REG_BADRPT", "repetition-operator operand invalid",
+ REG_EMPTY, "REG_EMPTY", "empty (sub)expression",
+ REG_ASSERT, "REG_ASSERT", "\"can't happen\" -- you found a bug",
+ REG_INVARG, "REG_INVARG", "invalid argument to regex routine",
+ 0, "", "*** unknown regexp error code ***",
+};
+
+/*
+ - regerror - the interface to error numbers
+ = extern size_t regerror(int, const regex_t *, char *, size_t);
+ */
+/* ARGSUSED */
+size_t
+regerror(errcode, preg, errbuf, errbuf_size)
+int errcode;
+const regex_t *preg;
+char *errbuf;
+size_t errbuf_size;
+{
+ register struct rerr *r;
+ register size_t len;
+ register int target = errcode &~ REG_ITOA;
+ register char *s;
+ char convbuf[50];
+
+ if (errcode == REG_ATOI)
+ s = regatoi(preg, convbuf);
+ else {
+ for (r = rerrs; r->code != 0; r++)
+ if (r->code == target)
+ break;
+
+ if (errcode®_ITOA) {
+ if (r->code != 0)
+ (void) strcpy(convbuf, r->name);
+ else
+ sprintf(convbuf, "REG_0x%x", target);
+ assert(strlen(convbuf) < sizeof(convbuf));
+ s = convbuf;
+ } else
+ s = r->explain;
+ }
+
+ len = strlen(s) + 1;
+ if (errbuf_size > 0) {
+ if (errbuf_size > len)
+ (void) strcpy(errbuf, s);
+ else {
+ (void) strncpy(errbuf, s, errbuf_size-1);
+ errbuf[errbuf_size-1] = '\0';
+ }
+ }
+
+ return(len);
+}
+
+/*
+ - regatoi - internal routine to implement REG_ATOI
+ == static char *regatoi(const regex_t *preg, char *localbuf);
+ */
+static char *
+regatoi(preg, localbuf)
+const regex_t *preg;
+char *localbuf;
+{
+ register struct rerr *r;
+ register size_t siz;
+ register char *p;
+
+ for (r = rerrs; r->code != 0; r++)
+ if (strcmp(r->name, preg->re_endp) == 0)
+ break;
+ if (r->code == 0)
+ return("0");
+
+ sprintf(localbuf, "%d", r->code);
+ return(localbuf);
+}
--- /dev/null
+.\" Copyright (c) 1992, 1993, 1994 Henry Spencer.
+.\" Copyright (c) 1992, 1993, 1994
+.\" The Regents of the University of California. All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Henry Spencer.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\" notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\" notice, this list of conditions and the following disclaimer in the
+.\" documentation and/or other materials provided with the distribution.
+.\" 3. All advertising materials mentioning features or use of this software
+.\" must display the following acknowledgement:
+.\" This product includes software developed by the University of
+.\" California, Berkeley and its contributors.
+.\" 4. Neither the name of the University nor the names of its contributors
+.\" may be used to endorse or promote products derived from this software
+.\" without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\" @(#)regex.3 8.4 (Berkeley) 3/20/94
+.\"
+.TH REGEX 3 "March 20, 1994"
+.de ZR
+.\" one other place knows this name: the SEE ALSO section
+.IR re_format (7) \\$1
+..
+.SH NAME
+regcomp, regexec, regerror, regfree \- regular-expression library
+.SH SYNOPSIS
+.ft B
+.\".na
+#include
+.br
+#include
+.HP 10
+int regcomp(regex_t\ *preg, const\ char\ *pattern, int\ cflags);
+.HP
+int\ regexec(const\ regex_t\ *preg, const\ char\ *string,
+size_t\ nmatch, regmatch_t\ pmatch[], int\ eflags);
+.HP
+size_t\ regerror(int\ errcode, const\ regex_t\ *preg,
+char\ *errbuf, size_t\ errbuf_size);
+.HP
+void\ regfree(regex_t\ *preg);
+.\".ad
+.ft
+.SH DESCRIPTION
+These routines implement POSIX 1003.2 regular expressions (``RE''s);
+see
+.ZR .
+.I Regcomp
+compiles an RE written as a string into an internal form,
+.I regexec
+matches that internal form against a string and reports results,
+.I regerror
+transforms error codes from either into human-readable messages,
+and
+.I regfree
+frees any dynamically-allocated storage used by the internal form
+of an RE.
+.PP
+The header
+.I
+declares two structure types,
+.I regex_t
+and
+.IR regmatch_t ,
+the former for compiled internal forms and the latter for match reporting.
+It also declares the four functions,
+a type
+.IR regoff_t ,
+and a number of constants with names starting with ``REG_''.
+.PP
+.I Regcomp
+compiles the regular expression contained in the
+.I pattern
+string,
+subject to the flags in
+.IR cflags ,
+and places the results in the
+.I regex_t
+structure pointed to by
+.IR preg .
+.I Cflags
+is the bitwise OR of zero or more of the following flags:
+.IP REG_EXTENDED \w'REG_EXTENDED'u+2n
+Compile modern (``extended'') REs,
+rather than the obsolete (``basic'') REs that
+are the default.
+.IP REG_BASIC
+This is a synonym for 0,
+provided as a counterpart to REG_EXTENDED to improve readability.
+.IP REG_NOSPEC
+Compile with recognition of all special characters turned off.
+All characters are thus considered ordinary,
+so the ``RE'' is a literal string.
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+REG_EXTENDED and REG_NOSPEC may not be used
+in the same call to
+.IR regcomp .
+.IP REG_ICASE
+Compile for matching that ignores upper/lower case distinctions.
+See
+.ZR .
+.IP REG_NOSUB
+Compile for matching that need only report success or failure,
+not what was matched.
+.IP REG_NEWLINE
+Compile for newline-sensitive matching.
+By default, newline is a completely ordinary character with no special
+meaning in either REs or strings.
+With this flag,
+`[^' bracket expressions and `.' never match newline,
+a `^' anchor matches the null string after any newline in the string
+in addition to its normal function,
+and the `$' anchor matches the null string before any newline in the
+string in addition to its normal function.
+.IP REG_PEND
+The regular expression ends,
+not at the first NUL,
+but just before the character pointed to by the
+.I re_endp
+member of the structure pointed to by
+.IR preg .
+The
+.I re_endp
+member is of type
+.IR const\ char\ * .
+This flag permits inclusion of NULs in the RE;
+they are considered ordinary characters.
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+.PP
+When successful,
+.I regcomp
+returns 0 and fills in the structure pointed to by
+.IR preg .
+One member of that structure
+(other than
+.IR re_endp )
+is publicized:
+.IR re_nsub ,
+of type
+.IR size_t ,
+contains the number of parenthesized subexpressions within the RE
+(except that the value of this member is undefined if the
+REG_NOSUB flag was used).
+If
+.I regcomp
+fails, it returns a non-zero error code;
+see DIAGNOSTICS.
+.PP
+.I Regexec
+matches the compiled RE pointed to by
+.I preg
+against the
+.IR string ,
+subject to the flags in
+.IR eflags ,
+and reports results using
+.IR nmatch ,
+.IR pmatch ,
+and the returned value.
+The RE must have been compiled by a previous invocation of
+.IR regcomp .
+The compiled form is not altered during execution of
+.IR regexec ,
+so a single compiled RE can be used simultaneously by multiple threads.
+.PP
+By default,
+the NUL-terminated string pointed to by
+.I string
+is considered to be the text of an entire line, minus any terminating
+newline.
+The
+.I eflags
+argument is the bitwise OR of zero or more of the following flags:
+.IP REG_NOTBOL \w'REG_STARTEND'u+2n
+The first character of
+the string
+is not the beginning of a line, so the `^' anchor should not match before it.
+This does not affect the behavior of newlines under REG_NEWLINE.
+.IP REG_NOTEOL
+The NUL terminating
+the string
+does not end a line, so the `$' anchor should not match before it.
+This does not affect the behavior of newlines under REG_NEWLINE.
+.IP REG_STARTEND
+The string is considered to start at
+\fIstring\fR\ + \fIpmatch\fR[0].\fIrm_so\fR
+and to have a terminating NUL located at
+\fIstring\fR\ + \fIpmatch\fR[0].\fIrm_eo\fR
+(there need not actually be a NUL at that location),
+regardless of the value of
+.IR nmatch .
+See below for the definition of
+.IR pmatch
+and
+.IR nmatch .
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+Note that a non-zero \fIrm_so\fR does not imply REG_NOTBOL;
+REG_STARTEND affects only the location of the string,
+not how it is matched.
+.PP
+See
+.ZR
+for a discussion of what is matched in situations where an RE or a
+portion thereof could match any of several substrings of
+.IR string .
+.PP
+Normally,
+.I regexec
+returns 0 for success and the non-zero code REG_NOMATCH for failure.
+Other non-zero error codes may be returned in exceptional situations;
+see DIAGNOSTICS.
+.PP
+If REG_NOSUB was specified in the compilation of the RE,
+or if
+.I nmatch
+is 0,
+.I regexec
+ignores the
+.I pmatch
+argument (but see below for the case where REG_STARTEND is specified).
+Otherwise,
+.I pmatch
+points to an array of
+.I nmatch
+structures of type
+.IR regmatch_t .
+Such a structure has at least the members
+.I rm_so
+and
+.IR rm_eo ,
+both of type
+.I regoff_t
+(a signed arithmetic type at least as large as an
+.I off_t
+and a
+.IR ssize_t ),
+containing respectively the offset of the first character of a substring
+and the offset of the first character after the end of the substring.
+Offsets are measured from the beginning of the
+.I string
+argument given to
+.IR regexec .
+An empty substring is denoted by equal offsets,
+both indicating the character following the empty substring.
+.PP
+The 0th member of the
+.I pmatch
+array is filled in to indicate what substring of
+.I string
+was matched by the entire RE.
+Remaining members report what substring was matched by parenthesized
+subexpressions within the RE;
+member
+.I i
+reports subexpression
+.IR i ,
+with subexpressions counted (starting at 1) by the order of their opening
+parentheses in the RE, left to right.
+Unused entries in the array\(emcorresponding either to subexpressions that
+did not participate in the match at all, or to subexpressions that do not
+exist in the RE (that is, \fIi\fR\ > \fIpreg\fR\->\fIre_nsub\fR)\(emhave both
+.I rm_so
+and
+.I rm_eo
+set to \-1.
+If a subexpression participated in the match several times,
+the reported substring is the last one it matched.
+(Note, as an example in particular, that when the RE `(b*)+' matches `bbb',
+the parenthesized subexpression matches each of the three `b's and then
+an infinite number of empty strings following the last `b',
+so the reported substring is one of the empties.)
+.PP
+If REG_STARTEND is specified,
+.I pmatch
+must point to at least one
+.I regmatch_t
+(even if
+.I nmatch
+is 0 or REG_NOSUB was specified),
+to hold the input offsets for REG_STARTEND.
+Use for output is still entirely controlled by
+.IR nmatch ;
+if
+.I nmatch
+is 0 or REG_NOSUB was specified,
+the value of
+.IR pmatch [0]
+will not be changed by a successful
+.IR regexec .
+.PP
+.I Regerror
+maps a non-zero
+.I errcode
+from either
+.I regcomp
+or
+.I regexec
+to a human-readable, printable message.
+If
+.I preg
+is non-NULL,
+the error code should have arisen from use of
+the
+.I regex_t
+pointed to by
+.IR preg ,
+and if the error code came from
+.IR regcomp ,
+it should have been the result from the most recent
+.I regcomp
+using that
+.IR regex_t .
+.RI ( Regerror
+may be able to supply a more detailed message using information
+from the
+.IR regex_t .)
+.I Regerror
+places the NUL-terminated message into the buffer pointed to by
+.IR errbuf ,
+limiting the length (including the NUL) to at most
+.I errbuf_size
+bytes.
+If the whole message won't fit,
+as much of it as will fit before the terminating NUL is supplied.
+In any case,
+the returned value is the size of buffer needed to hold the whole
+message (including terminating NUL).
+If
+.I errbuf_size
+is 0,
+.I errbuf
+is ignored but the return value is still correct.
+.PP
+If the
+.I errcode
+given to
+.I regerror
+is first ORed with REG_ITOA,
+the ``message'' that results is the printable name of the error code,
+e.g. ``REG_NOMATCH'',
+rather than an explanation thereof.
+If
+.I errcode
+is REG_ATOI,
+then
+.I preg
+shall be non-NULL and the
+.I re_endp
+member of the structure it points to
+must point to the printable name of an error code;
+in this case, the result in
+.I errbuf
+is the decimal digits of
+the numeric value of the error code
+(0 if the name is not recognized).
+REG_ITOA and REG_ATOI are intended primarily as debugging facilities;
+they are extensions,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+Be warned also that they are considered experimental and changes are possible.
+.PP
+.I Regfree
+frees any dynamically-allocated storage associated with the compiled RE
+pointed to by
+.IR preg .
+The remaining
+.I regex_t
+is no longer a valid compiled RE
+and the effect of supplying it to
+.I regexec
+or
+.I regerror
+is undefined.
+.PP
+None of these functions references global variables except for tables
+of constants;
+all are safe for use from multiple threads if the arguments are safe.
+.SH IMPLEMENTATION CHOICES
+There are a number of decisions that 1003.2 leaves up to the implementor,
+either by explicitly saying ``undefined'' or by virtue of them being
+forbidden by the RE grammar.
+This implementation treats them as follows.
+.PP
+See
+.ZR
+for a discussion of the definition of case-independent matching.
+.PP
+There is no particular limit on the length of REs,
+except insofar as memory is limited.
+Memory usage is approximately linear in RE size, and largely insensitive
+to RE complexity, except for bounded repetitions.
+See BUGS for one short RE using them
+that will run almost any system out of memory.
+.PP
+A backslashed character other than one specifically given a magic meaning
+by 1003.2 (such magic meanings occur only in obsolete [``basic''] REs)
+is taken as an ordinary character.
+.PP
+Any unmatched [ is a REG_EBRACK error.
+.PP
+Equivalence classes cannot begin or end bracket-expression ranges.
+The endpoint of one range cannot begin another.
+.PP
+RE_DUP_MAX, the limit on repetition counts in bounded repetitions, is 255.
+.PP
+A repetition operator (?, *, +, or bounds) cannot follow another
+repetition operator.
+A repetition operator cannot begin an expression or subexpression
+or follow `^' or `|'.
+.PP
+`|' cannot appear first or last in a (sub)expression or after another `|',
+i.e. an operand of `|' cannot be an empty subexpression.
+An empty parenthesized subexpression, `()', is legal and matches an
+empty (sub)string.
+An empty string is not a legal RE.
+.PP
+A `{' followed by a digit is considered the beginning of bounds for a
+bounded repetition, which must then follow the syntax for bounds.
+A `{' \fInot\fR followed by a digit is considered an ordinary character.
+.PP
+`^' and `$' beginning and ending subexpressions in obsolete (``basic'')
+REs are anchors, not ordinary characters.
+.SH SEE ALSO
+grep(1), re_format(7)
+.PP
+POSIX 1003.2, sections 2.8 (Regular Expression Notation)
+and
+B.5 (C Binding for Regular Expression Matching).
+.SH DIAGNOSTICS
+Non-zero error codes from
+.I regcomp
+and
+.I regexec
+include the following:
+.PP
+.nf
+.ta \w'REG_ECOLLATE'u+3n
+REG_NOMATCH regexec() failed to match
+REG_BADPAT invalid regular expression
+REG_ECOLLATE invalid collating element
+REG_ECTYPE invalid character class
+REG_EESCAPE \e applied to unescapable character
+REG_ESUBREG invalid backreference number
+REG_EBRACK brackets [ ] not balanced
+REG_EPAREN parentheses ( ) not balanced
+REG_EBRACE braces { } not balanced
+REG_BADBR invalid repetition count(s) in { }
+REG_ERANGE invalid character range in [ ]
+REG_ESPACE ran out of memory
+REG_BADRPT ?, *, or + operand invalid
+REG_EMPTY empty (sub)expression
+REG_ASSERT ``can't happen''\(emyou found a bug
+REG_INVARG invalid argument, e.g. negative-length string
+.fi
+.SH HISTORY
+Originally written by Henry Spencer.
+Altered for inclusion in the 4.4BSD distribution.
+.SH BUGS
+This is an alpha release with known defects.
+Please report problems.
+.PP
+There is one known functionality bug.
+The implementation of internationalization is incomplete:
+the locale is always assumed to be the default one of 1003.2,
+and only the collating elements etc. of that locale are available.
+.PP
+The back-reference code is subtle and doubts linger about its correctness
+in complex cases.
+.PP
+.I Regexec
+performance is poor.
+This will improve with later releases.
+.I Nmatch
+exceeding 0 is expensive;
+.I nmatch
+exceeding 1 is worse.
+.I Regexec
+is largely insensitive to RE complexity \fIexcept\fR that back
+references are massively expensive.
+RE length does matter; in particular, there is a strong speed bonus
+for keeping RE length under about 30 characters,
+with most special characters counting roughly double.
+.PP
+.I Regcomp
+implements bounded repetitions by macro expansion,
+which is costly in time and space if counts are large
+or bounded repetitions are nested.
+An RE like, say,
+`((((a{1,100}){1,100}){1,100}){1,100}){1,100}'
+will (eventually) run almost any existing machine out of swap space.
+.PP
+There are suspected problems with response to obscure error conditions.
+Notably,
+certain kinds of internal overflow,
+produced only by truly enormous REs or by multiply nested bounded repetitions,
+are probably not handled well.
+.PP
+Due to a mistake in 1003.2, things like `a)b' are legal REs because `)' is
+a special character only in the presence of a previous unmatched `('.
+This can't be fixed until the spec is fixed.
+.PP
+The standard's definition of back references is vague.
+For example, does
+`a\e(\e(b\e)*\e2\e)*d' match `abbbd'?
+Until the standard is clarified,
+behavior in such cases should not be relied on.
+.PP
+The implementation of word-boundary matching is a bit of a kludge,
+and bugs may lurk in combinations of word-boundary matching and anchoring.
--- /dev/null
+/*-
+ * Copyright (c) 1992 Henry Spencer.
+ * Copyright (c) 1992, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer of the University of Toronto.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)regex.h 8.2 (Berkeley) 1/3/94
+ */
+
+#ifndef _REGEX_H_
+#define _REGEX_H_
+
+#include
+
+/* types */
+typedef off_t regoff_t;
+
+typedef struct {
+ int re_magic;
+ size_t re_nsub; /* number of parenthesized subexpressions */
+ __const char *re_endp; /* end pointer for REG_PEND */
+ struct re_guts *re_g; /* none of your business :-) */
+} regex_t;
+
+typedef struct {
+ regoff_t rm_so; /* start of match */
+ regoff_t rm_eo; /* end of match */
+} regmatch_t;
+
+/* regcomp() flags */
+#define REG_BASIC 0000
+#define REG_EXTENDED 0001
+#define REG_ICASE 0002
+#define REG_NOSUB 0004
+#define REG_NEWLINE 0010
+#define REG_NOSPEC 0020
+#define REG_PEND 0040
+#define REG_DUMP 0200
+
+/* regerror() flags */
+#define REG_NOMATCH 1
+#define REG_BADPAT 2
+#define REG_ECOLLATE 3
+#define REG_ECTYPE 4
+#define REG_EESCAPE 5
+#define REG_ESUBREG 6
+#define REG_EBRACK 7
+#define REG_EPAREN 8
+#define REG_EBRACE 9
+#define REG_BADBR 10
+#define REG_ERANGE 11
+#define REG_ESPACE 12
+#define REG_BADRPT 13
+#define REG_EMPTY 14
+#define REG_ASSERT 15
+#define REG_INVARG 16
+#define REG_ATOI 255 /* convert name to number (!) */
+#define REG_ITOA 0400 /* convert number to name (!) */
+
+/* regexec() flags */
+#define REG_NOTBOL 00001
+#define REG_NOTEOL 00002
+#define REG_STARTEND 00004
+#define REG_TRACE 00400 /* tracing of execution */
+#define REG_LARGE 01000 /* force large representation */
+#define REG_BACKR 02000 /* force use of backref code */
+
+__BEGIN_DECLS
+int regcomp __P((regex_t *, const char *, int));
+size_t regerror __P((int, const regex_t *, char *, size_t));
+int regexec __P((const regex_t *,
+ const char *, size_t, regmatch_t [], int));
+void regfree __P((regex_t *));
+__END_DECLS
+
+#endif /* !_REGEX_H_ */
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)regex2.h 8.4 (Berkeley) 3/20/94
+ */
+
+/*
+ * First, the stuff that ends up in the outside-world include file
+*/
+/*
+ typedef off_t regoff_t;
+ typedef struct {
+ int re_magic;
+ size_t re_nsub; // number of parenthesized subexpressions
+ const char *re_endp; // end pointer for REG_PEND
+ struct re_guts *re_g; // none of your business :-)
+ } regex_t;
+ typedef struct {
+ regoff_t rm_so; // start of match
+ regoff_t rm_eo; // end of match
+ } regmatch_t;
+*/
+/*
+ * internals of regex_t
+ */
+#define MAGIC1 ((('r'^0200)<<8) | 'e')
+
+/*
+ * The internal representation is a *strip*, a sequence of
+ * operators ending with an endmarker. (Some terminology etc. is a
+ * historical relic of earlier versions which used multiple strips.)
+ * Certain oddities in the representation are there to permit running
+ * the machinery backwards; in particular, any deviation from sequential
+ * flow must be marked at both its source and its destination. Some
+ * fine points:
+ *
+ * - OPLUS_ and O_PLUS are *inside* the loop they create.
+ * - OQUEST_ and O_QUEST are *outside* the bypass they create.
+ * - OCH_ and O_CH are *outside* the multi-way branch they create, while
+ * OOR1 and OOR2 are respectively the end and the beginning of one of
+ * the branches. Note that there is an implicit OOR2 following OCH_
+ * and an implicit OOR1 preceding O_CH.
+ *
+ * In state representations, an operator's bit is on to signify a state
+ * immediately *preceding* "execution" of that operator.
+ */
+typedef unsigned long sop; /* strip operator */
+typedef long sopno;
+#define OPRMASK 0xf8000000
+#define OPDMASK 0x07ffffff
+#define OPSHIFT ((unsigned)27)
+#define OP(n) ((n)&OPRMASK)
+#define OPND(n) ((n)&OPDMASK)
+#define SOP(op, opnd) ((op)|(opnd))
+/* operators meaning operand */
+/* (back, fwd are offsets) */
+#define OEND (1<
+#define OCHAR (2<
+#define OBOL (3<
+#define OEOL (4<
+#define OANY (5<
+#define OANYOF (6<
+#define OBACK_ (7<
+#define O_BACK (8<
+#define OPLUS_ (9<
+#define O_PLUS (10<
+#define OQUEST_ (11<
+#define O_QUEST (12<
+#define OLPAREN (13<
+#define ORPAREN (14<
+#define OCH_ (15<
+#define OOR1 (16<
+#define OOR2 (17<
+#define O_CH (18<
+#define OBOW (19<
+#define OEOW (20<
+
+/*
+ * Structure for [] character-set representation. Character sets are
+ * done as bit vectors, grouped 8 to a byte vector for compactness.
+ * The individual set therefore has both a pointer to the byte vector
+ * and a mask to pick out the relevant bit of each byte. A hash code
+ * simplifies testing whether two sets could be identical.
+ *
+ * This will get trickier for multicharacter collating elements. As
+ * preliminary hooks for dealing with such things, we also carry along
+ * a string of multi-character elements, and decide the size of the
+ * vectors at run time.
+ */
+typedef struct {
+ uch *ptr; /* -> uch [csetsize] */
+ uch mask; /* bit within array */
+ uch hash; /* hash code */
+ size_t smultis;
+ char *multis; /* -> char[smulti] ab\0cd\0ef\0\0 */
+} cset;
+/* note that CHadd and CHsub are unsafe, and CHIN doesn't yield 0/1 */
+#define CHadd(cs, c) ((cs)->ptr[(uch)(c)] |= (cs)->mask, (cs)->hash += (c))
+#define CHsub(cs, c) ((cs)->ptr[(uch)(c)] &= ~(cs)->mask, (cs)->hash -= (c))
+#define CHIN(cs, c) ((cs)->ptr[(uch)(c)] & (cs)->mask)
+#define MCadd(p, cs, cp) mcadd(p, cs, cp) /* regcomp() internal fns */
+#define MCsub(p, cs, cp) mcsub(p, cs, cp)
+#define MCin(p, cs, cp) mcin(p, cs, cp)
+
+/* stuff for character categories */
+typedef unsigned char cat_t;
+
+/*
+ * main compiled-expression structure
+ */
+struct re_guts {
+ int magic;
+# define MAGIC2 ((('R'^0200)<<8)|'E')
+ sop *strip; /* malloced area for strip */
+ int csetsize; /* number of bits in a cset vector */
+ int ncsets; /* number of csets in use */
+ cset *sets; /* -> cset [ncsets] */
+ uch *setbits; /* -> uch[csetsize][ncsets/CHAR_BIT] */
+ int cflags; /* copy of regcomp() cflags argument */
+ sopno nstates; /* = number of sops */
+ sopno firststate; /* the initial OEND (normally 0) */
+ sopno laststate; /* the final OEND */
+ int iflags; /* internal flags */
+# define USEBOL 01 /* used ^ */
+# define USEEOL 02 /* used $ */
+# define BAD 04 /* something wrong */
+ int nbol; /* number of ^ used */
+ int neol; /* number of $ used */
+ int ncategories; /* how many character categories */
+ cat_t *categories; /* ->catspace[-CHAR_MIN] */
+ char *must; /* match must contain this string */
+ int mlen; /* length of must */
+ size_t nsub; /* copy of re_nsub */
+ int backrefs; /* does it use back references? */
+ sopno nplus; /* how deep does it nest +s? */
+ /* catspace must be last */
+ cat_t catspace[1]; /* actually [NC] */
+};
+
+/* misc utilities */
+#define OUT (CHAR_MAX+1) /* a non-character value */
+#define ISWORD(c) (isalnum(c) || (c) == '_')
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)regexec.c 8.3 (Berkeley) 3/20/94
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)regexec.c 8.3 (Berkeley) 3/20/94";
+#endif /* LIBC_SCCS and not lint */
+
+/*
+ * the outer shell of regexec()
+ *
+ * This file includes engine.c *twice*, after muchos fiddling with the
+ * macros that code uses. This lets the same code operate on two different
+ * representations for state sets.
+ */
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "utils.h"
+#include "regex2.h"
+
+static int nope = 0; /* for use in asserts; shuts lint up */
+
+/* macros for manipulating states, small version */
+#define states long
+#define states1 states /* for later use in regexec() decision */
+#define CLEAR(v) ((v) = 0)
+#define SET0(v, n) ((v) &= ~(1 << (n)))
+#define SET1(v, n) ((v) |= 1 << (n))
+#define ISSET(v, n) ((v) & (1 << (n)))
+#define ASSIGN(d, s) ((d) = (s))
+#define EQ(a, b) ((a) == (b))
+#define STATEVARS int dummy /* dummy version */
+#define STATESETUP(m, n) /* nothing */
+#define STATETEARDOWN(m) /* nothing */
+#define SETUP(v) ((v) = 0)
+#define onestate int
+#define INIT(o, n) ((o) = (unsigned)1 << (n))
+#define INC(o) ((o) <<= 1)
+#define ISSTATEIN(v, o) ((v) & (o))
+/* some abbreviations; note that some of these know variable names! */
+/* do "if I'm here, I can also be there" etc without branches */
+#define FWD(dst, src, n) ((dst) |= ((unsigned)(src)&(here)) << (n))
+#define BACK(dst, src, n) ((dst) |= ((unsigned)(src)&(here)) >> (n))
+#define ISSETBACK(v, n) ((v) & ((unsigned)here >> (n)))
+/* function names */
+#define SNAMES /* engine.c looks after details */
+
+#include "engine.c"
+
+/* now undo things */
+#undef states
+#undef CLEAR
+#undef SET0
+#undef SET1
+#undef ISSET
+#undef ASSIGN
+#undef EQ
+#undef STATEVARS
+#undef STATESETUP
+#undef STATETEARDOWN
+#undef SETUP
+#undef onestate
+#undef INIT
+#undef INC
+#undef ISSTATEIN
+#undef FWD
+#undef BACK
+#undef ISSETBACK
+#undef SNAMES
+
+/* macros for manipulating states, large version */
+#define states char *
+#define CLEAR(v) memset(v, 0, m->g->nstates)
+#define SET0(v, n) ((v)[n] = 0)
+#define SET1(v, n) ((v)[n] = 1)
+#define ISSET(v, n) ((v)[n])
+#define ASSIGN(d, s) memcpy(d, s, m->g->nstates)
+#define EQ(a, b) (memcmp(a, b, m->g->nstates) == 0)
+#define STATEVARS int vn; char *space
+#define STATESETUP(m, nv) { (m)->space = malloc((nv)*(m)->g->nstates); \
+ if ((m)->space == NULL) return(REG_ESPACE); \
+ (m)->vn = 0; }
+#define STATETEARDOWN(m) { free((m)->space); }
+#define SETUP(v) ((v) = &m->space[m->vn++ * m->g->nstates])
+#define onestate int
+#define INIT(o, n) ((o) = (n))
+#define INC(o) ((o)++)
+#define ISSTATEIN(v, o) ((v)[o])
+/* some abbreviations; note that some of these know variable names! */
+/* do "if I'm here, I can also be there" etc without branches */
+#define FWD(dst, src, n) ((dst)[here+(n)] |= (src)[here])
+#define BACK(dst, src, n) ((dst)[here-(n)] |= (src)[here])
+#define ISSETBACK(v, n) ((v)[here - (n)])
+/* function names */
+#define LNAMES /* flag */
+
+#include "engine.c"
+
+/*
+ - regexec - interface for matching
+ = extern int regexec(const regex_t *, const char *, size_t, \
+ = regmatch_t [], int);
+ = #define REG_NOTBOL 00001
+ = #define REG_NOTEOL 00002
+ = #define REG_STARTEND 00004
+ = #define REG_TRACE 00400 // tracing of execution
+ = #define REG_LARGE 01000 // force large representation
+ = #define REG_BACKR 02000 // force use of backref code
+ *
+ * We put this here so we can exploit knowledge of the state representation
+ * when choosing which matcher to call. Also, by this point the matchers
+ * have been prototyped.
+ */
+int /* 0 success, REG_NOMATCH failure */
+regexec(preg, string, nmatch, pmatch, eflags)
+const regex_t *preg;
+const char *string;
+size_t nmatch;
+regmatch_t pmatch[];
+int eflags;
+{
+ register struct re_guts *g = preg->re_g;
+#ifdef REDEBUG
+# define GOODFLAGS(f) (f)
+#else
+# define GOODFLAGS(f) ((f)&(REG_NOTBOL|REG_NOTEOL|REG_STARTEND))
+#endif
+
+ if (preg->re_magic != MAGIC1 || g->magic != MAGIC2)
+ return(REG_BADPAT);
+ assert(!(g->iflags&BAD));
+ if (g->iflags&BAD) /* backstop for no-debug case */
+ return(REG_BADPAT);
+ eflags = GOODFLAGS(eflags);
+
+ if (g->nstates <= CHAR_BIT*sizeof(states1) && !(eflags®_LARGE))
+ return(smatcher(g, (char *)string, nmatch, pmatch, eflags));
+ else
+ return(lmatcher(g, (char *)string, nmatch, pmatch, eflags));
+}
--- /dev/null
+/*
+ * Copyright (c) 1986 by University of Toronto.
+ * Copyright (c) 1989, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley
+ * by Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)regexp.h 8.1 (Berkeley) 6/2/93
+ */
+
+#ifndef _REGEXP_H_
+#define _REGEXP_H_
+
+/*
+ * Definitions etc. for regexp(3) routines.
+ *
+ * Caveat: this is V8 regexp(3) [actually, a reimplementation thereof],
+ * not the System V one.
+ */
+#define NSUBEXP 10
+typedef struct regexp {
+ char *startp[NSUBEXP];
+ char *endp[NSUBEXP];
+ char regstart; /* Internal use only. */
+ char reganch; /* Internal use only. */
+ char *regmust; /* Internal use only. */
+ int regmlen; /* Internal use only. */
+ char program[1]; /* Unwarranted chumminess with compiler. */
+} regexp;
+
+#include
+
+__BEGIN_DECLS
+regexp *regcomp __P((const char *));
+int regexec __P((const regexp *, const char *));
+void regsub __P((const regexp *, const char *, char *));
+void regerror __P((const char *));
+__END_DECLS
+
+#endif /* !_REGEXP_H_ */
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)regfree.c 8.3 (Berkeley) 3/20/94
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)regfree.c 8.3 (Berkeley) 3/20/94";
+#endif /* LIBC_SCCS and not lint */
+
+#include
+#include
+#include
+#include
+
+#include "utils.h"
+#include "regex2.h"
+
+/*
+ - regfree - free everything
+ = extern void regfree(regex_t *);
+ */
+void
+regfree(preg)
+regex_t *preg;
+{
+ register struct re_guts *g;
+
+ if (preg->re_magic != MAGIC1) /* oops */
+ return; /* nice to complain, but hard */
+
+ g = preg->re_g;
+ if (g == NULL || g->magic != MAGIC2) /* oops again */
+ return;
+ preg->re_magic = 0; /* mark it invalid */
+ g->magic = 0; /* mark it invalid */
+
+ if (g->strip != NULL)
+ free((char *)g->strip);
+ if (g->sets != NULL)
+ free((char *)g->sets);
+ if (g->setbits != NULL)
+ free((char *)g->setbits);
+ if (g->must != NULL)
+ free(g->must);
+ free((char *)g);
+}
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)utils.h 8.3 (Berkeley) 3/20/94
+ */
+
+/* utility definitions */
+#define DUPMAX 100000000 /* xxx is this right? */
+#define INFINITY (DUPMAX + 1)
+#define NC (CHAR_MAX - CHAR_MIN + 1)
+typedef unsigned char uch;
+
+/* switch off assertions (if not already off) if no REDEBUG */
+#ifndef REDEBUG
+#ifndef NDEBUG
+#define NDEBUG /* no assertions please */
+#endif
+#endif
+
+/* for old systems with bcopy() but no memmove() */
+#ifdef USEBCOPY
+#define memmove(d, s, c) bcopy(s, d, c)
+#endif
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * rusagestub.h--
+ * Stubs for getrusage(3).
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: rusagestub.h,v 1.1.1.1 1996/07/09 06:21:46 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef RUSAGESTUB_H
+#define RUSAGESTUB_H
+
+#include /* for struct timeval */
+#include /* for CLK_TCK */
+
+#define RUSAGE_SELF 0
+#define RUSAGE_CHILDREN -1
+
+struct rusage {
+ struct timeval ru_utime; /* user time used */
+ struct timeval ru_stime; /* system time used */
+};
+
+extern int getrusage(int who, struct rusage *rusage);
+
+#endif /* RUSAGESTUB_H */
--- /dev/null
+/*
+ * Copyright (c) 1991, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Berkeley Software Design, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)cdefs.h 8.7 (Berkeley) 1/21/94
+ */
+
+#ifndef _CDEFS_H_
+#define _CDEFS_H_
+
+#if defined(__cplusplus)
+#define __BEGIN_DECLS extern "C" {
+#define __END_DECLS };
+#else
+#define __BEGIN_DECLS
+#define __END_DECLS
+#endif
+
+/*
+ * The __CONCAT macro is used to concatenate parts of symbol names, e.g.
+ * with "#define OLD(foo) __CONCAT(old,foo)", OLD(foo) produces oldfoo.
+ * The __CONCAT macro is a bit tricky -- make sure you don't put spaces
+ * in between its arguments. __CONCAT can also concatenate double-quoted
+ * strings produced by the __STRING macro, but this only works with ANSI C.
+ */
+#if defined(__STDC__) || defined(__cplusplus)
+#define __P(protos) protos /* full-blown ANSI C */
+#define __CONCAT(x,y) x ## y
+#define __STRING(x) #x
+
+#define __const const /* define reserved names to standard */
+#define __signed signed
+#define __volatile volatile
+#if defined(__cplusplus)
+#define __inline inline /* convert to C++ keyword */
+#else
+#ifndef __GNUC__
+#define __inline /* delete GCC keyword */
+#endif /* !__GNUC__ */
+#endif /* !__cplusplus */
+
+#else /* !(__STDC__ || __cplusplus) */
+#define __P(protos) () /* traditional C preprocessor */
+#define __CONCAT(x,y) x/**/y
+#define __STRING(x) "x"
+
+#ifndef __GNUC__
+#define __const /* delete pseudo-ANSI C keywords */
+#define __inline
+#define __signed
+#define __volatile
+/*
+ * In non-ANSI C environments, new programs will want ANSI-only C keywords
+ * deleted from the program and old programs will want them left alone.
+ * When using a compiler other than gcc, programs using the ANSI C keywords
+ * const, inline etc. as normal identifiers should define -DNO_ANSI_KEYWORDS.
+ * When using "gcc -traditional", we assume that this is the intent; if
+ * __GNUC__ is defined but __STDC__ is not, we leave the new keywords alone.
+ */
+#ifndef NO_ANSI_KEYWORDS
+#define const /* delete ANSI C keywords */
+#define inline
+#define signed
+#define volatile
+#endif
+#endif /* !__GNUC__ */
+#endif /* !(__STDC__ || __cplusplus) */
+
+/*
+ * GCC1 and some versions of GCC2 declare dead (non-returning) and
+ * pure (no side effects) functions using "volatile" and "const";
+ * unfortunately, these then cause warnings under "-ansi -pedantic".
+ * GCC2 uses a new, peculiar __attribute__((attrs)) style. All of
+ * these work for GNU C++ (modulo a slight glitch in the C++ grammar
+ * in the distribution version of 2.5.5).
+ */
+#if !defined(__GNUC__) || __GNUC__ < 2 || __GNUC_MINOR__ < 5
+#define __attribute__(x) /* delete __attribute__ if non-gcc or gcc1 */
+#if defined(__GNUC__) && !defined(__STRICT_ANSI__)
+#define __dead __volatile
+#define __pure __const
+#endif
+#endif
+
+/* Delete pseudo-keywords wherever they are not available or needed. */
+#ifndef __dead
+#define __dead
+#define __pure
+#endif
+
+typedef long off_t;
+
+#endif /* !_CDEFS_H_ */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for the postmaster module
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/postmaster/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:49 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+VPATH:= $(VPATH):$(CURDIR)/postmaster
+
+SRCS_POSTMASTER= postmaster.c
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * postmaster.c--
+ * This program acts as a clearing house for requests to the
+ * POSTGRES system. Frontend programs send a startup message
+ * to the Postmaster and the postmaster uses the info in the
+ * message to setup a backend process.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.1.1.1 1996/07/09 06:21:49 scrappy Exp $
+ *
+ * NOTES
+ *
+ * Initialization:
+ * The Postmaster sets up a few shared memory data structures
+ * for the backends. It should at the very least initialize the
+ * lock manager.
+ *
+ * Synchronization:
+ * The Postmaster shares memory with the backends and will have to lock
+ * the shared memory it accesses. The Postmaster should never block
+ * on messages from clients.
+ *
+ * Garbage Collection:
+ * The Postmaster cleans up after backends if they have an emergency
+ * exit and/or core dump.
+ *
+ * Communication:
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "libpq/pqsignal.h" /* substitute for */
+#include
+#include
+#ifndef WIN32
+#include
+#endif /* WIN32 */
+#include
+#include /* for fd_set stuff */
+#include /* for umask */
+#include
+#include /* for MAXHOSTNAMELEN on most */
+#ifdef WIN32
+#include
+#include
+#define MAXINT INT_MAX
+#else
+#include /* for MAXHOSTNAMELEN on some */
+# if defined(PORTNAME_BSD44_derived) || defined(PORTNAME_bsdi)
+# include
+# define MAXINT INT_MAX
+# else
+# include
+# endif /* !PORTNAME_BSD44_derived */
+#include
+#endif /* WIN32 */
+#include
+#include
+#include
+
+#if defined(PORTNAME_aix)
+#include
+#endif /* PORTNAME_aix */
+
+#include "storage/ipc.h"
+#include "libpq/libpq.h"
+#include "libpq/auth.h"
+#include "libpq/pqcomm.h"
+#include "miscadmin.h"
+#include "lib/dllist.h"
+#include "utils/mcxt.h"
+#include "storage/proc.h"
+#include "utils/elog.h"
+
+#ifdef DBX_VERSION
+#define FORK() (0)
+#else
+#if defined(PORTNAME_irix5)
+/* IRIX 5 does not have vfork() */
+#define FORK() fork()
+#else
+#define FORK() vfork()
+#endif
+#endif
+
+/*
+ * Info for garbage collection. Whenever a process dies, the Postmaster
+ * cleans up after it. Currently, NO information is required for cleanup,
+ * but I left this structure around in case that changed.
+ */
+typedef struct bkend {
+ int pid; /* process id of backend */
+} Backend;
+
+/* list of active backends. For garbage collection only now. */
+
+static Dllist* BackendList;
+
+/* list of ports associated with still open, but incomplete connections */
+static Dllist* PortList;
+
+static short PostPortName = -1;
+static short ActiveBackends = FALSE;
+static int NextBackendId = MAXINT; /* XXX why? */
+static char *progname = (char *) NULL;
+
+char *DataDir = (char *) NULL;
+
+/*
+ * Default Values
+ */
+static char Execfile[MAXPATHLEN] = "";
+
+static int ServerSock = INVALID_SOCK; /* stream socket server */
+
+/*
+ * Set by the -o option
+ */
+static char ExtraOptions[ARGV_SIZE] = "";
+
+/*
+ * These globals control the behavior of the postmaster in case some
+ * backend dumps core. Normally, it kills all peers of the dead backend
+ * and reinitializes shared memory. By specifying -s or -n, we can have
+ * the postmaster stop (rather than kill) peers and not reinitialize
+ * shared data structures.
+ */
+static int Reinit = 1;
+static int SendStop = 0;
+
+static int MultiplexedBackends = 0;
+static int MultiplexedBackendPort;
+
+#ifdef HBA
+static int useHostBasedAuth = 1;
+#else
+static int useHostBasedAuth = 0;
+#endif
+
+/*
+ * postmaster.c - function prototypes
+ */
+static void pmdaemonize(void);
+static int ConnStartup(Port *port);
+static int ConnCreate(int serverFd, int *newFdP);
+static void reset_shared(short port);
+#if defined(PORTNAME_linux)
+static void pmdie(int);
+static void reaper(int);
+static void dumpstatus(int);
+#else
+static void pmdie(void);
+static void reaper(void);
+static void dumpstatus();
+#endif
+static void CleanupProc(int pid, int exitstatus);
+static int DoExec(StartupInfo *packet, int portFd);
+static void ExitPostmaster(int status);
+static void usage();
+static void checkDataDir();
+
+int ServerLoop(void);
+int BackendStartup(StartupInfo *packet, Port *port, int *pidPtr);
+
+extern char *optarg;
+extern int optind, opterr;
+
+int
+PostmasterMain(int argc, char *argv[])
+{
+ extern int NBuffers; /* from buffer/bufmgr.c */
+ extern bool IsPostmaster; /* from smgr/mm.c */
+ int opt;
+ char *hostName;
+ int status;
+ int silentflag = 0;
+ char hostbuf[MAXHOSTNAMELEN];
+#ifdef WIN32
+ WSADATA WSAData;
+#endif /* WIN32 */
+
+ progname = argv[0];
+
+ /* for security, no dir or file created can be group or other accessible */
+ (void) umask((mode_t) 0077);
+
+ if (!(hostName = getenv("PGHOST"))) {
+ if (gethostname(hostbuf, MAXHOSTNAMELEN) < 0)
+ (void) strcpy(hostbuf, "localhost");
+ hostName = hostbuf;
+ }
+
+ opterr = 0;
+ while ((opt = getopt(argc, argv, "a:B:b:D:dmM:no:p:Ss")) != EOF) {
+ switch (opt) {
+ case 'a':
+ /* Set the authentication system. */
+ be_setauthsvc(optarg);
+ break;
+ case 'B':
+ /*
+ * The number of buffers to create. Setting this
+ * option means we have to start each backend with
+ * a -B # to make sure they know how many buffers
+ * were allocated.
+ */
+ NBuffers = atol(optarg);
+ (void) strcat(ExtraOptions, " -B ");
+ (void) strcat(ExtraOptions, optarg);
+ break;
+ case 'b':
+ /* Set the backend executable file to use. */
+ if (!ValidateBackend(optarg))
+ strcpy(Execfile, optarg);
+ else {
+ fprintf(stderr, "%s: invalid backend \"%s\"\n",
+ progname, optarg);
+ exit(2);
+ }
+ break;
+ case 'D':
+ /* Set PGDATA from the command line. */
+ DataDir = optarg;
+ break;
+ case 'd':
+ /*
+ * Turn on debugging for the postmaster and the backend
+ * servers descended from it.
+ */
+ if ((optind < argc) && *argv[optind] != '-') {
+ DebugLvl = atoi(argv[optind]);
+ optind++;
+ }
+ else
+ DebugLvl = 1;
+ break;
+ case 'm':
+ MultiplexedBackends = 1;
+ MultiplexedBackendPort = atoi(optarg);
+ break;
+ case 'M':
+ /* ignore this flag. This may be passed in because the
+ program was run as 'postgres -M' instead of 'postmaster' */
+ break;
+ case 'n':
+ /* Don't reinit shared mem after abnormal exit */
+ Reinit = 0;
+ break;
+ case 'o':
+ /*
+ * Other options to pass to the backend on the
+ * command line -- useful only for debugging.
+ */
+ (void) strcat(ExtraOptions, " ");
+ (void) strcat(ExtraOptions, optarg);
+ break;
+ case 'p':
+ /* Set PGPORT by hand. */
+ PostPortName = (short) atoi(optarg);
+ break;
+ case 'S':
+ /*
+ * Start in 'S'ilent mode (disassociate from controlling tty).
+ * You may also think of this as 'S'ysV mode since it's most
+ * badly needed on SysV-derived systems like SVR4 and HP-UX.
+ */
+ silentflag = 1;
+ break;
+ case 's':
+ /*
+ * In the event that some backend dumps core,
+ * send SIGSTOP, rather than SIGUSR1, to all
+ * its peers. This lets the wily post_hacker
+ * collect core dumps from everyone.
+ */
+ SendStop = 1;
+ break;
+ default:
+ /* usage() never returns */
+ usage(progname);
+ break;
+ }
+ }
+ if (PostPortName == -1)
+ PostPortName = pq_getport();
+
+ IsPostmaster = true;
+
+ if (!DataDir)
+ DataDir = GetPGData();
+
+ /*
+ * check whether the data directory exists. Passing this test doesn't
+ * gaurantee we are accessing the right data base but is a first barrier
+ * to site administrators who starts up the postmaster without realizing
+ * it cannot access the data base.
+ */
+ checkDataDir();
+
+ if (!Execfile[0] && FindBackend(Execfile, argv[0]) < 0) {
+ fprintf(stderr, "%s: could not find backend to execute...\n",
+ argv[0]);
+ exit(1);
+ }
+
+
+#ifdef WIN32
+ if ((status = WSAStartup(MAKEWORD(1,1), &WSAData)) == 0)
+ (void) printf("%s\nInitializing WinSock: %s\n", WSAData.szDescription, WSAData.szSystemStatus);
+ else
+ {
+ fprintf(stderr, "Error initializing WinSock: %d is the err", status);
+ exit(1);
+ }
+ _nt_init();
+ _nt_attach();
+#endif /* WIN32 */
+
+ status = StreamServerPort(hostName, PostPortName, &ServerSock);
+ if (status != STATUS_OK) {
+ fprintf(stderr, "%s: cannot create stream port\n",
+ progname);
+ exit(1);
+ }
+
+ /* set up shared memory and semaphores */
+ EnableMemoryContext(TRUE);
+ reset_shared(PostPortName);
+
+ /*
+ * Initialize the list of active backends. This list is only
+ * used for garbage collecting the backend processes.
+ */
+ BackendList = DLNewList();
+ PortList = DLNewList();
+
+ if (silentflag)
+ pmdaemonize();
+
+ signal(SIGINT, pmdie);
+#ifndef WIN32
+ signal(SIGCHLD, reaper);
+ signal(SIGTTIN, SIG_IGN);
+ signal(SIGTTOU, SIG_IGN);
+ signal(SIGHUP, pmdie);
+ signal(SIGTERM, pmdie);
+ signal(SIGCONT, dumpstatus);
+#endif /* WIN32 */
+
+
+ status = ServerLoop();
+
+ ExitPostmaster(status != STATUS_OK);
+ return 0; /* not reached */
+}
+
+static void
+pmdaemonize()
+{
+ int i;
+
+ if (fork())
+ exit(0);
+
+ if (setsid() < 0) {
+ fprintf(stderr, "%s: ", progname);
+ perror("cannot disassociate from controlling TTY");
+ exit(1);
+ }
+ i = open(NULL_DEV, O_RDWR);
+ (void) dup2(i, 0);
+ (void) dup2(i, 1);
+ (void) dup2(i, 2);
+ (void) close(i);
+}
+
+static void
+usage(char *progname)
+{
+ fprintf(stderr, "usage: %s [options..]\n", progname);
+ fprintf(stderr, "\t-a authsys\tdo/do not permit use of an authentication system\n");
+ fprintf(stderr, "\t-B nbufs\tset number of shared buffers\n");
+ fprintf(stderr, "\t-b backend\tuse a specific backend server executable\n");
+ fprintf(stderr, "\t-d [1|2|3]\tset debugging level\n");
+ fprintf(stderr, "\t-D datadir\tset data directory\n");
+ fprintf(stderr, "\t-m \tstart up multiplexing backends\n");
+ fprintf(stderr, "\t-n\t\tdon't reinitialize shared memory after abnormal exit\n");
+ fprintf(stderr, "\t-o option\tpass 'option' to each backend servers\n");
+ fprintf(stderr, "\t-p port\t\tspecify port for postmaster to listen on\n");
+ fprintf(stderr, "\t-S\t\tsilent mode (disassociate from tty)\n");
+ fprintf(stderr, "\t-s\t\tsend SIGSTOP to all backend servers if one dies\n");
+ exit(1);
+}
+
+int
+ServerLoop()
+{
+ int serverFd = ServerSock;
+ fd_set rmask, basemask;
+ int nSockets, nSelected, status, newFd;
+ Dlelem *prev, *curr;
+/* int orgsigmask = sigblock(0); */
+ sigset_t oldsigmask, newsigmask;
+
+ nSockets = ServerSock + 1;
+ FD_ZERO(&basemask);
+ FD_SET(ServerSock, &basemask);
+
+ sigprocmask(0,0,&oldsigmask);
+ sigemptyset(&newsigmask);
+ sigaddset(&newsigmask,SIGCHLD);
+ for (;;) {
+/* sigsetmask(orgsigmask); */
+ sigprocmask(SIG_SETMASK,&oldsigmask,0);
+ newFd = -1;
+ memmove((char *) &rmask, (char *) &basemask, sizeof(fd_set));
+ if ((nSelected = select(nSockets, &rmask,
+ (fd_set *) NULL,
+ (fd_set *) NULL,
+ (struct timeval *) NULL)) < 0) {
+ if (errno == EINTR)
+ continue;
+ fprintf(stderr, "%s: ServerLoop: select failed\n",
+ progname);
+ return(STATUS_ERROR);
+ /* [TRH]
+ * To avoid race conditions, block SIGCHLD signals while we are
+ * handling the request. (both reaper() and ConnCreate()
+ * manipulate the BackEnd list, and reaper() calls free() which is
+ * usually non-reentrant.)
+ */
+ sigprocmask(SIG_BLOCK, &newsigmask, &oldsigmask);
+/* sigblock(sigmask(SIGCHLD)); */ /* XXX[TRH] portability */
+
+ }
+ if (DebugLvl > 1) {
+ fprintf(stderr, "%s: ServerLoop: %d sockets pending\n",
+ progname, nSelected);
+ }
+
+ /* new connection pending on our well-known port's socket */
+ if (FD_ISSET(ServerSock, &rmask)) {
+ /*
+ * connect and make an addition to PortList. If
+ * the connection dies and we notice it, just forget
+ * about the whole thing.
+ */
+ if (ConnCreate(serverFd, &newFd) == STATUS_OK) {
+ if (newFd >= nSockets)
+ nSockets = newFd + 1;
+ FD_SET(newFd, &rmask);
+ FD_SET(newFd, &basemask);
+ if (DebugLvl)
+ fprintf(stderr, "%s: ServerLoop: connect on %d\n",
+ progname, newFd);
+ }
+ --nSelected;
+ FD_CLR(ServerSock, &rmask);
+ }
+
+ if (DebugLvl > 1) {
+ fprintf(stderr, "%s: ServerLoop:\tnSelected=%d\n",
+ progname, nSelected);
+ curr = DLGetHead(PortList);
+ while (curr) {
+ Port *port = DLE_VAL(curr);
+
+ fprintf(stderr, "%s: ServerLoop:\t\tport %d%s pending\n",
+ progname, port->sock,
+ FD_ISSET(port->sock, &rmask)
+ ? "" :
+ " not");
+ curr = DLGetSucc(curr);
+ }
+ }
+
+ curr = DLGetHead(PortList);
+
+ while (curr) {
+ Port *port = (Port*)DLE_VAL(curr);
+ int lastbytes = port->nBytes;
+
+ if (FD_ISSET(port->sock, &rmask) && port->sock != newFd) {
+ if (DebugLvl > 1)
+ fprintf(stderr, "%s: ServerLoop:\t\thandling %d\n",
+ progname, port->sock);
+ --nSelected;
+
+ /*
+ * Read the incoming packet into its packet buffer.
+ * Read the connection id out of the packet so we
+ * know who the packet is from.
+ */
+ status = PacketReceive(port, &port->buf, NON_BLOCKING);
+ switch (status) {
+ case STATUS_OK:
+ ConnStartup(port);
+ ActiveBackends = TRUE;
+ /*FALLTHROUGH*/
+ case STATUS_INVALID:
+ if (DebugLvl)
+ fprintf(stderr, "%s: ServerLoop:\t\tdone with %d\n",
+ progname, port->sock);
+ break;
+ case STATUS_BAD_PACKET:
+ /*
+ * This is a bogus client, kill the connection
+ * and forget the whole thing.
+ */
+ if (DebugLvl)
+ fprintf(stderr, "%s: ServerLoop:\t\tbad packet format (reported packet size of %d read on port %d\n", progname, port->nBytes, port->sock);
+ break;
+ case STATUS_NOT_DONE:
+ if (DebugLvl)
+ fprintf(stderr, "%s: ServerLoop:\t\tpartial packet (%d bytes actually read) on %d\n",
+ progname, port->nBytes, port->sock);
+ /*
+ * If we've received at least a PacketHdr's worth of data
+ * and we're still receiving data each time we read, we're
+ * ok. If the client gives us less than a PacketHdr at
+ * the beginning, just kill the connection and forget
+ * about the whole thing.
+ */
+ if (lastbytes < port->nBytes) {
+ if (DebugLvl)
+ fprintf(stderr, "%s: ServerLoop:\t\tpartial packet on %d ok\n",
+ progname, port->sock);
+ curr = DLGetSucc(curr);
+ continue;
+ }
+ break;
+ case STATUS_ERROR: /* system call error - die */
+ fprintf(stderr, "%s: ServerLoop:\t\terror receiving packet\n",
+ progname);
+ return(STATUS_ERROR);
+ }
+ FD_CLR(port->sock, &basemask);
+ StreamClose(port->sock);
+ prev = DLGetPred(curr);
+ DLRemove(curr);
+ DLFreeElem(curr);
+ curr = 0;
+ }
+ curr = DLGetSucc(curr);
+ }
+ Assert(nSelected == 0);
+ }
+}
+
+static int
+ConnStartup(Port *port) /* receiving port */
+{
+ MsgType msgType;
+ char namebuf[NAMEDATALEN + 1];
+/* StartupInfo *sp;*/
+ int pid;
+ PacketBuf *p;
+/* sp = PacketBuf2StartupInfo(&port->buf);*/
+ StartupInfo sp;
+ char *tmp;
+
+ p = &port->buf;
+
+ sp.database[0]='\0';
+ sp.user[0]='\0';
+ sp.options[0]='\0';
+ sp.execFile[0]='\0';
+ sp.tty[0]='\0';
+
+ tmp= p->data;
+ strncpy(sp.database,tmp,sizeof(sp.database));
+ tmp += sizeof(sp.database);
+ strncpy(sp.user,tmp, sizeof(sp.user));
+ tmp += sizeof(sp.user);
+ strncpy(sp.options,tmp, sizeof(sp.options));
+ tmp += sizeof(sp.options);
+ strncpy(sp.execFile,tmp, sizeof(sp.execFile));
+ tmp += sizeof(sp.execFile);
+ strncpy(sp.tty,tmp, sizeof(sp.tty));
+
+ msgType = ntohl(port->buf.msgtype);
+
+ (void) strncpy(namebuf, sp.user, NAMEDATALEN);
+ namebuf[NAMEDATALEN] = '\0';
+ if (!namebuf[0]) {
+ fprintf(stderr, "%s: ConnStartup: no user name specified\n",
+ progname);
+ return(STATUS_ERROR);
+ }
+
+ if (msgType == STARTUP_MSG && useHostBasedAuth)
+ msgType = STARTUP_HBA_MSG;
+ if (be_recvauth(msgType, port, namebuf,&sp) != STATUS_OK) {
+ fprintf(stderr, "%s: ConnStartup: authentication failed\n",
+ progname);
+ return(STATUS_ERROR);
+ }
+
+ if (BackendStartup(&sp, port, &pid) != STATUS_OK) {
+ fprintf(stderr, "%s: ConnStartup: couldn't start backend\n",
+ progname);
+ return(STATUS_ERROR);
+ }
+
+ return(STATUS_OK);
+}
+
+/*
+ * ConnCreate -- create a local connection data structure
+ */
+static int
+ConnCreate(int serverFd, int *newFdP)
+{
+ int status;
+ Port *port;
+
+
+ if (!(port = (Port *) calloc(1, sizeof(Port)))) {
+ fprintf(stderr, "%s: ConnCreate: malloc failed\n",
+ progname);
+ ExitPostmaster(1);
+ }
+
+ if ((status = StreamConnection(serverFd, port)) != STATUS_OK) {
+ StreamClose(port->sock);
+ free(port);
+ }
+ else {
+ DLAddHead(PortList, DLNewElem(port));
+ *newFdP = port->sock;
+ }
+
+ return (status);
+}
+
+/*
+ * reset_shared -- reset shared memory and semaphores
+ */
+static void
+reset_shared(short port)
+{
+ IPCKey key;
+
+ key = SystemPortAddressCreateIPCKey((SystemPortAddress) port);
+ CreateSharedMemoryAndSemaphores(key);
+ ActiveBackends = FALSE;
+}
+
+/*
+ * pmdie -- signal handler for cleaning up after a kill signal.
+ */
+static void
+#if defined(PORTNAME_linux)
+pmdie(int i)
+#else
+pmdie()
+#endif
+{
+ exitpg(0);
+}
+
+/*
+ * Reaper -- signal handler to cleanup after a backend (child) dies.
+ */
+static void
+#if defined(PORTNAME_linux)
+reaper(int i)
+#else
+reaper()
+#endif
+{
+ int status; /* backend exit status */
+ int pid; /* process id of dead backend */
+
+ if (DebugLvl)
+ fprintf(stderr, "%s: reaping dead processes...\n",
+ progname);
+#ifndef WIN32
+ while((pid = waitpid(-1, &status, WNOHANG)) > 0)
+ CleanupProc(pid, status);
+#endif /* WIN32 */
+}
+
+/*
+ * CleanupProc -- cleanup after terminated backend.
+ *
+ * Remove all local state associated with backend.
+ *
+ * Dillon's note: should log child's exit status in the system log.
+ */
+static void
+CleanupProc(int pid,
+ int exitstatus) /* child's exit status. */
+{
+ Dlelem *prev, *curr;
+ Backend *bp;
+ int sig;
+
+ if (DebugLvl) {
+ fprintf(stderr, "%s: CleanupProc: pid %d exited with status %d\n",
+ progname, pid, exitstatus);
+ }
+ /*
+ * -------------------------
+ * If a backend dies in an ugly way (i.e. exit status not 0) then
+ * we must signal all other backends to quickdie. If exit status
+ * is zero we assume everything is hunky dory and simply remove the
+ * backend from the active backend list.
+ * -------------------------
+ */
+ if (!exitstatus) {
+ curr = DLGetHead(BackendList);
+ while (curr) {
+ bp = (Backend*)DLE_VAL(curr);
+ if (bp->pid == pid) {
+ DLRemove(curr);
+ DLFreeElem(curr);
+ break;
+ }
+ curr = DLGetSucc(curr);
+ }
+
+ ProcRemove(pid);
+
+ return;
+ }
+
+ curr = DLGetHead(BackendList);
+ while (curr) {
+ bp = (Backend*)DLE_VAL(curr);
+
+ /*
+ * -----------------
+ * SIGUSR1 is the special signal that sez exit without exitpg
+ * and let the user know what's going on. ProcSemaphoreKill()
+ * cleans up the backends semaphore. If SendStop is set (-s on
+ * the command line), then we send a SIGSTOP so that we can
+ * collect core dumps from all backends by hand.
+ * -----------------
+ */
+#ifndef WIN32
+ sig = (SendStop) ? SIGSTOP : SIGUSR1;
+ if (bp->pid != pid) {
+ if (DebugLvl)
+ fprintf(stderr, "%s: CleanupProc: sending %s to process %d\n",
+ progname,
+ (sig == SIGUSR1)
+ ? "SIGUSR1" : "SIGSTOP",
+ bp->pid);
+ (void) kill(bp->pid, sig);
+ }
+#endif /* WIN32 */
+ ProcRemove(bp->pid);
+
+ prev = DLGetPred(curr);
+ DLRemove(curr);
+ DLFreeElem(curr);
+ if (!prev) { /* removed head */
+ curr = DLGetHead(BackendList);
+ continue;
+ }
+ curr = DLGetSucc(curr);
+ }
+ /*
+ * -------------
+ * Quasi_exit means run all of the on_exitpg routines but don't
+ * acutally call exit(). The on_exit list of routines to do is
+ * also truncated.
+ *
+ * Nothing up my sleeve here, ActiveBackends means that since the
+ * last time we recreated shared memory and sems another frontend
+ * has requested and received a connection and I have forked off
+ * another backend. This prevents me from reinitializing shared
+ * stuff more than once for the set of backends that caused the
+ * failure and were killed off.
+ * ----------------
+ */
+ if (ActiveBackends == TRUE && Reinit) {
+ if (DebugLvl)
+ fprintf(stderr, "%s: CleanupProc: reinitializing shared memory and semaphores\n",
+ progname);
+ quasi_exitpg();
+ reset_shared(PostPortName);
+ }
+}
+
+/*
+ * BackendStartup -- start backend process
+ *
+ * returns: STATUS_ERROR if the fork/exec failed, STATUS_OK
+ * otherwise.
+ *
+ */
+int
+BackendStartup(StartupInfo *packet, /* client's startup packet */
+ Port *port,
+ int *pidPtr)
+{
+ Backend* bn; /* for backend cleanup */
+ int pid, i;
+ static char envEntry[4][2 * ARGV_SIZE];
+
+ for (i = 0; i < 4; ++i) {
+ memset(envEntry[i], 2*ARGV_SIZE,0);
+ }
+ /*
+ * Set up the necessary environment variables for the backend
+ * This should really be some sort of message....
+ */
+ sprintf(envEntry[0], "POSTPORT=%d", PostPortName);
+ putenv(envEntry[0]);
+ sprintf(envEntry[1], "POSTID=%d", NextBackendId);
+ putenv(envEntry[1]);
+ sprintf(envEntry[2], "PG_USER=%s", packet->user);
+ putenv(envEntry[2]);
+ if (!getenv("PGDATA")) {
+ sprintf(envEntry[3], "PGDATA=%s", DataDir);
+ putenv(envEntry[3]);
+ }
+ if (DebugLvl > 2) {
+ char **p;
+ extern char **environ;
+
+ fprintf(stderr, "%s: BackendStartup: environ dump:\n",
+ progname);
+ fprintf(stderr, "-----------------------------------------\n");
+ for (p = environ; *p; ++p)
+ fprintf(stderr, "\t%s\n", *p);
+ fprintf(stderr, "-----------------------------------------\n");
+ }
+
+#ifndef WIN32
+ if ((pid = FORK()) == 0) { /* child */
+ if (DoExec(packet, port->sock))
+ fprintf(stderr, "%s child[%d]: BackendStartup: execv failed\n",
+ progname, pid);
+ /* use _exit to keep from double-flushing stdio */
+ _exit(1);
+ }
+
+ /* in parent */
+ if (pid < 0) {
+ fprintf(stderr, "%s: BackendStartup: fork failed\n",
+ progname);
+ return(STATUS_ERROR);
+ }
+#else
+ pid = DoExec(packet, port->sock);
+ if (pid == FALSE) {
+ fprintf(stderr, "%s: BackendStartup: CreateProcess failed\n",
+ progname);
+ return(STATUS_ERROR);
+ }
+#endif /* WIN32 */
+
+ if (DebugLvl)
+ fprintf(stderr, "%s: BackendStartup: pid %d user %s db %s socket %d\n",
+ progname, pid, packet->user,
+ (packet->database[0] == '\0' ? packet->user : packet->database),
+ port->sock);
+
+ /* adjust backend counter */
+ /* XXX Don't know why this is done, but for now backend needs it */
+ NextBackendId -= 1;
+
+ /*
+ * Everything's been successful, it's safe to add this backend to our
+ * list of backends.
+ */
+ if (!(bn = (Backend *) calloc(1, sizeof (Backend)))) {
+ fprintf(stderr, "%s: BackendStartup: malloc failed\n",
+ progname);
+ ExitPostmaster(1);
+ }
+
+ bn->pid = pid;
+ DLAddHead(BackendList,DLNewElem(bn));
+
+ if (MultiplexedBackends)
+ MultiplexedBackendPort++;
+
+ *pidPtr = pid;
+
+ return(STATUS_OK);
+}
+
+/*
+ * split_opts -- destructively load a string into an argv array
+ *
+ * Since no current POSTGRES arguments require any quoting characters,
+ * we can use the simple-minded tactic of assuming each set of space-
+ * delimited characters is a separate argv element.
+ *
+ * If you don't like that, well, we *used* to pass the whole option string
+ * as ONE argument to execl(), which was even less intelligent...
+ */
+void
+split_opts(char **argv, int *argcp, char *s)
+{
+ int i = *argcp;
+
+ while (s && *s) {
+ while (isspace(*s))
+ ++s;
+ if (*s)
+ argv[i++] = s;
+ while (*s && !isspace(*s))
+ ++s;
+ if (isspace(*s))
+ *s++ = '\0';
+ }
+ *argcp = i;
+}
+
+/*
+ * DoExec -- set up the argument list and perform an execv system call
+ *
+ * Tries fairly hard not to dork with anything that isn't automatically
+ * allocated so we don't do anything weird to the postmaster when it gets
+ * its thread back. (This is vfork() we're talking about. If we're using
+ * fork() because we don't have vfork(), then we don't really care.)
+ *
+ * returns:
+ * Shouldn't return at all.
+ * If execv() fails, return status.
+ */
+static int
+DoExec(StartupInfo *packet, int portFd)
+{
+ char execbuf[MAXPATHLEN];
+ char portbuf[ARGV_SIZE];
+ char mbbuf[ARGV_SIZE];
+ char debugbuf[ARGV_SIZE];
+ char ttybuf[ARGV_SIZE + 1];
+ char argbuf[(2 * ARGV_SIZE) + 1];
+ /*
+ * each argument takes at least three chars, so we can't
+ * have more than ARGV_SIZE arguments in (2 * ARGV_SIZE)
+ * chars (i.e., packet->options plus ExtraOptions)...
+ */
+ char *av[ARGV_SIZE];
+ char dbbuf[ARGV_SIZE + 1];
+ int ac = 0;
+ int i;
+#ifdef WIN32
+ char win32_args[(2 * ARGV_SIZE) + 1];
+ PROCESS_INFORMATION piProcInfo;
+ STARTUPINFO siStartInfo;
+ BOOL fSuccess;
+#endif /* WIN32 */
+
+ (void) strncpy(execbuf, Execfile, MAXPATHLEN);
+ execbuf[MAXPATHLEN - 1] = '\0';
+ av[ac++] = execbuf;
+
+ /* Tell the backend it is being called from the postmaster */
+ av[ac++] = "-p";
+
+ /*
+ * Pass the requested debugging level along to the backend. We
+ * decrement by one; level one debugging in the postmaster traces
+ * postmaster connection activity, and levels two and higher
+ * are passed along to the backend. This allows us to watch only
+ * the postmaster or the postmaster and the backend.
+ */
+
+ if (DebugLvl > 1) {
+ (void) sprintf(debugbuf, "-d%d", DebugLvl - 1);
+ av[ac++] = debugbuf;
+ }
+ else
+ av[ac++] = "-Q";
+
+ /* Pass the requested debugging output file */
+ if (packet->tty[0]) {
+ (void) strncpy(ttybuf, packet->tty, ARGV_SIZE);
+ av[ac++] = "-o";
+#ifdef WIN32
+ /* BIG HACK - The front end is passing "/dev/null" here which
+ ** causes new backends to fail. So, as a very special case,
+ ** use a real NT filename.
+ */
+ av[ac++] = "CON";
+#else
+ av[ac++] = ttybuf;
+#endif /* WIN32 */
+
+ }
+
+ /* tell the multiplexed backend to start on a certain port */
+ if (MultiplexedBackends) {
+ sprintf(mbbuf, "-m %d", MultiplexedBackendPort);
+ av[ac++] = mbbuf;
+ }
+ /* Tell the backend the descriptor of the fe/be socket */
+ (void) sprintf(portbuf, "-P%d", portFd);
+ av[ac++] = portbuf;
+
+ (void) strncpy(argbuf, packet->options, ARGV_SIZE);
+ argbuf[ARGV_SIZE] = '\0';
+ (void) strncat(argbuf, ExtraOptions, ARGV_SIZE);
+ argbuf[(2 * ARGV_SIZE) + 1] = '\0';
+ split_opts(av, &ac, argbuf);
+
+ if (packet->database[0])
+ (void) strncpy(dbbuf, packet->database, ARGV_SIZE);
+ else
+ (void) strncpy(dbbuf, packet->user, NAMEDATALEN);
+ dbbuf[ARGV_SIZE] = '\0';
+ av[ac++] = dbbuf;
+
+ av[ac] = (char *) NULL;
+
+ if (DebugLvl > 1) {
+ fprintf(stderr, "%s child[%d]: execv(",
+ progname, getpid());
+ for (i = 0; i < ac; ++i)
+ fprintf(stderr, "%s, ", av[i]);
+ fprintf(stderr, ")\n");
+ }
+
+#ifndef WIN32
+ return(execv(av[0], av));
+#else
+
+ /* Copy all the arguments into one char array */
+ win32_args[0] = '\0';
+ for (i = 0; i < ac; i++)
+ {
+ strcat(win32_args, av[i]);
+ strcat(win32_args, " ");
+ }
+
+ siStartInfo.cb = sizeof(STARTUPINFO);
+ siStartInfo.lpReserved = NULL;
+ siStartInfo.lpDesktop = NULL;
+ siStartInfo.lpTitle = NULL;
+ siStartInfo.lpReserved2 = NULL;
+ siStartInfo.cbReserved2 = 0;
+ siStartInfo.dwFlags = 0;
+
+
+ fSuccess = CreateProcess(progname, win32_args, NULL, NULL,
+ TRUE, 0, NULL, NULL, &siStartInfo, &piProcInfo);
+ if (fSuccess)
+ {
+ /* The parent process doesn't need the handles */
+ CloseHandle(piProcInfo.hThread);
+ CloseHandle(piProcInfo.hProcess);
+ return (piProcInfo.dwProcessId);
+ }
+ else
+ return (FALSE);
+#endif /* WIN32 */
+}
+
+/*
+ * ExitPostmaster -- cleanup
+ */
+static void
+ExitPostmaster(int status)
+{
+ /* should cleanup shared memory and kill all backends */
+
+ /*
+ * Not sure of the semantics here. When the Postmaster dies,
+ * should the backends all be killed? probably not.
+ */
+ if (ServerSock != INVALID_SOCK)
+ close(ServerSock);
+ exitpg(status);
+}
+
+static void
+#if defined(PORTNAME_linux)
+dumpstatus(int i)
+#else
+dumpstatus()
+#endif
+{
+ Dlelem *curr = DLGetHead(PortList);
+
+ while (curr) {
+ Port *port = DLE_VAL(curr);
+
+ fprintf(stderr, "%s: dumpstatus:\n", progname);
+ fprintf(stderr, "\tsock %d: nBytes=%d, laddr=0x%x, raddr=0x%x\n",
+ port->sock, port->nBytes,
+ port->laddr,
+ port->raddr);
+ curr = DLGetSucc(curr);
+ }
+}
+
+static void
+checkDataDir()
+{
+ char path[MAXPATHLEN];
+ FILE *fp;
+
+ sprintf(path, "%s%cbase%ctemplate1%cpg_class", DataDir, SEP_CHAR, SEP_CHAR,
+ SEP_CHAR);
+ if ((fp=fopen(path, "r")) == NULL) {
+ fprintf(stderr, "%s: data base not found in directory \"%s\"\n",
+ progname, DataDir);
+ exit(2);
+ }
+ fclose(fp);
+
+#ifndef WIN32
+ if (!ValidPgVersion(DataDir)) {
+ fprintf(stderr, "%s: data base in \"%s\" is of a different version.\n",
+ progname, DataDir);
+ exit(2);
+ }
+#endif /* WIN32 */
+}
+
+
--- /dev/null
+Copyright 1992, 1993, 1994 Henry Spencer. All rights reserved.
+This software is not subject to any license of the American Telephone
+and Telegraph Company or of the Regents of the University of California.
+
+Permission is granted to anyone to use this software for any purpose on
+any computer system, and to alter it and redistribute it, subject
+to the following restrictions:
+
+1. The author is not responsible for the consequences of use of this
+ software, no matter how awful, even if they arise from flaws in it.
+
+2. The origin of this software must not be misrepresented, either by
+ explicit claim or by omission. Since few users ever read sources,
+ credits must appear in the documentation.
+
+3. Altered versions must be plainly marked as such, and must not be
+ misrepresented as being the original software. Since few users
+ ever read sources, credits must appear in the documentation.
+
+4. This notice may not be removed or altered.
+
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+/*-
+ * Copyright (c) 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)COPYRIGHT 8.1 (Berkeley) 3/16/94
+ */
--- /dev/null
+# @(#)Makefile.inc 8.1 (Berkeley) 6/4/93
+
+# regex sources
+VPATH:=$(VPATH):$(CURDIR)/regex
+
+CFLAGS+=-DPOSIX_MISTAKE -I$(CURDIR)/regex
+
+SRCS_REGEX= regcomp.c regerror.c regexec.c regfree.c
+
+MAN3+= regex.0
+MAN7+= re_format.0
+
+MLINKS+=regex.3 regcomp.3 regex.3 regexec.3 regex.3 regerror.3
+MLINKS+=regexec.3 regfree.3
--- /dev/null
+# @(#)WHATSNEW 8.3 (Berkeley) 3/18/94
+
+New in alpha3.4: The complex bug alluded to below has been fixed (in a
+slightly kludgey temporary way that may hurt efficiency a bit; this is
+another "get it out the door for 4.4" release). The tests at the end of
+the tests file have accordingly been uncommented. The primary sign of
+the bug was that something like a?b matching ab matched b rather than ab.
+(The bug was essentially specific to this exact situation, else it would
+have shown up earlier.)
+
+New in alpha3.3: The definition of word boundaries has been altered
+slightly, to more closely match the usual programming notion that "_"
+is an alphabetic. Stuff used for pre-ANSI systems is now in a subdir,
+and the makefile no longer alludes to it in mysterious ways. The
+makefile has generally been cleaned up some. Fixes have been made
+(again!) so that the regression test will run without -DREDEBUG, at
+the cost of weaker checking. A workaround for a bug in some folks'
+
has been added. And some more things have been added to+tests, including a couple right at the end which are commented out
+because the code currently flunks them (complex bug; fix coming).
+Plus the usual minor cleanup.
+
+New in alpha3.2: Assorted bits of cleanup and portability improvement
+(the development base is now a BSDI system using GCC instead of an ancient
+Sun system, and the newer compiler exposed some glitches). Fix for a
+serious bug that affected REs using many [] (including REG_ICASE REs
+because of the way they are implemented), *sometimes*, depending on
+memory-allocation patterns. The header-file prototypes no longer name
+the parameters, avoiding possible name conflicts. The possibility that
+some clot has defined CHAR_MIN as (say) `-128' instead of `(-128)' is
+now handled gracefully. "uchar" is no longer used as an internal type
+name (too many people have the same idea). Still the same old lousy
+performance, alas.
+
+New in alpha3.1: Basically nothing, this release is just a bookkeeping
+convenience. Stay tuned.
+
+New in alpha3.0: Performance is no better, alas, but some fixes have been
+made and some functionality has been added. (This is basically the "get
+it out the door in time for 4.4" release.) One bug fix: regfree() didn't
+free the main internal structure (how embarrassing). It is now possible
+to put NULs in either the RE or the target string, using (resp.) a new
+REG_PEND flag and the old REG_STARTEND flag. The REG_NOSPEC flag to
+regcomp() makes all characters ordinary, so you can match a literal
+string easily (this will become more useful when performance improves!).
+There are now primitives to match beginnings and ends of words, although
+the syntax is disgusting and so is the implementation. The REG_ATOI
+debugging interface has changed a bit. And there has been considerable
+internal cleanup of various kinds.
+
+New in alpha2.3: Split change list out of README, and moved flags notes
+into Makefile. Macro-ized the name of regex(7) in regex(3), since it has
+to change for 4.4BSD. Cleanup work in engine.c, and some new regression
+tests to catch tricky cases thereof.
+
+New in alpha2.2: Out-of-date manpages updated. Regerror() acquires two
+small extensions -- REG_ITOA and REG_ATOI -- which avoid debugging kludges
+in my own test program and might be useful to others for similar purposes.
+The regression test will now compile (and run) without REDEBUG. The
+BRE \$ bug is fixed. Most uses of "uchar" are gone; it's all chars now.
+Char/uchar parameters are now written int/unsigned, to avoid possible
+portability problems with unpromoted parameters. Some unsigned casts have
+been introduced to minimize portability problems with shifting into sign
+bits.
+
+New in alpha2.1: Lots of little stuff, cleanup and fixes. The one big
+thing is that regex.h is now generated, using mkh, rather than being
+supplied in the distribution; due to circularities in dependencies,
+you have to build regex.h explicitly by "make h". The two known bugs
+have been fixed (and the regression test now checks for them), as has a
+problem with assertions not being suppressed in the absence of REDEBUG.
+No performance work yet.
+
+New in alpha2: Backslash-anything is an ordinary character, not an
+error (except, of course, for the handful of backslashed metacharacters
+in BREs), which should reduce script breakage. The regression test
+checks *where* null strings are supposed to match, and has generally
+been tightened up somewhat. Small bug fixes in parameter passing (not
+harmful, but technically errors) and some other areas. Debugging
+invoked by defining REDEBUG rather than not defining NDEBUG.
+
+New in alpha+3: full prototyping for internal routines, using a little
+helper program, mkh, which extracts prototypes given in stylized comments.
+More minor cleanup. Buglet fix: it's CHAR_BIT, not CHAR_BITS. Simple
+pre-screening of input when a literal string is known to be part of the
+RE; this does wonders for performance.
+
+New in alpha+2: minor bits of cleanup. Notably, the number "32" for the
+word width isn't hardwired into regexec.c any more, the public header
+file prototypes the functions if __STDC__ is defined, and some small typos
+in the manpages have been fixed.
+
+New in alpha+1: improvements to the manual pages, and an important
+extension, the REG_STARTEND option to regexec().
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)cclass.h 8.3 (Berkeley) 3/20/94
+ */
+
+/* character-class table */
+static struct cclass {
+ char *name;
+ char *chars;
+ char *multis;
+} cclasses[] = {
+ {"alnum", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
+0123456789", ""},
+ {"alpha", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+ ""},
+ {"blank", " \t", ""},
+ {"cntrl", "\007\b\t\n\v\f\r\1\2\3\4\5\6\16\17\20\21\22\23\24\
+\25\26\27\30\31\32\33\34\35\36\37\177", ""},
+ {"digit", "0123456789", ""},
+ {"graph", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
+0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
+ ""},
+ {"lower", "abcdefghijklmnopqrstuvwxyz",
+ ""},
+ {"print", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
+0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ",
+ ""},
+ {"punct", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
+ ""},
+ {"space", "\t\n\v\f\r ", ""},
+ {"upper", "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+ ""},
+ {"xdigit", "0123456789ABCDEFabcdef",
+ ""},
+ {NULL, 0, ""}
+};
--- /dev/null
+/*
+ * ++Copyright++ 1991, 1993
+ * -
+ * Copyright (c) 1991, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * -
+ * Portions Copyright (c) 1993 by Digital Equipment Corporation.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies, and that
+ * the name of Digital Equipment Corporation not be used in advertising or
+ * publicity pertaining to distribution of the document or software without
+ * specific, written prior permission.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
+ * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ * -
+ * --Copyright--
+ */
+
+/*
+ * @(#)cdefs.h 8.1 (Berkeley) 6/2/93
+ * $Id: cdefs.h,v 1.1.1.1 1996/07/09 06:21:49 scrappy Exp $
+ */
+
+#ifndef _CDEFS_H_
+#define _CDEFS_H_
+
+#if defined(__cplusplus)
+#define __BEGIN_DECLS extern "C" {
+#define __END_DECLS };
+#else
+#define __BEGIN_DECLS
+#define __END_DECLS
+#endif
+
+/*
+ * The __CONCAT macro is used to concatenate parts of symbol names, e.g.
+ * with "#define OLD(foo) __CONCAT(old,foo)", OLD(foo) produces oldfoo.
+ * The __CONCAT macro is a bit tricky -- make sure you don't put spaces
+ * in between its arguments. __CONCAT can also concatenate double-quoted
+ * strings produced by the __STRING macro, but this only works with ANSI C.
+ */
+#if defined(__STDC__) || defined(__cplusplus)
+#define __P(protos) protos /* full-blown ANSI C */
+#define __CONCAT(x,y) x ## y
+#define __STRING(x) #x
+
+#define __const const /* define reserved names to standard */
+#define __signed signed
+#define __volatile volatile
+#if defined(__cplusplus)
+#define __inline inline /* convert to C++ keyword */
+#else
+#ifndef __GNUC__
+#define __inline /* delete GCC keyword */
+#endif /* !__GNUC__ */
+#endif /* !__cplusplus */
+
+#else /* !(__STDC__ || __cplusplus) */
+#define __P(protos) () /* traditional C preprocessor */
+#define __CONCAT(x,y) x/**/y
+#define __STRING(x) "x"
+
+#ifndef __GNUC__
+#define __const /* delete pseudo-ANSI C keywords */
+#define __inline
+#define __signed
+#define __volatile
+/*
+ * In non-ANSI C environments, new programs will want ANSI-only C keywords
+ * deleted from the program and old programs will want them left alone.
+ * When using a compiler other than gcc, programs using the ANSI C keywords
+ * const, inline etc. as normal identifiers should define -DNO_ANSI_KEYWORDS.
+ * When using "gcc -traditional", we assume that this is the intent; if
+ * __GNUC__ is defined but __STDC__ is not, we leave the new keywords alone.
+ */
+#ifndef NO_ANSI_KEYWORDS
+#define const /* delete ANSI C keywords */
+#define inline
+#define signed
+#define volatile
+#endif
+#endif /* !__GNUC__ */
+#endif /* !(__STDC__ || __cplusplus) */
+
+/*
+ * GCC1 and some versions of GCC2 declare dead (non-returning) and
+ * pure (no side effects) functions using "volatile" and "const";
+ * unfortunately, these then cause warnings under "-ansi -pedantic".
+ * GCC2 uses a new, peculiar __attribute__((attrs)) style. All of
+ * these work for GNU C++ (modulo a slight glitch in the C++ grammar
+ * in the distribution version of 2.5.5).
+ */
+#if !defined(__GNUC__) || __GNUC__ < 2 || __GNUC_MINOR__ < 5
+#define __attribute__(x) /* delete __attribute__ if non-gcc or gcc1 */
+#if defined(__GNUC__) && !defined(__STRICT_ANSI__)
+#define __dead __volatile
+#define __pure __const
+#endif
+#endif
+
+/* Delete pseudo-keywords wherever they are not available or needed. */
+#ifndef __dead
+#define __dead
+#define __pure
+#endif
+
+#endif /* !_CDEFS_H_ */
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)cname.h 8.3 (Berkeley) 3/20/94
+ */
+
+/* character-name table */
+static struct cname {
+ char *name;
+ char code;
+} cnames[] = {
+ {"NUL", '\0'},
+ {"SOH", '\001'},
+ {"STX", '\002'},
+ {"ETX", '\003'},
+ {"EOT", '\004'},
+ {"ENQ", '\005'},
+ {"ACK", '\006'},
+ {"BEL", '\007'},
+ {"alert", '\007'},
+ {"BS", '\010'},
+ {"backspace", '\b'},
+ {"HT", '\011'},
+ {"tab", '\t'},
+ {"LF", '\012'},
+ {"newline", '\n'},
+ {"VT", '\013'},
+ {"vertical-tab", '\v'},
+ {"FF", '\014'},
+ {"form-feed", '\f'},
+ {"CR", '\015'},
+ {"carriage-return", '\r'},
+ {"SO", '\016'},
+ {"SI", '\017'},
+ {"DLE", '\020'},
+ {"DC1", '\021'},
+ {"DC2", '\022'},
+ {"DC3", '\023'},
+ {"DC4", '\024'},
+ {"NAK", '\025'},
+ {"SYN", '\026'},
+ {"ETB", '\027'},
+ {"CAN", '\030'},
+ {"EM", '\031'},
+ {"SUB", '\032'},
+ {"ESC", '\033'},
+ {"IS4", '\034'},
+ {"FS", '\034'},
+ {"IS3", '\035'},
+ {"GS", '\035'},
+ {"IS2", '\036'},
+ {"RS", '\036'},
+ {"IS1", '\037'},
+ {"US", '\037'},
+ {"space", ' '},
+ {"exclamation-mark", '!'},
+ {"quotation-mark", '"'},
+ {"number-sign", '#'},
+ {"dollar-sign", '$'},
+ {"percent-sign", '%'},
+ {"ampersand", '&'},
+ {"apostrophe", '\''},
+ {"left-parenthesis", '('},
+ {"right-parenthesis", ')'},
+ {"asterisk", '*'},
+ {"plus-sign", '+'},
+ {"comma", ','},
+ {"hyphen", '-'},
+ {"hyphen-minus", '-'},
+ {"period", '.'},
+ {"full-stop", '.'},
+ {"slash", '/'},
+ {"solidus", '/'},
+ {"zero", '0'},
+ {"one", '1'},
+ {"two", '2'},
+ {"three", '3'},
+ {"four", '4'},
+ {"five", '5'},
+ {"six", '6'},
+ {"seven", '7'},
+ {"eight", '8'},
+ {"nine", '9'},
+ {"colon", ':'},
+ {"semicolon", ';'},
+ {"less-than-sign", '<'},
+ {"equals-sign", '='},
+ {"greater-than-sign", '>'},
+ {"question-mark", '?'},
+ {"commercial-at", '@'},
+ {"left-square-bracket", '['},
+ {"backslash", '\\'},
+ {"reverse-solidus", '\\'},
+ {"right-square-bracket", ']'},
+ {"circumflex", '^'},
+ {"circumflex-accent", '^'},
+ {"underscore", '_'},
+ {"low-line", '_'},
+ {"grave-accent", '`'},
+ {"left-brace", '{'},
+ {"left-curly-bracket", '{'},
+ {"vertical-line", '|'},
+ {"right-brace", '}'},
+ {"right-curly-bracket", '}'},
+ {"tilde", '~'},
+ {"DEL", '\177'},
+ {NULL, 0}
+};
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)engine.c 8.5 (Berkeley) 3/20/94
+ */
+
+/*
+ * The matching engine and friends. This file is #included by regexec.c
+ * after suitable #defines of a variety of macros used herein, so that
+ * different state representations can be used without duplicating masses
+ * of code.
+ */
+
+#ifdef SNAMES
+#define matcher smatcher
+#define fast sfast
+#define slow sslow
+#define dissect sdissect
+#define backref sbackref
+#define step sstep
+#define print sprint
+#define at sat
+#define match smat
+#endif
+#ifdef LNAMES
+#define matcher lmatcher
+#define fast lfast
+#define slow lslow
+#define dissect ldissect
+#define backref lbackref
+#define step lstep
+#define print lprint
+#define at lat
+#define match lmat
+#endif
+
+/* another structure passed up and down to avoid zillions of parameters */
+struct match {
+ struct re_guts *g;
+ int eflags;
+ regmatch_t *pmatch; /* [nsub+1] (0 element unused) */
+ char *offp; /* offsets work from here */
+ char *beginp; /* start of string -- virtual NUL precedes */
+ char *endp; /* end of string -- virtual NUL here */
+ char *coldp; /* can be no match starting before here */
+ char **lastpos; /* [nplus+1] */
+ STATEVARS;
+ states st; /* current states */
+ states fresh; /* states for a fresh start */
+ states tmp; /* temporary */
+ states empty; /* empty set of states */
+};
+
+/* ========= begin header generated by ./mkh ========= */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* === engine.c === */
+static int matcher __P((struct re_guts *g, char *string, size_t nmatch, regmatch_t pmatch[], int eflags));
+static char *dissect __P((struct match *m, char *start, char *stop, sopno startst, sopno stopst));
+static char *backref __P((struct match *m, char *start, char *stop, sopno startst, sopno stopst, sopno lev));
+static char *fast __P((struct match *m, char *start, char *stop, sopno startst, sopno stopst));
+static char *slow __P((struct match *m, char *start, char *stop, sopno startst, sopno stopst));
+static states step __P((struct re_guts *g, sopno start, sopno stop, states bef, int ch, states aft));
+#define BOL (OUT+1)
+#define EOL (BOL+1)
+#define BOLEOL (BOL+2)
+#define NOTHING (BOL+3)
+#define BOW (BOL+4)
+#define EOW (BOL+5)
+#define CODEMAX (BOL+5) /* highest code used */
+#define NONCHAR(c) ((c) > CHAR_MAX)
+#define NNONCHAR (CODEMAX-CHAR_MAX)
+#ifdef REDEBUG
+static void print __P((struct match *m, char *caption, states st, int ch, FILE *d));
+#endif
+#ifdef REDEBUG
+static void at __P((struct match *m, char *title, char *start, char *stop, sopno startst, sopno stopst));
+#endif
+#ifdef REDEBUG
+static char *pchar __P((int ch));
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+/* ========= end header generated by ./mkh ========= */
+
+#ifdef REDEBUG
+#define SP(t, s, c) print(m, t, s, c, stdout)
+#define AT(t, p1, p2, s1, s2) at(m, t, p1, p2, s1, s2)
+#define NOTE(str) { if (m->eflags®_TRACE) printf("=%s\n", (str)); }
+#else
+#define SP(t, s, c) /* nothing */
+#define AT(t, p1, p2, s1, s2) /* nothing */
+#define NOTE(s) /* nothing */
+#endif
+
+/*
+ - matcher - the actual matching engine
+ == static int matcher(register struct re_guts *g, char *string, \
+ == size_t nmatch, regmatch_t pmatch[], int eflags);
+ */
+static int /* 0 success, REG_NOMATCH failure */
+matcher(g, string, nmatch, pmatch, eflags)
+register struct re_guts *g;
+char *string;
+size_t nmatch;
+regmatch_t pmatch[];
+int eflags;
+{
+ register char *endp;
+ register int i;
+ struct match mv;
+ register struct match *m = &mv;
+ register char *dp;
+ const register sopno gf = g->firststate+1; /* +1 for OEND */
+ const register sopno gl = g->laststate;
+ char *start;
+ char *stop;
+
+ /* simplify the situation where possible */
+ if (g->cflags®_NOSUB)
+ nmatch = 0;
+ if (eflags®_STARTEND) {
+ start = string + pmatch[0].rm_so;
+ stop = string + pmatch[0].rm_eo;
+ } else {
+ start = string;
+ stop = start + strlen(start);
+ }
+ if (stop < start)
+ return(REG_INVARG);
+
+ /* prescreening; this does wonders for this rather slow code */
+ if (g->must != NULL) {
+ for (dp = start; dp < stop; dp++)
+ if (*dp == g->must[0] && stop - dp >= g->mlen &&
+ memcmp(dp, g->must, (size_t)g->mlen) == 0)
+ break;
+ if (dp == stop) /* we didn't find g->must */
+ return(REG_NOMATCH);
+ }
+
+ /* match struct setup */
+ m->g = g;
+ m->eflags = eflags;
+ m->pmatch = NULL;
+ m->lastpos = NULL;
+ m->offp = string;
+ m->beginp = start;
+ m->endp = stop;
+ STATESETUP(m, 4);
+ SETUP(m->st);
+ SETUP(m->fresh);
+ SETUP(m->tmp);
+ SETUP(m->empty);
+ CLEAR(m->empty);
+
+ /* this loop does only one repetition except for backrefs */
+ for (;;) {
+ endp = fast(m, start, stop, gf, gl);
+ if (endp == NULL) { /* a miss */
+ STATETEARDOWN(m);
+ return(REG_NOMATCH);
+ }
+ if (nmatch == 0 && !g->backrefs)
+ break; /* no further info needed */
+
+ /* where? */
+ assert(m->coldp != NULL);
+ for (;;) {
+ NOTE("finding start");
+ endp = slow(m, m->coldp, stop, gf, gl);
+ if (endp != NULL)
+ break;
+ assert(m->coldp < m->endp);
+ m->coldp++;
+ }
+ if (nmatch == 1 && !g->backrefs)
+ break; /* no further info needed */
+
+ /* oh my, he wants the subexpressions... */
+ if (m->pmatch == NULL)
+ m->pmatch = (regmatch_t *)malloc((m->g->nsub + 1) *
+ sizeof(regmatch_t));
+ if (m->pmatch == NULL) {
+ STATETEARDOWN(m);
+ return(REG_ESPACE);
+ }
+ for (i = 1; i <= m->g->nsub; i++)
+ m->pmatch[i].rm_so = m->pmatch[i].rm_eo = -1;
+ if (!g->backrefs && !(m->eflags®_BACKR)) {
+ NOTE("dissecting");
+ dp = dissect(m, m->coldp, endp, gf, gl);
+ } else {
+ if (g->nplus > 0 && m->lastpos == NULL)
+ m->lastpos = (char **)malloc((g->nplus+1) *
+ sizeof(char *));
+ if (g->nplus > 0 && m->lastpos == NULL) {
+ free(m->pmatch);
+ STATETEARDOWN(m);
+ return(REG_ESPACE);
+ }
+ NOTE("backref dissect");
+ dp = backref(m, m->coldp, endp, gf, gl, (sopno)0);
+ }
+ if (dp != NULL)
+ break;
+
+ /* uh-oh... we couldn't find a subexpression-level match */
+ assert(g->backrefs); /* must be back references doing it */
+ assert(g->nplus == 0 || m->lastpos != NULL);
+ for (;;) {
+ if (dp != NULL || endp <= m->coldp)
+ break; /* defeat */
+ NOTE("backoff");
+ endp = slow(m, m->coldp, endp-1, gf, gl);
+ if (endp == NULL)
+ break; /* defeat */
+ /* try it on a shorter possibility */
+#ifndef NDEBUG
+ for (i = 1; i <= m->g->nsub; i++) {
+ assert(m->pmatch[i].rm_so == -1);
+ assert(m->pmatch[i].rm_eo == -1);
+ }
+#endif
+ NOTE("backoff dissect");
+ dp = backref(m, m->coldp, endp, gf, gl, (sopno)0);
+ }
+ assert(dp == NULL || dp == endp);
+ if (dp != NULL) /* found a shorter one */
+ break;
+
+ /* despite initial appearances, there is no match here */
+ NOTE("false alarm");
+ start = m->coldp + 1; /* recycle starting later */
+ assert(start <= stop);
+ }
+
+ /* fill in the details if requested */
+ if (nmatch > 0) {
+ pmatch[0].rm_so = m->coldp - m->offp;
+ pmatch[0].rm_eo = endp - m->offp;
+ }
+ if (nmatch > 1) {
+ assert(m->pmatch != NULL);
+ for (i = 1; i < nmatch; i++)
+ if (i <= m->g->nsub)
+ pmatch[i] = m->pmatch[i];
+ else {
+ pmatch[i].rm_so = -1;
+ pmatch[i].rm_eo = -1;
+ }
+ }
+
+ if (m->pmatch != NULL)
+ free((char *)m->pmatch);
+ if (m->lastpos != NULL)
+ free((char *)m->lastpos);
+ STATETEARDOWN(m);
+ return(0);
+}
+
+/*
+ - dissect - figure out what matched what, no back references
+ == static char *dissect(register struct match *m, char *start, \
+ == char *stop, sopno startst, sopno stopst);
+ */
+static char * /* == stop (success) always */
+dissect(m, start, stop, startst, stopst)
+register struct match *m;
+char *start;
+char *stop;
+sopno startst;
+sopno stopst;
+{
+ register int i;
+ register sopno ss; /* start sop of current subRE */
+ register sopno es; /* end sop of current subRE */
+ register char *sp; /* start of string matched by it */
+ register char *stp; /* string matched by it cannot pass here */
+ register char *rest; /* start of rest of string */
+ register char *tail; /* string unmatched by rest of RE */
+ register sopno ssub; /* start sop of subsubRE */
+ register sopno esub; /* end sop of subsubRE */
+ register char *ssp; /* start of string matched by subsubRE */
+ register char *sep; /* end of string matched by subsubRE */
+ register char *oldssp; /* previous ssp */
+ register char *dp;
+
+ AT("diss", start, stop, startst, stopst);
+ sp = start;
+ for (ss = startst; ss < stopst; ss = es) {
+ /* identify end of subRE */
+ es = ss;
+ switch (OP(m->g->strip[es])) {
+ case OPLUS_:
+ case OQUEST_:
+ es += OPND(m->g->strip[es]);
+ break;
+ case OCH_:
+ while (OP(m->g->strip[es]) != O_CH)
+ es += OPND(m->g->strip[es]);
+ break;
+ }
+ es++;
+
+ /* figure out what it matched */
+ switch (OP(m->g->strip[ss])) {
+ case OEND:
+ assert(nope);
+ break;
+ case OCHAR:
+ sp++;
+ break;
+ case OBOL:
+ case OEOL:
+ case OBOW:
+ case OEOW:
+ break;
+ case OANY:
+ case OANYOF:
+ sp++;
+ break;
+ case OBACK_:
+ case O_BACK:
+ assert(nope);
+ break;
+ /* cases where length of match is hard to find */
+ case OQUEST_:
+ stp = stop;
+ for (;;) {
+ /* how long could this one be? */
+ rest = slow(m, sp, stp, ss, es);
+ assert(rest != NULL); /* it did match */
+ /* could the rest match the rest? */
+ tail = slow(m, rest, stop, es, stopst);
+ if (tail == stop)
+ break; /* yes! */
+ /* no -- try a shorter match for this one */
+ stp = rest - 1;
+ assert(stp >= sp); /* it did work */
+ }
+ ssub = ss + 1;
+ esub = es - 1;
+ /* did innards match? */
+ if (slow(m, sp, rest, ssub, esub) != NULL) {
+ dp = dissect(m, sp, rest, ssub, esub);
+ assert(dp == rest);
+ } else /* no */
+ assert(sp == rest);
+ sp = rest;
+ break;
+ case OPLUS_:
+ stp = stop;
+ for (;;) {
+ /* how long could this one be? */
+ rest = slow(m, sp, stp, ss, es);
+ assert(rest != NULL); /* it did match */
+ /* could the rest match the rest? */
+ tail = slow(m, rest, stop, es, stopst);
+ if (tail == stop)
+ break; /* yes! */
+ /* no -- try a shorter match for this one */
+ stp = rest - 1;
+ assert(stp >= sp); /* it did work */
+ }
+ ssub = ss + 1;
+ esub = es - 1;
+ ssp = sp;
+ oldssp = ssp;
+ for (;;) { /* find last match of innards */
+ sep = slow(m, ssp, rest, ssub, esub);
+ if (sep == NULL || sep == ssp)
+ break; /* failed or matched null */
+ oldssp = ssp; /* on to next try */
+ ssp = sep;
+ }
+ if (sep == NULL) {
+ /* last successful match */
+ sep = ssp;
+ ssp = oldssp;
+ }
+ assert(sep == rest); /* must exhaust substring */
+ assert(slow(m, ssp, sep, ssub, esub) == rest);
+ dp = dissect(m, ssp, sep, ssub, esub);
+ assert(dp == sep);
+ sp = rest;
+ break;
+ case OCH_:
+ stp = stop;
+ for (;;) {
+ /* how long could this one be? */
+ rest = slow(m, sp, stp, ss, es);
+ assert(rest != NULL); /* it did match */
+ /* could the rest match the rest? */
+ tail = slow(m, rest, stop, es, stopst);
+ if (tail == stop)
+ break; /* yes! */
+ /* no -- try a shorter match for this one */
+ stp = rest - 1;
+ assert(stp >= sp); /* it did work */
+ }
+ ssub = ss + 1;
+ esub = ss + OPND(m->g->strip[ss]) - 1;
+ assert(OP(m->g->strip[esub]) == OOR1);
+ for (;;) { /* find first matching branch */
+ if (slow(m, sp, rest, ssub, esub) == rest)
+ break; /* it matched all of it */
+ /* that one missed, try next one */
+ assert(OP(m->g->strip[esub]) == OOR1);
+ esub++;
+ assert(OP(m->g->strip[esub]) == OOR2);
+ ssub = esub + 1;
+ esub += OPND(m->g->strip[esub]);
+ if (OP(m->g->strip[esub]) == OOR2)
+ esub--;
+ else
+ assert(OP(m->g->strip[esub]) == O_CH);
+ }
+ dp = dissect(m, sp, rest, ssub, esub);
+ assert(dp == rest);
+ sp = rest;
+ break;
+ case O_PLUS:
+ case O_QUEST:
+ case OOR1:
+ case OOR2:
+ case O_CH:
+ assert(nope);
+ break;
+ case OLPAREN:
+ i = OPND(m->g->strip[ss]);
+ assert(0 < i && i <= m->g->nsub);
+ m->pmatch[i].rm_so = sp - m->offp;
+ break;
+ case ORPAREN:
+ i = OPND(m->g->strip[ss]);
+ assert(0 < i && i <= m->g->nsub);
+ m->pmatch[i].rm_eo = sp - m->offp;
+ break;
+ default: /* uh oh */
+ assert(nope);
+ break;
+ }
+ }
+
+ assert(sp == stop);
+ return(sp);
+}
+
+/*
+ - backref - figure out what matched what, figuring in back references
+ == static char *backref(register struct match *m, char *start, \
+ == char *stop, sopno startst, sopno stopst, sopno lev);
+ */
+static char * /* == stop (success) or NULL (failure) */
+backref(m, start, stop, startst, stopst, lev)
+register struct match *m;
+char *start;
+char *stop;
+sopno startst;
+sopno stopst;
+sopno lev; /* PLUS nesting level */
+{
+ register int i;
+ register sopno ss; /* start sop of current subRE */
+ register char *sp; /* start of string matched by it */
+ register sopno ssub; /* start sop of subsubRE */
+ register sopno esub; /* end sop of subsubRE */
+ register char *ssp; /* start of string matched by subsubRE */
+ register char *dp;
+ register size_t len;
+ register int hard;
+ register sop s;
+ register regoff_t offsave;
+ register cset *cs;
+
+ AT("back", start, stop, startst, stopst);
+ sp = start;
+
+ /* get as far as we can with easy stuff */
+ hard = 0;
+ for (ss = startst; !hard && ss < stopst; ss++)
+ switch (OP(s = m->g->strip[ss])) {
+ case OCHAR:
+ if (sp == stop || *sp++ != (char)OPND(s))
+ return(NULL);
+ break;
+ case OANY:
+ if (sp == stop)
+ return(NULL);
+ sp++;
+ break;
+ case OANYOF:
+ cs = &m->g->sets[OPND(s)];
+ if (sp == stop || !CHIN(cs, *sp++))
+ return(NULL);
+ break;
+ case OBOL:
+ if ( (sp == m->beginp && !(m->eflags®_NOTBOL)) ||
+ (sp < m->endp && *(sp-1) == '\n' &&
+ (m->g->cflags®_NEWLINE)) )
+ { /* yes */ }
+ else
+ return(NULL);
+ break;
+ case OEOL:
+ if ( (sp == m->endp && !(m->eflags®_NOTEOL)) ||
+ (sp < m->endp && *sp == '\n' &&
+ (m->g->cflags®_NEWLINE)) )
+ { /* yes */ }
+ else
+ return(NULL);
+ break;
+ case OBOW:
+ if (( (sp == m->beginp && !(m->eflags®_NOTBOL)) ||
+ (sp < m->endp && *(sp-1) == '\n' &&
+ (m->g->cflags®_NEWLINE)) ||
+ (sp > m->beginp &&
+ !ISWORD(*(sp-1))) ) &&
+ (sp < m->endp && ISWORD(*sp)) )
+ { /* yes */ }
+ else
+ return(NULL);
+ break;
+ case OEOW:
+ if (( (sp == m->endp && !(m->eflags®_NOTEOL)) ||
+ (sp < m->endp && *sp == '\n' &&
+ (m->g->cflags®_NEWLINE)) ||
+ (sp < m->endp && !ISWORD(*sp)) ) &&
+ (sp > m->beginp && ISWORD(*(sp-1))) )
+ { /* yes */ }
+ else
+ return(NULL);
+ break;
+ case O_QUEST:
+ break;
+ case OOR1: /* matches null but needs to skip */
+ ss++;
+ s = m->g->strip[ss];
+ do {
+ assert(OP(s) == OOR2);
+ ss += OPND(s);
+ } while (OP(s = m->g->strip[ss]) != O_CH);
+ /* note that the ss++ gets us past the O_CH */
+ break;
+ default: /* have to make a choice */
+ hard = 1;
+ break;
+ }
+ if (!hard) { /* that was it! */
+ if (sp != stop)
+ return(NULL);
+ return(sp);
+ }
+ ss--; /* adjust for the for's final increment */
+
+ /* the hard stuff */
+ AT("hard", sp, stop, ss, stopst);
+ s = m->g->strip[ss];
+ switch (OP(s)) {
+ case OBACK_: /* the vilest depths */
+ i = OPND(s);
+ assert(0 < i && i <= m->g->nsub);
+ if (m->pmatch[i].rm_eo == -1)
+ return(NULL);
+ assert(m->pmatch[i].rm_so != -1);
+ len = m->pmatch[i].rm_eo - m->pmatch[i].rm_so;
+ assert(stop - m->beginp >= len);
+ if (sp > stop - len)
+ return(NULL); /* not enough left to match */
+ ssp = m->offp + m->pmatch[i].rm_so;
+ if (memcmp(sp, ssp, len) != 0)
+ return(NULL);
+ while (m->g->strip[ss] != SOP(O_BACK, i))
+ ss++;
+ return(backref(m, sp+len, stop, ss+1, stopst, lev));
+ break;
+ case OQUEST_: /* to null or not */
+ dp = backref(m, sp, stop, ss+1, stopst, lev);
+ if (dp != NULL)
+ return(dp); /* not */
+ return(backref(m, sp, stop, ss+OPND(s)+1, stopst, lev));
+ break;
+ case OPLUS_:
+ assert(m->lastpos != NULL);
+ assert(lev+1 <= m->g->nplus);
+ m->lastpos[lev+1] = sp;
+ return(backref(m, sp, stop, ss+1, stopst, lev+1));
+ break;
+ case O_PLUS:
+ if (sp == m->lastpos[lev]) /* last pass matched null */
+ return(backref(m, sp, stop, ss+1, stopst, lev-1));
+ /* try another pass */
+ m->lastpos[lev] = sp;
+ dp = backref(m, sp, stop, ss-OPND(s)+1, stopst, lev);
+ if (dp == NULL)
+ return(backref(m, sp, stop, ss+1, stopst, lev-1));
+ else
+ return(dp);
+ break;
+ case OCH_: /* find the right one, if any */
+ ssub = ss + 1;
+ esub = ss + OPND(s) - 1;
+ assert(OP(m->g->strip[esub]) == OOR1);
+ for (;;) { /* find first matching branch */
+ dp = backref(m, sp, stop, ssub, esub, lev);
+ if (dp != NULL)
+ return(dp);
+ /* that one missed, try next one */
+ if (OP(m->g->strip[esub]) == O_CH)
+ return(NULL); /* there is none */
+ esub++;
+ assert(OP(m->g->strip[esub]) == OOR2);
+ ssub = esub + 1;
+ esub += OPND(m->g->strip[esub]);
+ if (OP(m->g->strip[esub]) == OOR2)
+ esub--;
+ else
+ assert(OP(m->g->strip[esub]) == O_CH);
+ }
+ break;
+ case OLPAREN: /* must undo assignment if rest fails */
+ i = OPND(s);
+ assert(0 < i && i <= m->g->nsub);
+ offsave = m->pmatch[i].rm_so;
+ m->pmatch[i].rm_so = sp - m->offp;
+ dp = backref(m, sp, stop, ss+1, stopst, lev);
+ if (dp != NULL)
+ return(dp);
+ m->pmatch[i].rm_so = offsave;
+ return(NULL);
+ break;
+ case ORPAREN: /* must undo assignment if rest fails */
+ i = OPND(s);
+ assert(0 < i && i <= m->g->nsub);
+ offsave = m->pmatch[i].rm_eo;
+ m->pmatch[i].rm_eo = sp - m->offp;
+ dp = backref(m, sp, stop, ss+1, stopst, lev);
+ if (dp != NULL)
+ return(dp);
+ m->pmatch[i].rm_eo = offsave;
+ return(NULL);
+ break;
+ default: /* uh oh */
+ assert(nope);
+ break;
+ }
+
+ /* "can't happen" */
+ assert(nope);
+ /* NOTREACHED */
+ return 0;
+}
+
+/*
+ - fast - step through the string at top speed
+ == static char *fast(register struct match *m, char *start, \
+ == char *stop, sopno startst, sopno stopst);
+ */
+static char * /* where tentative match ended, or NULL */
+fast(m, start, stop, startst, stopst)
+register struct match *m;
+char *start;
+char *stop;
+sopno startst;
+sopno stopst;
+{
+ register states st = m->st;
+ register states fresh = m->fresh;
+ register states tmp = m->tmp;
+ register char *p = start;
+ register int c = (start == m->beginp) ? OUT : *(start-1);
+ register int lastc; /* previous c */
+ register int flagch;
+ register int i;
+ register char *coldp; /* last p after which no match was underway */
+
+ CLEAR(st);
+ SET1(st, startst);
+ st = step(m->g, startst, stopst, st, NOTHING, st);
+ ASSIGN(fresh, st);
+ SP("start", st, *p);
+ coldp = NULL;
+ for (;;) {
+ /* next character */
+ lastc = c;
+ c = (p == m->endp) ? OUT : *p;
+ if (EQ(st, fresh))
+ coldp = p;
+
+ /* is there an EOL and/or BOL between lastc and c? */
+ flagch = '\0';
+ i = 0;
+ if ( (lastc == '\n' && m->g->cflags®_NEWLINE) ||
+ (lastc == OUT && !(m->eflags®_NOTBOL)) ) {
+ flagch = BOL;
+ i = m->g->nbol;
+ }
+ if ( (c == '\n' && m->g->cflags®_NEWLINE) ||
+ (c == OUT && !(m->eflags®_NOTEOL)) ) {
+ flagch = (flagch == BOL) ? BOLEOL : EOL;
+ i += m->g->neol;
+ }
+ if (i != 0) {
+ for (; i > 0; i--)
+ st = step(m->g, startst, stopst, st, flagch, st);
+ SP("boleol", st, c);
+ }
+
+ /* how about a word boundary? */
+ if ( (flagch == BOL || (lastc != OUT && !ISWORD(lastc))) &&
+ (c != OUT && ISWORD(c)) ) {
+ flagch = BOW;
+ }
+ if ( (lastc != OUT && ISWORD(lastc)) &&
+ (flagch == EOL || (c != OUT && !ISWORD(c))) ) {
+ flagch = EOW;
+ }
+ if (flagch == BOW || flagch == EOW) {
+ st = step(m->g, startst, stopst, st, flagch, st);
+ SP("boweow", st, c);
+ }
+
+ /* are we done? */
+ if (ISSET(st, stopst) || p == stop)
+ break; /* NOTE BREAK OUT */
+
+ /* no, we must deal with this character */
+ ASSIGN(tmp, st);
+ ASSIGN(st, fresh);
+ assert(c != OUT);
+ st = step(m->g, startst, stopst, tmp, c, st);
+ SP("aft", st, c);
+ assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st));
+ p++;
+ }
+
+ assert(coldp != NULL);
+ m->coldp = coldp;
+ if (ISSET(st, stopst))
+ return(p+1);
+ else
+ return(NULL);
+}
+
+/*
+ - slow - step through the string more deliberately
+ == static char *slow(register struct match *m, char *start, \
+ == char *stop, sopno startst, sopno stopst);
+ */
+static char * /* where it ended */
+slow(m, start, stop, startst, stopst)
+register struct match *m;
+char *start;
+char *stop;
+sopno startst;
+sopno stopst;
+{
+ register states st = m->st;
+ register states empty = m->empty;
+ register states tmp = m->tmp;
+ register char *p = start;
+ register int c = (start == m->beginp) ? OUT : *(start-1);
+ register int lastc; /* previous c */
+ register int flagch;
+ register int i;
+ register char *matchp; /* last p at which a match ended */
+
+ AT("slow", start, stop, startst, stopst);
+ CLEAR(st);
+ SET1(st, startst);
+ SP("sstart", st, *p);
+ st = step(m->g, startst, stopst, st, NOTHING, st);
+ matchp = NULL;
+ for (;;) {
+ /* next character */
+ lastc = c;
+ c = (p == m->endp) ? OUT : *p;
+
+ /* is there an EOL and/or BOL between lastc and c? */
+ flagch = '\0';
+ i = 0;
+ if ( (lastc == '\n' && m->g->cflags®_NEWLINE) ||
+ (lastc == OUT && !(m->eflags®_NOTBOL)) ) {
+ flagch = BOL;
+ i = m->g->nbol;
+ }
+ if ( (c == '\n' && m->g->cflags®_NEWLINE) ||
+ (c == OUT && !(m->eflags®_NOTEOL)) ) {
+ flagch = (flagch == BOL) ? BOLEOL : EOL;
+ i += m->g->neol;
+ }
+ if (i != 0) {
+ for (; i > 0; i--)
+ st = step(m->g, startst, stopst, st, flagch, st);
+ SP("sboleol", st, c);
+ }
+
+ /* how about a word boundary? */
+ if ( (flagch == BOL || (lastc != OUT && !ISWORD(lastc))) &&
+ (c != OUT && ISWORD(c)) ) {
+ flagch = BOW;
+ }
+ if ( (lastc != OUT && ISWORD(lastc)) &&
+ (flagch == EOL || (c != OUT && !ISWORD(c))) ) {
+ flagch = EOW;
+ }
+ if (flagch == BOW || flagch == EOW) {
+ st = step(m->g, startst, stopst, st, flagch, st);
+ SP("sboweow", st, c);
+ }
+
+ /* are we done? */
+ if (ISSET(st, stopst))
+ matchp = p;
+ if (EQ(st, empty) || p == stop)
+ break; /* NOTE BREAK OUT */
+
+ /* no, we must deal with this character */
+ ASSIGN(tmp, st);
+ ASSIGN(st, empty);
+ assert(c != OUT);
+ st = step(m->g, startst, stopst, tmp, c, st);
+ SP("saft", st, c);
+ assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st));
+ p++;
+ }
+
+ return(matchp);
+}
+
+
+/*
+ - step - map set of states reachable before char to set reachable after
+ == static states step(register struct re_guts *g, sopno start, sopno stop, \
+ == register states bef, int ch, register states aft);
+ == #define BOL (OUT+1)
+ == #define EOL (BOL+1)
+ == #define BOLEOL (BOL+2)
+ == #define NOTHING (BOL+3)
+ == #define BOW (BOL+4)
+ == #define EOW (BOL+5)
+ == #define CODEMAX (BOL+5) // highest code used
+ == #define NONCHAR(c) ((c) > CHAR_MAX)
+ == #define NNONCHAR (CODEMAX-CHAR_MAX)
+ */
+static states
+step(g, start, stop, bef, ch, aft)
+register struct re_guts *g;
+sopno start; /* start state within strip */
+sopno stop; /* state after stop state within strip */
+register states bef; /* states reachable before */
+int ch; /* character or NONCHAR code */
+register states aft; /* states already known reachable after */
+{
+ register cset *cs;
+ register sop s;
+ register sopno pc;
+ register onestate here; /* note, macros know this name */
+ register sopno look;
+ register int i;
+
+ for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here)) {
+ s = g->strip[pc];
+ switch (OP(s)) {
+ case OEND:
+ assert(pc == stop-1);
+ break;
+ case OCHAR:
+ /* only characters can match */
+ assert(!NONCHAR(ch) || ch != (char)OPND(s));
+ if (ch == (char)OPND(s))
+ FWD(aft, bef, 1);
+ break;
+ case OBOL:
+ if (ch == BOL || ch == BOLEOL)
+ FWD(aft, bef, 1);
+ break;
+ case OEOL:
+ if (ch == EOL || ch == BOLEOL)
+ FWD(aft, bef, 1);
+ break;
+ case OBOW:
+ if (ch == BOW)
+ FWD(aft, bef, 1);
+ break;
+ case OEOW:
+ if (ch == EOW)
+ FWD(aft, bef, 1);
+ break;
+ case OANY:
+ if (!NONCHAR(ch))
+ FWD(aft, bef, 1);
+ break;
+ case OANYOF:
+ cs = &g->sets[OPND(s)];
+ if (!NONCHAR(ch) && CHIN(cs, ch))
+ FWD(aft, bef, 1);
+ break;
+ case OBACK_: /* ignored here */
+ case O_BACK:
+ FWD(aft, aft, 1);
+ break;
+ case OPLUS_: /* forward, this is just an empty */
+ FWD(aft, aft, 1);
+ break;
+ case O_PLUS: /* both forward and back */
+ FWD(aft, aft, 1);
+ i = ISSETBACK(aft, OPND(s));
+ BACK(aft, aft, OPND(s));
+ if (!i && ISSETBACK(aft, OPND(s))) {
+ /* oho, must reconsider loop body */
+ pc -= OPND(s) + 1;
+ INIT(here, pc);
+ }
+ break;
+ case OQUEST_: /* two branches, both forward */
+ FWD(aft, aft, 1);
+ FWD(aft, aft, OPND(s));
+ break;
+ case O_QUEST: /* just an empty */
+ FWD(aft, aft, 1);
+ break;
+ case OLPAREN: /* not significant here */
+ case ORPAREN:
+ FWD(aft, aft, 1);
+ break;
+ case OCH_: /* mark the first two branches */
+ FWD(aft, aft, 1);
+ assert(OP(g->strip[pc+OPND(s)]) == OOR2);
+ FWD(aft, aft, OPND(s));
+ break;
+ case OOR1: /* done a branch, find the O_CH */
+ if (ISSTATEIN(aft, here)) {
+ for (look = 1;
+ OP(s = g->strip[pc+look]) != O_CH;
+ look += OPND(s))
+ assert(OP(s) == OOR2);
+ FWD(aft, aft, look);
+ }
+ break;
+ case OOR2: /* propagate OCH_'s marking */
+ FWD(aft, aft, 1);
+ if (OP(g->strip[pc+OPND(s)]) != O_CH) {
+ assert(OP(g->strip[pc+OPND(s)]) == OOR2);
+ FWD(aft, aft, OPND(s));
+ }
+ break;
+ case O_CH: /* just empty */
+ FWD(aft, aft, 1);
+ break;
+ default: /* ooooops... */
+ assert(nope);
+ break;
+ }
+ }
+
+ return(aft);
+}
+
+#ifdef REDEBUG
+/*
+ - print - print a set of states
+ == #ifdef REDEBUG
+ == static void print(struct match *m, char *caption, states st, \
+ == int ch, FILE *d);
+ == #endif
+ */
+static void
+print(m, caption, st, ch, d)
+struct match *m;
+char *caption;
+states st;
+int ch;
+FILE *d;
+{
+ register struct re_guts *g = m->g;
+ register int i;
+ register int first = 1;
+
+ if (!(m->eflags®_TRACE))
+ return;
+
+ fprintf(d, "%s", caption);
+ if (ch != '\0')
+ fprintf(d, " %s", pchar(ch));
+ for (i = 0; i < g->nstates; i++)
+ if (ISSET(st, i)) {
+ fprintf(d, "%s%d", (first) ? "\t" : ", ", i);
+ first = 0;
+ }
+ fprintf(d, "\n");
+}
+
+/*
+ - at - print current situation
+ == #ifdef REDEBUG
+ == static void at(struct match *m, char *title, char *start, char *stop, \
+ == sopno startst, sopno stopst);
+ == #endif
+ */
+static void
+at(m, title, start, stop, startst, stopst)
+struct match *m;
+char *title;
+char *start;
+char *stop;
+sopno startst;
+sopno stopst;
+{
+ if (!(m->eflags®_TRACE))
+ return;
+
+ printf("%s %s-", title, pchar(*start));
+ printf("%s ", pchar(*stop));
+ printf("%ld-%ld\n", (long)startst, (long)stopst);
+}
+
+#ifndef PCHARDONE
+#define PCHARDONE /* never again */
+/*
+ - pchar - make a character printable
+ == #ifdef REDEBUG
+ == static char *pchar(int ch);
+ == #endif
+ *
+ * Is this identical to regchar() over in debug.c? Well, yes. But a
+ * duplicate here avoids having a debugging-capable regexec.o tied to
+ * a matching debug.o, and this is convenient. It all disappears in
+ * the non-debug compilation anyway, so it doesn't matter much.
+ */
+static char * /* -> representation */
+pchar(ch)
+int ch;
+{
+ static char pbuf[10];
+
+ if (isprint(ch) || ch == ' ')
+ sprintf(pbuf, "%c", ch);
+ else
+ sprintf(pbuf, "\\%o", ch);
+ return(pbuf);
+}
+#endif
+#endif
+
+#undef matcher
+#undef fast
+#undef slow
+#undef dissect
+#undef backref
+#undef step
+#undef print
+#undef at
+#undef match
--- /dev/null
+.\" Copyright (c) 1992, 1993, 1994 Henry Spencer.
+.\" Copyright (c) 1992, 1993, 1994
+.\" The Regents of the University of California. All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Henry Spencer.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\" notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\" notice, this list of conditions and the following disclaimer in the
+.\" documentation and/or other materials provided with the distribution.
+.\" 3. All advertising materials mentioning features or use of this software
+.\" must display the following acknowledgement:
+.\" This product includes software developed by the University of
+.\" California, Berkeley and its contributors.
+.\" 4. Neither the name of the University nor the names of its contributors
+.\" may be used to endorse or promote products derived from this software
+.\" without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\" @(#)re_format.7 8.3 (Berkeley) 3/20/94
+.\"
+.TH RE_FORMAT 7 "March 20, 1994"
+.SH NAME
+re_format \- POSIX 1003.2 regular expressions
+.SH DESCRIPTION
+Regular expressions (``RE''s),
+as defined in POSIX 1003.2, come in two forms:
+modern REs (roughly those of
+.IR egrep ;
+1003.2 calls these ``extended'' REs)
+and obsolete REs (roughly those of
+.IR ed ;
+1003.2 ``basic'' REs).
+Obsolete REs mostly exist for backward compatibility in some old programs;
+they will be discussed at the end.
+1003.2 leaves some aspects of RE syntax and semantics open;
+`\(dg' marks decisions on these aspects that
+may not be fully portable to other 1003.2 implementations.
+.PP
+A (modern) RE is one\(dg or more non-empty\(dg \fIbranches\fR,
+separated by `|'.
+It matches anything that matches one of the branches.
+.PP
+A branch is one\(dg or more \fIpieces\fR, concatenated.
+It matches a match for the first, followed by a match for the second, etc.
+.PP
+A piece is an \fIatom\fR possibly followed
+by a single\(dg `*', `+', `?', or \fIbound\fR.
+An atom followed by `*' matches a sequence of 0 or more matches of the atom.
+An atom followed by `+' matches a sequence of 1 or more matches of the atom.
+An atom followed by `?' matches a sequence of 0 or 1 matches of the atom.
+.PP
+A \fIbound\fR is `{' followed by an unsigned decimal integer,
+possibly followed by `,'
+possibly followed by another unsigned decimal integer,
+always followed by `}'.
+The integers must lie between 0 and RE_DUP_MAX (255\(dg) inclusive,
+and if there are two of them, the first may not exceed the second.
+An atom followed by a bound containing one integer \fIi\fR
+and no comma matches
+a sequence of exactly \fIi\fR matches of the atom.
+An atom followed by a bound
+containing one integer \fIi\fR and a comma matches
+a sequence of \fIi\fR or more matches of the atom.
+An atom followed by a bound
+containing two integers \fIi\fR and \fIj\fR matches
+a sequence of \fIi\fR through \fIj\fR (inclusive) matches of the atom.
+.PP
+An atom is a regular expression enclosed in `()' (matching a match for the
+regular expression),
+an empty set of `()' (matching the null string)\(dg,
+a \fIbracket expression\fR (see below), `.'
+(matching any single character), `^' (matching the null string at the
+beginning of a line), `$' (matching the null string at the
+end of a line), a `\e' followed by one of the characters
+`^.[$()|*+?{\e'
+(matching that character taken as an ordinary character),
+a `\e' followed by any other character\(dg
+(matching that character taken as an ordinary character,
+as if the `\e' had not been present\(dg),
+or a single character with no other significance (matching that character).
+A `{' followed by a character other than a digit is an ordinary
+character, not the beginning of a bound\(dg.
+It is illegal to end an RE with `\e'.
+.PP
+A \fIbracket expression\fR is a list of characters enclosed in `[]'.
+It normally matches any single character from the list (but see below).
+If the list begins with `^',
+it matches any single character
+(but see below) \fInot\fR from the rest of the list.
+If two characters in the list are separated by `\-', this is shorthand
+for the full \fIrange\fR of characters between those two (inclusive) in the
+collating sequence,
+e.g. `[0-9]' in ASCII matches any decimal digit.
+It is illegal\(dg for two ranges to share an
+endpoint, e.g. `a-c-e'.
+Ranges are very collating-sequence-dependent,
+and portable programs should avoid relying on them.
+.PP
+To include a literal `]' in the list, make it the first character
+(following a possible `^').
+To include a literal `\-', make it the first or last character,
+or the second endpoint of a range.
+To use a literal `\-' as the first endpoint of a range,
+enclose it in `[.' and `.]' to make it a collating element (see below).
+With the exception of these and some combinations using `[' (see next
+paragraphs), all other special characters, including `\e', lose their
+special significance within a bracket expression.
+.PP
+Within a bracket expression, a collating element (a character,
+a multi-character sequence that collates as if it were a single character,
+or a collating-sequence name for either)
+enclosed in `[.' and `.]' stands for the
+sequence of characters of that collating element.
+The sequence is a single element of the bracket expression's list.
+A bracket expression containing a multi-character collating element
+can thus match more than one character,
+e.g. if the collating sequence includes a `ch' collating element,
+then the RE `[[.ch.]]*c' matches the first five characters
+of `chchcc'.
+.PP
+Within a bracket expression, a collating element enclosed in `[=' and
+`=]' is an equivalence class, standing for the sequences of characters
+of all collating elements equivalent to that one, including itself.
+(If there are no other equivalent collating elements,
+the treatment is as if the enclosing delimiters were `[.' and `.]'.)
+For example, if o and \o'o^' are the members of an equivalence class,
+then `[[=o=]]', `[[=\o'o^'=]]', and `[o\o'o^']' are all synonymous.
+An equivalence class may not\(dg be an endpoint
+of a range.
+.PP
+Within a bracket expression, the name of a \fIcharacter class\fR enclosed
+in `[:' and `:]' stands for the list of all characters belonging to that
+class.
+Standard character class names are:
+.PP
+.RS
+.nf
+.ta 3c 6c 9c
+alnum digit punct
+alpha graph space
+blank lower upper
+cntrl print xdigit
+.fi
+.RE
+.PP
+These stand for the character classes defined in
+.IR ctype (3).
+A locale may provide others.
+A character class may not be used as an endpoint of a range.
+.PP
+There are two special cases\(dg of bracket expressions:
+the bracket expressions `[[:<:]]' and `[[:>:]]' match the null string at
+the beginning and end of a word respectively.
+A word is defined as a sequence of
+word characters
+which is neither preceded nor followed by
+word characters.
+A word character is an
+.I alnum
+character (as defined by
+.IR ctype (3))
+or an underscore.
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+.PP
+In the event that an RE could match more than one substring of a given
+string,
+the RE matches the one starting earliest in the string.
+If the RE could match more than one substring starting at that point,
+it matches the longest.
+Subexpressions also match the longest possible substrings, subject to
+the constraint that the whole match be as long as possible,
+with subexpressions starting earlier in the RE taking priority over
+ones starting later.
+Note that higher-level subexpressions thus take priority over
+their lower-level component subexpressions.
+.PP
+Match lengths are measured in characters, not collating elements.
+A null string is considered longer than no match at all.
+For example,
+`bb*' matches the three middle characters of `abbbc',
+`(wee|week)(knights|nights)' matches all ten characters of `weeknights',
+when `(.*).*' is matched against `abc' the parenthesized subexpression
+matches all three characters, and
+when `(a*)*' is matched against `bc' both the whole RE and the parenthesized
+subexpression match the null string.
+.PP
+If case-independent matching is specified,
+the effect is much as if all case distinctions had vanished from the
+alphabet.
+When an alphabetic that exists in multiple cases appears as an
+ordinary character outside a bracket expression, it is effectively
+transformed into a bracket expression containing both cases,
+e.g. `x' becomes `[xX]'.
+When it appears inside a bracket expression, all case counterparts
+of it are added to the bracket expression, so that (e.g.) `[x]'
+becomes `[xX]' and `[^x]' becomes `[^xX]'.
+.PP
+No particular limit is imposed on the length of REs\(dg.
+Programs intended to be portable should not employ REs longer
+than 256 bytes,
+as an implementation can refuse to accept such REs and remain
+POSIX-compliant.
+.PP
+Obsolete (``basic'') regular expressions differ in several respects.
+`|', `+', and `?' are ordinary characters and there is no equivalent
+for their functionality.
+The delimiters for bounds are `\e{' and `\e}',
+with `{' and `}' by themselves ordinary characters.
+The parentheses for nested subexpressions are `\e(' and `\e)',
+with `(' and `)' by themselves ordinary characters.
+`^' is an ordinary character except at the beginning of the
+RE or\(dg the beginning of a parenthesized subexpression,
+`$' is an ordinary character except at the end of the
+RE or\(dg the end of a parenthesized subexpression,
+and `*' is an ordinary character if it appears at the beginning of the
+RE or the beginning of a parenthesized subexpression
+(after a possible leading `^').
+Finally, there is one new type of atom, a \fIback reference\fR:
+`\e' followed by a non-zero decimal digit \fId\fR
+matches the same sequence of characters
+matched by the \fId\fRth parenthesized subexpression
+(numbering subexpressions by the positions of their opening parentheses,
+left to right),
+so that (e.g.) `\e([bc]\e)\e1' matches `bb' or `cc' but not `bc'.
+.SH SEE ALSO
+regex(3)
+.PP
+POSIX 1003.2, section 2.8 (Regular Expression Notation).
+.SH BUGS
+Having two kinds of REs is a botch.
+.PP
+The current 1003.2 spec says that `)' is an ordinary character in
+the absence of an unmatched `(';
+this was an unintentional result of a wording error,
+and change is likely.
+Avoid relying on it.
+.PP
+Back references are a dreadful botch,
+posing major problems for efficient implementations.
+They are also somewhat vaguely defined
+(does
+`a\e(\e(b\e)*\e2\e)*d' match `abbbd'?).
+Avoid using them.
+.PP
+1003.2's specification of case-independent matching is vague.
+The ``one case implies all cases'' definition given above
+is current consensus among implementors as to the right interpretation.
+.PP
+The syntax for word boundaries is incredibly ugly.
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)regcomp.c 8.5 (Berkeley) 3/20/94
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)regcomp.c 8.5 (Berkeley) 3/20/94";
+#endif /* LIBC_SCCS and not lint */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "utils.h"
+#include "regex2.h"
+
+#include "cclass.h"
+#include "cname.h"
+
+/*
+ * parse structure, passed up and down to avoid global variables and
+ * other clumsinesses
+ */
+struct parse {
+ char *next; /* next character in RE */
+ char *end; /* end of string (-> NUL normally) */
+ int error; /* has an error been seen? */
+ sop *strip; /* malloced strip */
+ sopno ssize; /* malloced strip size (allocated) */
+ sopno slen; /* malloced strip length (used) */
+ int ncsalloc; /* number of csets allocated */
+ struct re_guts *g;
+# define NPAREN 10 /* we need to remember () 1-9 for back refs */
+ sopno pbegin[NPAREN]; /* -> ( ([0] unused) */
+ sopno pend[NPAREN]; /* -> ) ([0] unused) */
+};
+
+/* ========= begin header generated by ./mkh ========= */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* === regcomp.c === */
+static void p_ere __P((struct parse *p, int stop));
+static void p_ere_exp __P((struct parse *p));
+static void p_str __P((struct parse *p));
+static void p_bre __P((struct parse *p, int end1, int end2));
+static int p_simp_re __P((struct parse *p, int starordinary));
+static int p_count __P((struct parse *p));
+static void p_bracket __P((struct parse *p));
+static void p_b_term __P((struct parse *p, cset *cs));
+static void p_b_cclass __P((struct parse *p, cset *cs));
+static void p_b_eclass __P((struct parse *p, cset *cs));
+static char p_b_symbol __P((struct parse *p));
+static char p_b_coll_elem __P((struct parse *p, int endc));
+static char othercase __P((int ch));
+static void bothcases __P((struct parse *p, int ch));
+static void ordinary __P((struct parse *p, int ch));
+static void nonnewline __P((struct parse *p));
+static void repeat __P((struct parse *p, sopno start, int from, int to));
+static int seterr __P((struct parse *p, int e));
+static cset *allocset __P((struct parse *p));
+static void freeset __P((struct parse *p, cset *cs));
+static int freezeset __P((struct parse *p, cset *cs));
+static int firstch __P((struct parse *p, cset *cs));
+static int nch __P((struct parse *p, cset *cs));
+static void mcadd __P((struct parse *p, cset *cs, char *cp));
+/* static void mcsub __P((cset *cs, char *cp)); */
+/*static int mcin __P((cset *cs, char *cp));*/
+/*static char *mcfind __P((cset *cs, char *cp)); */
+static void mcinvert __P((struct parse *p, cset *cs));
+static void mccase __P((struct parse *p, cset *cs));
+static int isinsets __P((struct re_guts *g, int c));
+static int samesets __P((struct re_guts *g, int c1, int c2));
+static void categorize __P((struct parse *p, struct re_guts *g));
+static sopno dupl __P((struct parse *p, sopno start, sopno finish));
+static void doemit __P((struct parse *p, sop op, size_t opnd));
+static void doinsert __P((struct parse *p, sop op, size_t opnd, sopno pos));
+static void dofwd __P((struct parse *p, sopno pos, sop value));
+static void enlarge __P((struct parse *p, sopno size));
+static void stripsnug __P((struct parse *p, struct re_guts *g));
+static void findmust __P((struct parse *p, struct re_guts *g));
+static sopno pluscount __P((struct parse *p, struct re_guts *g));
+
+#ifdef __cplusplus
+}
+#endif
+/* ========= end header generated by ./mkh ========= */
+
+static char nuls[10]; /* place to point scanner in event of error */
+
+/*
+ * macros for use with parse structure
+ * BEWARE: these know that the parse structure is named `p' !!!
+ */
+#define PEEK() (*p->next)
+#define PEEK2() (*(p->next+1))
+#define MORE() (p->next < p->end)
+#define MORE2() (p->next+1 < p->end)
+#define SEE(c) (MORE() && PEEK() == (c))
+#define SEETWO(a, b) (MORE() && MORE2() && PEEK() == (a) && PEEK2() == (b))
+#define EAT(c) ((SEE(c)) ? (NEXT(), 1) : 0)
+#define EATTWO(a, b) ((SEETWO(a, b)) ? (NEXT2(), 1) : 0)
+#define NEXT() (p->next++)
+#define NEXT2() (p->next += 2)
+#define NEXTn(n) (p->next += (n))
+#define GETNEXT() (*p->next++)
+#define SETERROR(e) seterr(p, (e))
+#define REQUIRE(co, e) if (!(co)) SETERROR(e)
+#define MUSTSEE(c, e) REQUIRE(MORE() && PEEK() == (c), e)
+#define MUSTEAT(c, e) REQUIRE(MORE() && GETNEXT() == (c), e)
+#define MUSTNOTSEE(c, e) REQUIRE(!MORE() || PEEK() != (c), e)
+#define EMIT(op, sopnd) doemit(p, (sop)(op), (size_t)(sopnd))
+#define INSERT(op, pos) doinsert(p, (sop)(op), HERE()-(pos)+1, pos)
+#define AHEAD(pos) dofwd(p, pos, HERE()-(pos))
+#define ASTERN(sop, pos) EMIT(sop, HERE()-pos)
+#define HERE() (p->slen)
+#define THERE() (p->slen - 1)
+#define THERETHERE() (p->slen - 2)
+#define DROP(n) (p->slen -= (n))
+
+#ifndef NDEBUG
+static int never = 0; /* for use in asserts; shuts lint up */
+#else
+#define never 0 /* some
s have bugs too */+#endif
+
+/*
+ - regcomp - interface for parser and compilation
+ = extern int regcomp(regex_t *, const char *, int);
+ = #define REG_BASIC 0000
+ = #define REG_EXTENDED 0001
+ = #define REG_ICASE 0002
+ = #define REG_NOSUB 0004
+ = #define REG_NEWLINE 0010
+ = #define REG_NOSPEC 0020
+ = #define REG_PEND 0040
+ = #define REG_DUMP 0200
+ */
+int /* 0 success, otherwise REG_something */
+pg95_regcomp(preg, pattern, cflags)
+regex_t *preg;
+const char *pattern;
+int cflags;
+{
+ struct parse pa;
+ register struct re_guts *g;
+ register struct parse *p = &pa;
+ register int i;
+ register size_t len;
+#ifdef REDEBUG
+# define GOODFLAGS(f) (f)
+#else
+# define GOODFLAGS(f) ((f)&~REG_DUMP)
+#endif
+
+ cflags = GOODFLAGS(cflags);
+ if ((cflags®_EXTENDED) && (cflags®_NOSPEC))
+ return(REG_INVARG);
+
+ if (cflags®_PEND) {
+ if (preg->re_endp < pattern)
+ return(REG_INVARG);
+ len = preg->re_endp - pattern;
+ } else
+ len = strlen((char *)pattern);
+
+ /* do the mallocs early so failure handling is easy */
+ g = (struct re_guts *)malloc(sizeof(struct re_guts) +
+ (NC-1)*sizeof(cat_t));
+ if (g == NULL)
+ return(REG_ESPACE);
+ p->ssize = len/(size_t)2*(size_t)3 + (size_t)1; /* ugh */
+ p->strip = (sop *)malloc(p->ssize * sizeof(sop));
+ p->slen = 0;
+ if (p->strip == NULL) {
+ free((char *)g);
+ return(REG_ESPACE);
+ }
+
+ /* set things up */
+ p->g = g;
+ p->next = (char *)pattern; /* convenience; we do not modify it */
+ p->end = p->next + len;
+ p->error = 0;
+ p->ncsalloc = 0;
+ for (i = 0; i < NPAREN; i++) {
+ p->pbegin[i] = 0;
+ p->pend[i] = 0;
+ }
+ g->csetsize = NC;
+ g->sets = NULL;
+ g->setbits = NULL;
+ g->ncsets = 0;
+ g->cflags = cflags;
+ g->iflags = 0;
+ g->nbol = 0;
+ g->neol = 0;
+ g->must = NULL;
+ g->mlen = 0;
+ g->nsub = 0;
+ g->ncategories = 1; /* category 0 is "everything else" */
+ g->categories = &g->catspace[-(CHAR_MIN)];
+ (void) memset((char *)g->catspace, 0, NC*sizeof(cat_t));
+ g->backrefs = 0;
+
+ /* do it */
+ EMIT(OEND, 0);
+ g->firststate = THERE();
+ if (cflags®_EXTENDED)
+ p_ere(p, OUT);
+ else if (cflags®_NOSPEC)
+ p_str(p);
+ else
+ p_bre(p, OUT, OUT);
+ EMIT(OEND, 0);
+ g->laststate = THERE();
+
+ /* tidy up loose ends and fill things in */
+ categorize(p, g);
+ stripsnug(p, g);
+ findmust(p, g);
+ g->nplus = pluscount(p, g);
+ g->magic = MAGIC2;
+ preg->re_nsub = g->nsub;
+ preg->re_g = g;
+ preg->re_magic = MAGIC1;
+#ifndef REDEBUG
+ /* not debugging, so can't rely on the assert() in regexec() */
+ if (g->iflags&BAD)
+ SETERROR(REG_ASSERT);
+#endif
+
+ /* win or lose, we're done */
+ if (p->error != 0) /* lose */
+ pg95_regfree(preg);
+ return(p->error);
+}
+
+/*
+ - p_ere - ERE parser top level, concatenation and alternation
+ == static void p_ere(register struct parse *p, int stop);
+ */
+static void
+p_ere(p, stop)
+register struct parse *p;
+int stop; /* character this ERE should end at */
+{
+ register char c;
+ register sopno prevback;
+ register sopno prevfwd;
+ register sopno conc;
+ register int first = 1; /* is this the first alternative? */
+
+ for (;;) {
+ /* do a bunch of concatenated expressions */
+ conc = HERE();
+ while (MORE() && (c = PEEK()) != '|' && c != stop)
+ p_ere_exp(p);
+ REQUIRE(HERE() != conc, REG_EMPTY); /* require nonempty */
+
+ if (!EAT('|'))
+ break; /* NOTE BREAK OUT */
+
+ if (first) {
+ INSERT(OCH_, conc); /* offset is wrong */
+ prevfwd = conc;
+ prevback = conc;
+ first = 0;
+ }
+ ASTERN(OOR1, prevback);
+ prevback = THERE();
+ AHEAD(prevfwd); /* fix previous offset */
+ prevfwd = HERE();
+ EMIT(OOR2, 0); /* offset is very wrong */
+ }
+
+ if (!first) { /* tail-end fixups */
+ AHEAD(prevfwd);
+ ASTERN(O_CH, prevback);
+ }
+
+ assert(!MORE() || SEE(stop));
+}
+
+/*
+ - p_ere_exp - parse one subERE, an atom possibly followed by a repetition op
+ == static void p_ere_exp(register struct parse *p);
+ */
+static void
+p_ere_exp(p)
+register struct parse *p;
+{
+ register char c;
+ register sopno pos;
+ register int count;
+ register int count2;
+ register sopno subno;
+ int wascaret = 0;
+
+ assert(MORE()); /* caller should have ensured this */
+ c = GETNEXT();
+
+ pos = HERE();
+ switch (c) {
+ case '(':
+ REQUIRE(MORE(), REG_EPAREN);
+ p->g->nsub++;
+ subno = p->g->nsub;
+ if (subno < NPAREN)
+ p->pbegin[subno] = HERE();
+ EMIT(OLPAREN, subno);
+ if (!SEE(')'))
+ p_ere(p, ')');
+ if (subno < NPAREN) {
+ p->pend[subno] = HERE();
+ assert(p->pend[subno] != 0);
+ }
+ EMIT(ORPAREN, subno);
+ MUSTEAT(')', REG_EPAREN);
+ break;
+#ifndef POSIX_MISTAKE
+ case ')': /* happens only if no current unmatched ( */
+ /*
+ * You may ask, why the ifndef? Because I didn't notice
+ * this until slightly too late for 1003.2, and none of the
+ * other 1003.2 regular-expression reviewers noticed it at
+ * all. So an unmatched ) is legal POSIX, at least until
+ * we can get it fixed.
+ */
+ SETERROR(REG_EPAREN);
+ break;
+#endif
+ case '^':
+ EMIT(OBOL, 0);
+ p->g->iflags |= USEBOL;
+ p->g->nbol++;
+ wascaret = 1;
+ break;
+ case '$':
+ EMIT(OEOL, 0);
+ p->g->iflags |= USEEOL;
+ p->g->neol++;
+ break;
+ case '|':
+ SETERROR(REG_EMPTY);
+ break;
+ case '*':
+ case '+':
+ case '?':
+ SETERROR(REG_BADRPT);
+ break;
+ case '.':
+ if (p->g->cflags®_NEWLINE)
+ nonnewline(p);
+ else
+ EMIT(OANY, 0);
+ break;
+ case '[':
+ p_bracket(p);
+ break;
+ case '\\':
+ REQUIRE(MORE(), REG_EESCAPE);
+ c = GETNEXT();
+ ordinary(p, c);
+ break;
+ case '{': /* okay as ordinary except if digit follows */
+ REQUIRE(!MORE() || !isdigit(PEEK()), REG_BADRPT);
+ /* FALLTHROUGH */
+ default:
+ ordinary(p, c);
+ break;
+ }
+
+ if (!MORE())
+ return;
+ c = PEEK();
+ /* we call { a repetition if followed by a digit */
+ if (!( c == '*' || c == '+' || c == '?' ||
+ (c == '{' && MORE2() && isdigit(PEEK2())) ))
+ return; /* no repetition, we're done */
+ NEXT();
+
+ REQUIRE(!wascaret, REG_BADRPT);
+ switch (c) {
+ case '*': /* implemented as +? */
+ /* this case does not require the (y|) trick, noKLUDGE */
+ INSERT(OPLUS_, pos);
+ ASTERN(O_PLUS, pos);
+ INSERT(OQUEST_, pos);
+ ASTERN(O_QUEST, pos);
+ break;
+ case '+':
+ INSERT(OPLUS_, pos);
+ ASTERN(O_PLUS, pos);
+ break;
+ case '?':
+ /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
+ INSERT(OCH_, pos); /* offset slightly wrong */
+ ASTERN(OOR1, pos); /* this one's right */
+ AHEAD(pos); /* fix the OCH_ */
+ EMIT(OOR2, 0); /* offset very wrong... */
+ AHEAD(THERE()); /* ...so fix it */
+ ASTERN(O_CH, THERETHERE());
+ break;
+ case '{':
+ count = p_count(p);
+ if (EAT(',')) {
+ if (isdigit(PEEK())) {
+ count2 = p_count(p);
+ REQUIRE(count <= count2, REG_BADBR);
+ } else /* single number with comma */
+ count2 = INFINITY;
+ } else /* just a single number */
+ count2 = count;
+ repeat(p, pos, count, count2);
+ if (!EAT('}')) { /* error heuristics */
+ while (MORE() && PEEK() != '}')
+ NEXT();
+ REQUIRE(MORE(), REG_EBRACE);
+ SETERROR(REG_BADBR);
+ }
+ break;
+ }
+
+ if (!MORE())
+ return;
+ c = PEEK();
+ if (!( c == '*' || c == '+' || c == '?' ||
+ (c == '{' && MORE2() && isdigit(PEEK2())) ) )
+ return;
+ SETERROR(REG_BADRPT);
+}
+
+/*
+ - p_str - string (no metacharacters) "parser"
+ == static void p_str(register struct parse *p);
+ */
+static void
+p_str(p)
+register struct parse *p;
+{
+ REQUIRE(MORE(), REG_EMPTY);
+ while (MORE())
+ ordinary(p, GETNEXT());
+}
+
+/*
+ - p_bre - BRE parser top level, anchoring and concatenation
+ == static void p_bre(register struct parse *p, register int end1, \
+ == register int end2);
+ * Giving end1 as OUT essentially eliminates the end1/end2 check.
+ *
+ * This implementation is a bit of a kludge, in that a trailing $ is first
+ * taken as an ordinary character and then revised to be an anchor. The
+ * only undesirable side effect is that '$' gets included as a character
+ * category in such cases. This is fairly harmless; not worth fixing.
+ * The amount of lookahead needed to avoid this kludge is excessive.
+ */
+static void
+p_bre(p, end1, end2)
+register struct parse *p;
+register int end1; /* first terminating character */
+register int end2; /* second terminating character */
+{
+ register sopno start = HERE();
+ register int first = 1; /* first subexpression? */
+ register int wasdollar = 0;
+
+ if (EAT('^')) {
+ EMIT(OBOL, 0);
+ p->g->iflags |= USEBOL;
+ p->g->nbol++;
+ }
+ while (MORE() && !SEETWO(end1, end2)) {
+ wasdollar = p_simp_re(p, first);
+ first = 0;
+ }
+ if (wasdollar) { /* oops, that was a trailing anchor */
+ DROP(1);
+ EMIT(OEOL, 0);
+ p->g->iflags |= USEEOL;
+ p->g->neol++;
+ }
+
+ REQUIRE(HERE() != start, REG_EMPTY); /* require nonempty */
+}
+
+/*
+ - p_simp_re - parse a simple RE, an atom possibly followed by a repetition
+ == static int p_simp_re(register struct parse *p, int starordinary);
+ */
+static int /* was the simple RE an unbackslashed $? */
+p_simp_re(p, starordinary)
+register struct parse *p;
+int starordinary; /* is a leading * an ordinary character? */
+{
+ register int c;
+ register int count;
+ register int count2;
+ register sopno pos;
+ register int i;
+ register sopno subno;
+# define BACKSL (1<
+
+ pos = HERE(); /* repetion op, if any, covers from here */
+
+ assert(MORE()); /* caller should have ensured this */
+ c = GETNEXT();
+ if (c == '\\') {
+ REQUIRE(MORE(), REG_EESCAPE);
+ c = BACKSL | (unsigned char)GETNEXT();
+ }
+ switch (c) {
+ case '.':
+ if (p->g->cflags®_NEWLINE)
+ nonnewline(p);
+ else
+ EMIT(OANY, 0);
+ break;
+ case '[':
+ p_bracket(p);
+ break;
+ case BACKSL|'{':
+ SETERROR(REG_BADRPT);
+ break;
+ case BACKSL|'(':
+ p->g->nsub++;
+ subno = p->g->nsub;
+ if (subno < NPAREN)
+ p->pbegin[subno] = HERE();
+ EMIT(OLPAREN, subno);
+ /* the MORE here is an error heuristic */
+ if (MORE() && !SEETWO('\\', ')'))
+ p_bre(p, '\\', ')');
+ if (subno < NPAREN) {
+ p->pend[subno] = HERE();
+ assert(p->pend[subno] != 0);
+ }
+ EMIT(ORPAREN, subno);
+ REQUIRE(EATTWO('\\', ')'), REG_EPAREN);
+ break;
+ case BACKSL|')': /* should not get here -- must be user */
+ case BACKSL|'}':
+ SETERROR(REG_EPAREN);
+ break;
+ case BACKSL|'1':
+ case BACKSL|'2':
+ case BACKSL|'3':
+ case BACKSL|'4':
+ case BACKSL|'5':
+ case BACKSL|'6':
+ case BACKSL|'7':
+ case BACKSL|'8':
+ case BACKSL|'9':
+ i = (c&~BACKSL) - '0';
+ assert(i < NPAREN);
+ if (p->pend[i] != 0) {
+ assert(i <= p->g->nsub);
+ EMIT(OBACK_, i);
+ assert(p->pbegin[i] != 0);
+ assert(OP(p->strip[p->pbegin[i]]) == OLPAREN);
+ assert(OP(p->strip[p->pend[i]]) == ORPAREN);
+ (void) dupl(p, p->pbegin[i]+1, p->pend[i]);
+ EMIT(O_BACK, i);
+ } else
+ SETERROR(REG_ESUBREG);
+ p->g->backrefs = 1;
+ break;
+ case '*':
+ REQUIRE(starordinary, REG_BADRPT);
+ /* FALLTHROUGH */
+ default:
+ ordinary(p, c &~ BACKSL);
+ break;
+ }
+
+ if (EAT('*')) { /* implemented as +? */
+ /* this case does not require the (y|) trick, noKLUDGE */
+ INSERT(OPLUS_, pos);
+ ASTERN(O_PLUS, pos);
+ INSERT(OQUEST_, pos);
+ ASTERN(O_QUEST, pos);
+ } else if (EATTWO('\\', '{')) {
+ count = p_count(p);
+ if (EAT(',')) {
+ if (MORE() && isdigit(PEEK())) {
+ count2 = p_count(p);
+ REQUIRE(count <= count2, REG_BADBR);
+ } else /* single number with comma */
+ count2 = INFINITY;
+ } else /* just a single number */
+ count2 = count;
+ repeat(p, pos, count, count2);
+ if (!EATTWO('\\', '}')) { /* error heuristics */
+ while (MORE() && !SEETWO('\\', '}'))
+ NEXT();
+ REQUIRE(MORE(), REG_EBRACE);
+ SETERROR(REG_BADBR);
+ }
+ } else if (c == (unsigned char)'$') /* $ (but not \$) ends it */
+ return(1);
+
+ return(0);
+}
+
+/*
+ - p_count - parse a repetition count
+ == static int p_count(register struct parse *p);
+ */
+static int /* the value */
+p_count(p)
+register struct parse *p;
+{
+ register int count = 0;
+ register int ndigits = 0;
+
+ while (MORE() && isdigit(PEEK()) && count <= DUPMAX) {
+ count = count*10 + (GETNEXT() - '0');
+ ndigits++;
+ }
+
+ REQUIRE(ndigits > 0 && count <= DUPMAX, REG_BADBR);
+ return(count);
+}
+
+/*
+ - p_bracket - parse a bracketed character list
+ == static void p_bracket(register struct parse *p);
+ *
+ * Note a significant property of this code: if the allocset() did SETERROR,
+ * no set operations are done.
+ */
+static void
+p_bracket(p)
+register struct parse *p;
+{
+ register cset *cs = allocset(p);
+ register int invert = 0;
+
+ /* Dept of Truly Sickening Special-Case Kludges */
+ if (p->next + 5 < p->end && strncmp(p->next, "[:<:]]", 6) == 0) {
+ EMIT(OBOW, 0);
+ NEXTn(6);
+ return;
+ }
+ if (p->next + 5 < p->end && strncmp(p->next, "[:>:]]", 6) == 0) {
+ EMIT(OEOW, 0);
+ NEXTn(6);
+ return;
+ }
+
+ if (EAT('^'))
+ invert++; /* make note to invert set at end */
+ if (EAT(']'))
+ CHadd(cs, ']');
+ else if (EAT('-'))
+ CHadd(cs, '-');
+ while (MORE() && PEEK() != ']' && !SEETWO('-', ']'))
+ p_b_term(p, cs);
+ if (EAT('-'))
+ CHadd(cs, '-');
+ MUSTEAT(']', REG_EBRACK);
+
+ if (p->error != 0) /* don't mess things up further */
+ return;
+
+ if (p->g->cflags®_ICASE) {
+ register int i;
+ register int ci;
+
+ for (i = p->g->csetsize - 1; i >= 0; i--)
+ if (CHIN(cs, i) && isalpha(i)) {
+ ci = othercase(i);
+ if (ci != i)
+ CHadd(cs, ci);
+ }
+ if (cs->multis != NULL)
+ mccase(p, cs);
+ }
+ if (invert) {
+ register int i;
+
+ for (i = p->g->csetsize - 1; i >= 0; i--)
+ if (CHIN(cs, i))
+ CHsub(cs, i);
+ else
+ CHadd(cs, i);
+ if (p->g->cflags®_NEWLINE)
+ CHsub(cs, '\n');
+ if (cs->multis != NULL)
+ mcinvert(p, cs);
+ }
+
+ assert(cs->multis == NULL); /* xxx */
+
+ if (nch(p, cs) == 1) { /* optimize singleton sets */
+ ordinary(p, firstch(p, cs));
+ freeset(p, cs);
+ } else
+ EMIT(OANYOF, freezeset(p, cs));
+}
+
+/*
+ - p_b_term - parse one term of a bracketed character list
+ == static void p_b_term(register struct parse *p, register cset *cs);
+ */
+static void
+p_b_term(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ register char c;
+ register char start, finish;
+ register int i;
+
+ /* classify what we've got */
+ switch ((MORE()) ? PEEK() : '\0') {
+ case '[':
+ c = (MORE2()) ? PEEK2() : '\0';
+ break;
+ case '-':
+ SETERROR(REG_ERANGE);
+ return; /* NOTE RETURN */
+ break;
+ default:
+ c = '\0';
+ break;
+ }
+
+ switch (c) {
+ case ':': /* character class */
+ NEXT2();
+ REQUIRE(MORE(), REG_EBRACK);
+ c = PEEK();
+ REQUIRE(c != '-' && c != ']', REG_ECTYPE);
+ p_b_cclass(p, cs);
+ REQUIRE(MORE(), REG_EBRACK);
+ REQUIRE(EATTWO(':', ']'), REG_ECTYPE);
+ break;
+ case '=': /* equivalence class */
+ NEXT2();
+ REQUIRE(MORE(), REG_EBRACK);
+ c = PEEK();
+ REQUIRE(c != '-' && c != ']', REG_ECOLLATE);
+ p_b_eclass(p, cs);
+ REQUIRE(MORE(), REG_EBRACK);
+ REQUIRE(EATTWO('=', ']'), REG_ECOLLATE);
+ break;
+ default: /* symbol, ordinary character, or range */
+/* xxx revision needed for multichar stuff */
+ start = p_b_symbol(p);
+ if (SEE('-') && MORE2() && PEEK2() != ']') {
+ /* range */
+ NEXT();
+ if (EAT('-'))
+ finish = '-';
+ else
+ finish = p_b_symbol(p);
+ } else
+ finish = start;
+/* xxx what about signed chars here... */
+ REQUIRE(start <= finish, REG_ERANGE);
+ for (i = start; i <= finish; i++)
+ CHadd(cs, i);
+ break;
+ }
+}
+
+/*
+ - p_b_cclass - parse a character-class name and deal with it
+ == static void p_b_cclass(register struct parse *p, register cset *cs);
+ */
+static void
+p_b_cclass(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ register char *sp = p->next;
+ register struct cclass *cp;
+ register size_t len;
+ register char *u;
+ register char c;
+
+ while (MORE() && isalpha(PEEK()))
+ NEXT();
+ len = p->next - sp;
+ for (cp = cclasses; cp->name != NULL; cp++)
+ if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')
+ break;
+ if (cp->name == NULL) {
+ /* oops, didn't find it */
+ SETERROR(REG_ECTYPE);
+ return;
+ }
+
+ u = cp->chars;
+ while ((c = *u++) != '\0')
+ CHadd(cs, c);
+ for (u = cp->multis; *u != '\0'; u += strlen(u) + 1)
+ MCadd(p, cs, u);
+}
+
+/*
+ - p_b_eclass - parse an equivalence-class name and deal with it
+ == static void p_b_eclass(register struct parse *p, register cset *cs);
+ *
+ * This implementation is incomplete. xxx
+ */
+static void
+p_b_eclass(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ register char c;
+
+ c = p_b_coll_elem(p, '=');
+ CHadd(cs, c);
+}
+
+/*
+ - p_b_symbol - parse a character or [..]ed multicharacter collating symbol
+ == static char p_b_symbol(register struct parse *p);
+ */
+static char /* value of symbol */
+p_b_symbol(p)
+register struct parse *p;
+{
+ register char value;
+
+ REQUIRE(MORE(), REG_EBRACK);
+ if (!EATTWO('[', '.'))
+ return(GETNEXT());
+
+ /* collating symbol */
+ value = p_b_coll_elem(p, '.');
+ REQUIRE(EATTWO('.', ']'), REG_ECOLLATE);
+ return(value);
+}
+
+/*
+ - p_b_coll_elem - parse a collating-element name and look it up
+ == static char p_b_coll_elem(register struct parse *p, int endc);
+ */
+static char /* value of collating element */
+p_b_coll_elem(p, endc)
+register struct parse *p;
+int endc; /* name ended by endc,']' */
+{
+ register char *sp = p->next;
+ register struct cname *cp;
+ register int len;
+
+ while (MORE() && !SEETWO(endc, ']'))
+ NEXT();
+ if (!MORE()) {
+ SETERROR(REG_EBRACK);
+ return(0);
+ }
+ len = p->next - sp;
+ for (cp = cnames; cp->name != NULL; cp++)
+ if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')
+ return(cp->code); /* known name */
+ if (len == 1)
+ return(*sp); /* single character */
+ SETERROR(REG_ECOLLATE); /* neither */
+ return(0);
+}
+
+/*
+ - othercase - return the case counterpart of an alphabetic
+ == static char othercase(int ch);
+ */
+static char /* if no counterpart, return ch */
+othercase(ch)
+int ch;
+{
+ assert(isalpha(ch));
+ if (isupper(ch))
+ return(tolower(ch));
+ else if (islower(ch))
+ return(toupper(ch));
+ else /* peculiar, but could happen */
+ return(ch);
+}
+
+/*
+ - bothcases - emit a dualcase version of a two-case character
+ == static void bothcases(register struct parse *p, int ch);
+ *
+ * Boy, is this implementation ever a kludge...
+ */
+static void
+bothcases(p, ch)
+register struct parse *p;
+int ch;
+{
+ register char *oldnext = p->next;
+ register char *oldend = p->end;
+ char bracket[3];
+
+ assert(othercase(ch) != ch); /* p_bracket() would recurse */
+ p->next = bracket;
+ p->end = bracket+2;
+ bracket[0] = ch;
+ bracket[1] = ']';
+ bracket[2] = '\0';
+ p_bracket(p);
+ assert(p->next == bracket+2);
+ p->next = oldnext;
+ p->end = oldend;
+}
+
+/*
+ - ordinary - emit an ordinary character
+ == static void ordinary(register struct parse *p, register int ch);
+ */
+static void
+ordinary(p, ch)
+register struct parse *p;
+register int ch;
+{
+ register cat_t *cap = p->g->categories;
+
+ if ((p->g->cflags®_ICASE) && isalpha(ch) && othercase(ch) != ch)
+ bothcases(p, ch);
+ else {
+ EMIT(OCHAR, (unsigned char)ch);
+ if (cap[ch] == 0)
+ cap[ch] = p->g->ncategories++;
+ }
+}
+
+/*
+ - nonnewline - emit REG_NEWLINE version of OANY
+ == static void nonnewline(register struct parse *p);
+ *
+ * Boy, is this implementation ever a kludge...
+ */
+static void
+nonnewline(p)
+register struct parse *p;
+{
+ register char *oldnext = p->next;
+ register char *oldend = p->end;
+ char bracket[4];
+
+ p->next = bracket;
+ p->end = bracket+3;
+ bracket[0] = '^';
+ bracket[1] = '\n';
+ bracket[2] = ']';
+ bracket[3] = '\0';
+ p_bracket(p);
+ assert(p->next == bracket+3);
+ p->next = oldnext;
+ p->end = oldend;
+}
+
+/*
+ - repeat - generate code for a bounded repetition, recursively if needed
+ == static void repeat(register struct parse *p, sopno start, int from, int to);
+ */
+static void
+repeat(p, start, from, to)
+register struct parse *p;
+sopno start; /* operand from here to end of strip */
+int from; /* repeated from this number */
+int to; /* to this number of times (maybe INFINITY) */
+{
+ register 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)
+ register sopno copy;
+
+ if (p->error != 0) /* head off possible runaway recursion */
+ return;
+
+ assert(from <= to);
+
+ switch (REP(MAP(from), MAP(to))) {
+ case REP(0, 0): /* must be user doing this */
+ DROP(finish-start); /* drop the operand */
+ break;
+ case REP(0, 1): /* as x{1,1}? */
+ case REP(0, N): /* as x{1,n}? */
+ case REP(0, INF): /* as x{1,}? */
+ /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
+ INSERT(OCH_, start); /* offset is wrong... */
+ repeat(p, start+1, 1, to);
+ ASTERN(OOR1, start);
+ AHEAD(start); /* ... fix it */
+ EMIT(OOR2, 0);
+ AHEAD(THERE());
+ ASTERN(O_CH, THERETHERE());
+ break;
+ case REP(1, 1): /* trivial case */
+ /* done */
+ break;
+ case REP(1, N): /* as x?x{1,n-1} */
+ /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
+ INSERT(OCH_, start);
+ ASTERN(OOR1, start);
+ AHEAD(start);
+ EMIT(OOR2, 0); /* offset very wrong... */
+ AHEAD(THERE()); /* ...so fix it */
+ ASTERN(O_CH, THERETHERE());
+ copy = dupl(p, start+1, finish+1);
+ assert(copy == finish+4);
+ repeat(p, copy, 1, to-1);
+ break;
+ case REP(1, INF): /* as x+ */
+ INSERT(OPLUS_, start);
+ ASTERN(O_PLUS, start);
+ break;
+ case REP(N, N): /* as xx{m-1,n-1} */
+ copy = dupl(p, start, finish);
+ repeat(p, copy, from-1, to-1);
+ break;
+ case REP(N, INF): /* as xx{n-1,INF} */
+ copy = dupl(p, start, finish);
+ repeat(p, copy, from-1, to);
+ break;
+ default: /* "can't happen" */
+ SETERROR(REG_ASSERT); /* just in case */
+ break;
+ }
+}
+
+/*
+ - seterr - set an error condition
+ == static int seterr(register struct parse *p, int e);
+ */
+static int /* useless but makes type checking happy */
+seterr(p, e)
+register struct parse *p;
+int e;
+{
+ if (p->error == 0) /* keep earliest error condition */
+ p->error = e;
+ p->next = nuls; /* try to bring things to a halt */
+ p->end = nuls;
+ return(0); /* make the return value well-defined */
+}
+
+/*
+ - allocset - allocate a set of characters for []
+ == static cset *allocset(register struct parse *p);
+ */
+static cset *
+allocset(p)
+register struct parse *p;
+{
+ register int no = p->g->ncsets++;
+ register size_t nc;
+ register size_t nbytes;
+ register cset *cs;
+ register size_t css = (size_t)p->g->csetsize;
+ register int i;
+
+ if (no >= p->ncsalloc) { /* need another column of space */
+ p->ncsalloc += CHAR_BIT;
+ nc = p->ncsalloc;
+ assert(nc % CHAR_BIT == 0);
+ nbytes = nc / CHAR_BIT * css;
+ if (p->g->sets == NULL)
+ p->g->sets = (cset *)malloc(nc * sizeof(cset));
+ else
+ p->g->sets = (cset *)realloc((char *)p->g->sets,
+ nc * sizeof(cset));
+ if (p->g->setbits == NULL)
+ p->g->setbits = (uch *)malloc(nbytes);
+ else {
+ p->g->setbits = (uch *)realloc((char *)p->g->setbits,
+ nbytes);
+ /* xxx this isn't right if setbits is now NULL */
+ for (i = 0; i < no; i++)
+ p->g->sets[i].ptr = p->g->setbits + css*(i/CHAR_BIT);
+ }
+ if (p->g->sets != NULL && p->g->setbits != NULL)
+ (void) memset((char *)p->g->setbits + (nbytes - css),
+ 0, css);
+ else {
+ no = 0;
+ SETERROR(REG_ESPACE);
+ /* caller's responsibility not to do set ops */
+ }
+ }
+
+ assert(p->g->sets != NULL); /* xxx */
+ cs = &p->g->sets[no];
+ cs->ptr = p->g->setbits + css*((no)/CHAR_BIT);
+ cs->mask = 1 << ((no) % CHAR_BIT);
+ cs->hash = 0;
+ cs->smultis = 0;
+ cs->multis = NULL;
+
+ return(cs);
+}
+
+/*
+ - freeset - free a now-unused set
+ == static void freeset(register struct parse *p, register cset *cs);
+ */
+static void
+freeset(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ register int i;
+ register cset *top = &p->g->sets[p->g->ncsets];
+ register size_t css = (size_t)p->g->csetsize;
+
+ for (i = 0; i < css; i++)
+ CHsub(cs, i);
+ if (cs == top-1) /* recover only the easy case */
+ p->g->ncsets--;
+}
+
+/*
+ - freezeset - final processing on a set of characters
+ == static int freezeset(register struct parse *p, register cset *cs);
+ *
+ * The main task here is merging identical sets. This is usually a waste
+ * of time (although the hash code minimizes the overhead), but can win
+ * big if REG_ICASE is being used. REG_ICASE, by the way, is why the hash
+ * is done using addition rather than xor -- all ASCII [aA] sets xor to
+ * the same value!
+ */
+static int /* set number */
+freezeset(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ register uch h = cs->hash;
+ register int i;
+ register cset *top = &p->g->sets[p->g->ncsets];
+ register cset *cs2;
+ register 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++)
+ if (cs2->hash == h && cs2 != cs) {
+ /* maybe */
+ for (i = 0; i < css; i++)
+ if (!!CHIN(cs2, i) != !!CHIN(cs, i))
+ break; /* no */
+ if (i == css)
+ break; /* yes */
+ }
+
+ if (cs2 < top) { /* found one */
+ freeset(p, cs);
+ cs = cs2;
+ }
+
+ return((int)(cs - p->g->sets));
+}
+
+/*
+ - firstch - return first character in a set (which must have at least one)
+ == static int firstch(register struct parse *p, register cset *cs);
+ */
+static int /* character; there is no "none" value */
+firstch(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ register int i;
+ register size_t css = (size_t)p->g->csetsize;
+
+ for (i = 0; i < css; i++)
+ if (CHIN(cs, i))
+ return((char)i);
+ assert(never);
+ return(0); /* arbitrary */
+}
+
+/*
+ - nch - number of characters in a set
+ == static int nch(register struct parse *p, register cset *cs);
+ */
+static int
+nch(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ register int i;
+ register size_t css = (size_t)p->g->csetsize;
+ register int n = 0;
+
+ for (i = 0; i < css; i++)
+ if (CHIN(cs, i))
+ n++;
+ return(n);
+}
+
+/*
+ - mcadd - add a collating element to a cset
+ == static void mcadd(register struct parse *p, register cset *cs, \
+ == register char *cp);
+ */
+static void
+mcadd(p, cs, cp)
+register struct parse *p;
+register cset *cs;
+register char *cp;
+{
+ register size_t oldend = cs->smultis;
+
+ cs->smultis += strlen(cp) + 1;
+ if (cs->multis == NULL)
+ cs->multis = malloc(cs->smultis);
+ else
+ cs->multis = realloc(cs->multis, cs->smultis);
+ if (cs->multis == NULL) {
+ SETERROR(REG_ESPACE);
+ return;
+ }
+
+ (void) strcpy(cs->multis + oldend - 1, cp);
+ cs->multis[cs->smultis - 1] = '\0';
+}
+
+/*
+ - mcsub - subtract a collating element from a cset
+ == static void mcsub(register cset *cs, register char *cp);
+ */
+/*
+static void
+mcsub(cs, cp)
+register cset *cs;
+register char *cp;
+{
+ register char *fp = mcfind(cs, cp);
+ register size_t len = strlen(fp);
+
+ assert(fp != NULL);
+ (void) memmove(fp, fp + len + 1,
+ cs->smultis - (fp + len + 1 - cs->multis));
+ cs->smultis -= len;
+
+ if (cs->smultis == 0) {
+ free(cs->multis);
+ cs->multis = NULL;
+ return;
+ }
+
+ cs->multis = realloc(cs->multis, cs->smultis);
+ assert(cs->multis != NULL);
+}
+*/
+
+/*
+ - mcin - is a collating element in a cset?
+ == static int mcin(register cset *cs, register char *cp);
+ */
+/*
+static int
+mcin(cs, cp)
+register cset *cs;
+register char *cp;
+{
+ return(mcfind(cs, cp) != NULL);
+}
+*/
+
+/*
+ - mcfind - find a collating element in a cset
+ == static char *mcfind(register cset *cs, register char *cp);
+ */
+/*
+static char *
+mcfind(cs, cp)
+register cset *cs;
+register char *cp;
+{
+ register char *p;
+
+ if (cs->multis == NULL)
+ return(NULL);
+ for (p = cs->multis; *p != '\0'; p += strlen(p) + 1)
+ if (strcmp(cp, p) == 0)
+ return(p);
+ return(NULL);
+}
+*/
+/*
+ - mcinvert - invert the list of collating elements in a cset
+ == static void mcinvert(register struct parse *p, register cset *cs);
+ *
+ * This would have to know the set of possibilities. Implementation
+ * is deferred.
+ */
+static void
+mcinvert(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ assert(cs->multis == NULL); /* xxx */
+}
+
+/*
+ - mccase - add case counterparts of the list of collating elements in a cset
+ == static void mccase(register struct parse *p, register cset *cs);
+ *
+ * This would have to know the set of possibilities. Implementation
+ * is deferred.
+ */
+static void
+mccase(p, cs)
+register struct parse *p;
+register cset *cs;
+{
+ assert(cs->multis == NULL); /* xxx */
+}
+
+/*
+ - isinsets - is this character in any sets?
+ == static int isinsets(register struct re_guts *g, int c);
+ */
+static int /* predicate */
+isinsets(g, c)
+register struct re_guts *g;
+int c;
+{
+ register uch *col;
+ register int i;
+ register int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
+ register unsigned uc = (unsigned char)c;
+
+ for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
+ if (col[uc] != 0)
+ return(1);
+ return(0);
+}
+
+/*
+ - samesets - are these two characters in exactly the same sets?
+ == static int samesets(register struct re_guts *g, int c1, int c2);
+ */
+static int /* predicate */
+samesets(g, c1, c2)
+register struct re_guts *g;
+int c1;
+int c2;
+{
+ register uch *col;
+ register int i;
+ register int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
+ register unsigned uc1 = (unsigned char)c1;
+ register unsigned uc2 = (unsigned char)c2;
+
+ for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
+ if (col[uc1] != col[uc2])
+ return(0);
+ return(1);
+}
+
+/*
+ - categorize - sort out character categories
+ == static void categorize(struct parse *p, register struct re_guts *g);
+ */
+static void
+categorize(p, g)
+struct parse *p;
+register struct re_guts *g;
+{
+ register cat_t *cats = g->categories;
+ register int c;
+ register int c2;
+ register cat_t cat;
+
+ /* avoid making error situations worse */
+ if (p->error != 0)
+ return;
+
+ for (c = CHAR_MIN; c <= CHAR_MAX; c++)
+ if (cats[c] == 0 && isinsets(g, c)) {
+ cat = g->ncategories++;
+ cats[c] = cat;
+ for (c2 = c+1; c2 <= CHAR_MAX; c2++)
+ if (cats[c2] == 0 && samesets(g, c, c2))
+ cats[c2] = cat;
+ }
+}
+
+/*
+ - dupl - emit a duplicate of a bunch of sops
+ == static sopno dupl(register struct parse *p, sopno start, sopno finish);
+ */
+static sopno /* start of duplicate */
+dupl(p, start, finish)
+register struct parse *p;
+sopno start; /* from here */
+sopno finish; /* to this less one */
+{
+ register sopno ret = HERE();
+ register sopno len = finish - start;
+
+ assert(finish >= start);
+ if (len == 0)
+ return(ret);
+ enlarge(p, p->ssize + len); /* this many unexpected additions */
+ assert(p->ssize >= p->slen + len);
+ (void) memcpy((char *)(p->strip + p->slen),
+ (char *)(p->strip + start), (size_t)len*sizeof(sop));
+ p->slen += len;
+ return(ret);
+}
+
+/*
+ - doemit - emit a strip operator
+ == static void doemit(register struct parse *p, sop op, size_t opnd);
+ *
+ * It might seem better to implement this as a macro with a function as
+ * hard-case backup, but it's just too big and messy unless there are
+ * some changes to the data structures. Maybe later.
+ */
+static void
+doemit(p, op, opnd)
+register struct parse *p;
+sop op;
+size_t opnd;
+{
+ /* avoid making error situations worse */
+ if (p->error != 0)
+ return;
+
+ /* deal with oversize operands ("can't happen", more or less) */
+ assert(opnd < 1<
+
+ /* deal with undersized strip */
+ if (p->slen >= p->ssize)
+ enlarge(p, (p->ssize+1) / 2 * 3); /* +50% */
+ assert(p->slen < p->ssize);
+
+ /* finally, it's all reduced to the easy case */
+ p->strip[p->slen++] = SOP(op, opnd);
+}
+
+/*
+ - doinsert - insert a sop into the strip
+ == static void doinsert(register struct parse *p, sop op, size_t opnd, sopno pos);
+ */
+static void
+doinsert(p, op, opnd, pos)
+register struct parse *p;
+sop op;
+size_t opnd;
+sopno pos;
+{
+ register sopno sn;
+ register sop s;
+ register int i;
+
+ /* avoid making error situations worse */
+ if (p->error != 0)
+ return;
+
+ sn = HERE();
+ EMIT(op, opnd); /* do checks, ensure space */
+ assert(HERE() == sn+1);
+ s = p->strip[sn];
+
+ /* adjust paren pointers */
+ assert(pos > 0);
+ for (i = 1; i < NPAREN; i++) {
+ if (p->pbegin[i] >= pos) {
+ p->pbegin[i]++;
+ }
+ if (p->pend[i] >= pos) {
+ p->pend[i]++;
+ }
+ }
+
+ memmove((char *)&p->strip[pos+1], (char *)&p->strip[pos],
+ (HERE()-pos-1)*sizeof(sop));
+ p->strip[pos] = s;
+}
+
+/*
+ - dofwd - complete a forward reference
+ == static void dofwd(register struct parse *p, sopno pos, sop value);
+ */
+static void
+dofwd(p, pos, value)
+register struct parse *p;
+register sopno pos;
+sop value;
+{
+ /* avoid making error situations worse */
+ if (p->error != 0)
+ return;
+
+ assert(value < 1<
+ p->strip[pos] = OP(p->strip[pos]) | value;
+}
+
+/*
+ - enlarge - enlarge the strip
+ == static void enlarge(register struct parse *p, sopno size);
+ */
+static void
+enlarge(p, size)
+register struct parse *p;
+register sopno size;
+{
+ register sop *sp;
+
+ if (p->ssize >= size)
+ return;
+
+ sp = (sop *)realloc(p->strip, size*sizeof(sop));
+ if (sp == NULL) {
+ SETERROR(REG_ESPACE);
+ return;
+ }
+ p->strip = sp;
+ p->ssize = size;
+}
+
+/*
+ - stripsnug - compact the strip
+ == static void stripsnug(register struct parse *p, register struct re_guts *g);
+ */
+static void
+stripsnug(p, g)
+register struct parse *p;
+register struct re_guts *g;
+{
+ g->nstates = p->slen;
+ g->strip = (sop *)realloc((char *)p->strip, p->slen * sizeof(sop));
+ if (g->strip == NULL) {
+ SETERROR(REG_ESPACE);
+ g->strip = p->strip;
+ }
+}
+
+/*
+ - findmust - fill in must and mlen with longest mandatory literal string
+ == static void findmust(register struct parse *p, register struct re_guts *g);
+ *
+ * This algorithm could do fancy things like analyzing the operands of |
+ * for common subsequences. Someday. This code is simple and finds most
+ * of the interesting cases.
+ *
+ * Note that must and mlen got initialized during setup.
+ */
+static void
+findmust(p, g)
+struct parse *p;
+register struct re_guts *g;
+{
+ register sop *scan;
+ sop *start;
+ register sop *newstart;
+ register sopno newlen;
+ register sop s;
+ register char *cp;
+ register sopno i;
+
+ /* avoid making error situations worse */
+ if (p->error != 0)
+ return;
+
+ /* find the longest OCHAR sequence in strip */
+ newlen = 0;
+ scan = g->strip + 1;
+ do {
+ s = *scan++;
+ switch (OP(s)) {
+ case OCHAR: /* sequence member */
+ if (newlen == 0) /* new sequence */
+ newstart = scan - 1;
+ newlen++;
+ break;
+ case OPLUS_: /* things that don't break one */
+ case OLPAREN:
+ case ORPAREN:
+ break;
+ case OQUEST_: /* things that must be skipped */
+ case OCH_:
+ scan--;
+ do {
+ scan += OPND(s);
+ s = *scan;
+ /* assert() interferes w debug printouts */
+ if (OP(s) != O_QUEST && OP(s) != O_CH &&
+ OP(s) != OOR2) {
+ g->iflags |= BAD;
+ return;
+ }
+ } while (OP(s) != O_QUEST && OP(s) != O_CH);
+ /* fallthrough */
+ default: /* things that break a sequence */
+ if (newlen > g->mlen) { /* ends one */
+ start = newstart;
+ g->mlen = newlen;
+ }
+ newlen = 0;
+ break;
+ }
+ } while (OP(s) != OEND);
+
+ if (g->mlen == 0) /* there isn't one */
+ return;
+
+ /* turn it into a character string */
+ g->must = malloc((size_t)g->mlen + 1);
+ if (g->must == NULL) { /* argh; just forget it */
+ g->mlen = 0;
+ return;
+ }
+ cp = g->must;
+ scan = start;
+ for (i = g->mlen; i > 0; i--) {
+ while (OP(s = *scan++) != OCHAR)
+ continue;
+ assert(cp < g->must + g->mlen);
+ *cp++ = (char)OPND(s);
+ }
+ assert(cp == g->must + g->mlen);
+ *cp++ = '\0'; /* just on general principles */
+}
+
+/*
+ - pluscount - count + nesting
+ == static sopno pluscount(register struct parse *p, register struct re_guts *g);
+ */
+static sopno /* nesting depth */
+pluscount(p, g)
+struct parse *p;
+register struct re_guts *g;
+{
+ register sop *scan;
+ register sop s;
+ register sopno plusnest = 0;
+ register sopno maxnest = 0;
+
+ if (p->error != 0)
+ return(0); /* there may not be an OEND */
+
+ scan = g->strip + 1;
+ do {
+ s = *scan++;
+ switch (OP(s)) {
+ case OPLUS_:
+ plusnest++;
+ break;
+ case O_PLUS:
+ if (plusnest > maxnest)
+ maxnest = plusnest;
+ plusnest--;
+ break;
+ }
+ } while (OP(s) != OEND);
+ if (plusnest != 0)
+ g->iflags |= BAD;
+ return(maxnest);
+}
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)regerror.c 8.4 (Berkeley) 3/20/94
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)regerror.c 8.4 (Berkeley) 3/20/94";
+#endif /* LIBC_SCCS and not lint */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "utils.h"
+
+/* ========= begin header generated by ./mkh ========= */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* === regerror.c === */
+static char *regatoi __P((const regex_t *preg, char *localbuf));
+
+#ifdef __cplusplus
+}
+#endif
+/* ========= end header generated by ./mkh ========= */
+/*
+ = #define REG_NOMATCH 1
+ = #define REG_BADPAT 2
+ = #define REG_ECOLLATE 3
+ = #define REG_ECTYPE 4
+ = #define REG_EESCAPE 5
+ = #define REG_ESUBREG 6
+ = #define REG_EBRACK 7
+ = #define REG_EPAREN 8
+ = #define REG_EBRACE 9
+ = #define REG_BADBR 10
+ = #define REG_ERANGE 11
+ = #define REG_ESPACE 12
+ = #define REG_BADRPT 13
+ = #define REG_EMPTY 14
+ = #define REG_ASSERT 15
+ = #define REG_INVARG 16
+ = #define REG_ATOI 255 // convert name to number (!)
+ = #define REG_ITOA 0400 // convert number to name (!)
+ */
+static struct rerr {
+ int code;
+ char *name;
+ char *explain;
+} rerrs[] = {
+ {REG_NOMATCH, "REG_NOMATCH", "regexec() failed to match"},
+ {REG_BADPAT, "REG_BADPAT", "invalid regular expression"},
+ {REG_ECOLLATE, "REG_ECOLLATE", "invalid collating element"},
+ {REG_ECTYPE, "REG_ECTYPE", "invalid character class"},
+ {REG_EESCAPE, "REG_EESCAPE", "trailing backslash (\\)"},
+ {REG_ESUBREG, "REG_ESUBREG", "invalid backreference number"},
+ {REG_EBRACK, "REG_EBRACK", "brackets ([ ]) not balanced"},
+ {REG_EPAREN, "REG_EPAREN", "parentheses not balanced"},
+ {REG_EBRACE, "REG_EBRACE", "braces not balanced"},
+ {REG_BADBR, "REG_BADBR", "invalid repetition count(s)"},
+ {REG_ERANGE, "REG_ERANGE", "invalid character range"},
+ {REG_ESPACE, "REG_ESPACE", "out of memory"},
+ {REG_BADRPT, "REG_BADRPT", "repetition-operator operand invalid"},
+ {REG_EMPTY, "REG_EMPTY", "empty (sub)expression"},
+ {REG_ASSERT, "REG_ASSERT", "\"can't happen\" -- you found a bug"},
+ {REG_INVARG, "REG_INVARG", "invalid argument to regex routine"},
+ {0, "", "*** unknown regexp error code ***"}
+};
+
+/*
+ - regerror - the interface to error numbers
+ = extern size_t regerror(int, const regex_t *, char *, size_t);
+ */
+/* ARGSUSED */
+size_t
+pg95_regerror(errcode, preg, errbuf, errbuf_size)
+int errcode;
+const regex_t *preg;
+char *errbuf;
+size_t errbuf_size;
+{
+ register struct rerr *r;
+ register size_t len;
+ register int target = errcode &~ REG_ITOA;
+ register char *s;
+ char convbuf[50];
+
+ if (errcode == REG_ATOI)
+ s = regatoi(preg, convbuf);
+ else {
+ for (r = rerrs; r->code != 0; r++)
+ if (r->code == target)
+ break;
+
+ if (errcode®_ITOA) {
+ if (r->code != 0)
+ (void) strcpy(convbuf, r->name);
+ else
+ sprintf(convbuf, "REG_0x%x", target);
+ assert(strlen(convbuf) < sizeof(convbuf));
+ s = convbuf;
+ } else
+ s = r->explain;
+ }
+
+ len = strlen(s) + 1;
+ if (errbuf_size > 0) {
+ if (errbuf_size > len)
+ (void) strcpy(errbuf, s);
+ else {
+ (void) strncpy(errbuf, s, errbuf_size-1);
+ errbuf[errbuf_size-1] = '\0';
+ }
+ }
+
+ return(len);
+}
+
+/*
+ - regatoi - internal routine to implement REG_ATOI
+ == static char *regatoi(const regex_t *preg, char *localbuf);
+ */
+static char *
+regatoi(preg, localbuf)
+const regex_t *preg;
+char *localbuf;
+{
+ register struct rerr *r;
+
+ for (r = rerrs; r->code != 0; r++)
+ if (strcmp(r->name, preg->re_endp) == 0)
+ break;
+ if (r->code == 0)
+ return("0");
+
+ sprintf(localbuf, "%d", r->code);
+ return(localbuf);
+}
--- /dev/null
+.\" Copyright (c) 1992, 1993, 1994 Henry Spencer.
+.\" Copyright (c) 1992, 1993, 1994
+.\" The Regents of the University of California. All rights reserved.
+.\"
+.\" This code is derived from software contributed to Berkeley by
+.\" Henry Spencer.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\" notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\" notice, this list of conditions and the following disclaimer in the
+.\" documentation and/or other materials provided with the distribution.
+.\" 3. All advertising materials mentioning features or use of this software
+.\" must display the following acknowledgement:
+.\" This product includes software developed by the University of
+.\" California, Berkeley and its contributors.
+.\" 4. Neither the name of the University nor the names of its contributors
+.\" may be used to endorse or promote products derived from this software
+.\" without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\" @(#)regex.3 8.4 (Berkeley) 3/20/94
+.\"
+.TH REGEX 3 "March 20, 1994"
+.de ZR
+.\" one other place knows this name: the SEE ALSO section
+.IR re_format (7) \\$1
+..
+.SH NAME
+regcomp, regexec, regerror, regfree \- regular-expression library
+.SH SYNOPSIS
+.ft B
+.\".na
+#include
+.br
+#include
+.HP 10
+int regcomp(regex_t\ *preg, const\ char\ *pattern, int\ cflags);
+.HP
+int\ regexec(const\ regex_t\ *preg, const\ char\ *string,
+size_t\ nmatch, regmatch_t\ pmatch[], int\ eflags);
+.HP
+size_t\ regerror(int\ errcode, const\ regex_t\ *preg,
+char\ *errbuf, size_t\ errbuf_size);
+.HP
+void\ regfree(regex_t\ *preg);
+.\".ad
+.ft
+.SH DESCRIPTION
+These routines implement POSIX 1003.2 regular expressions (``RE''s);
+see
+.ZR .
+.I Regcomp
+compiles an RE written as a string into an internal form,
+.I regexec
+matches that internal form against a string and reports results,
+.I regerror
+transforms error codes from either into human-readable messages,
+and
+.I regfree
+frees any dynamically-allocated storage used by the internal form
+of an RE.
+.PP
+The header
+.I
+declares two structure types,
+.I regex_t
+and
+.IR regmatch_t ,
+the former for compiled internal forms and the latter for match reporting.
+It also declares the four functions,
+a type
+.IR regoff_t ,
+and a number of constants with names starting with ``REG_''.
+.PP
+.I Regcomp
+compiles the regular expression contained in the
+.I pattern
+string,
+subject to the flags in
+.IR cflags ,
+and places the results in the
+.I regex_t
+structure pointed to by
+.IR preg .
+.I Cflags
+is the bitwise OR of zero or more of the following flags:
+.IP REG_EXTENDED \w'REG_EXTENDED'u+2n
+Compile modern (``extended'') REs,
+rather than the obsolete (``basic'') REs that
+are the default.
+.IP REG_BASIC
+This is a synonym for 0,
+provided as a counterpart to REG_EXTENDED to improve readability.
+.IP REG_NOSPEC
+Compile with recognition of all special characters turned off.
+All characters are thus considered ordinary,
+so the ``RE'' is a literal string.
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+REG_EXTENDED and REG_NOSPEC may not be used
+in the same call to
+.IR regcomp .
+.IP REG_ICASE
+Compile for matching that ignores upper/lower case distinctions.
+See
+.ZR .
+.IP REG_NOSUB
+Compile for matching that need only report success or failure,
+not what was matched.
+.IP REG_NEWLINE
+Compile for newline-sensitive matching.
+By default, newline is a completely ordinary character with no special
+meaning in either REs or strings.
+With this flag,
+`[^' bracket expressions and `.' never match newline,
+a `^' anchor matches the null string after any newline in the string
+in addition to its normal function,
+and the `$' anchor matches the null string before any newline in the
+string in addition to its normal function.
+.IP REG_PEND
+The regular expression ends,
+not at the first NUL,
+but just before the character pointed to by the
+.I re_endp
+member of the structure pointed to by
+.IR preg .
+The
+.I re_endp
+member is of type
+.IR const\ char\ * .
+This flag permits inclusion of NULs in the RE;
+they are considered ordinary characters.
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+.PP
+When successful,
+.I regcomp
+returns 0 and fills in the structure pointed to by
+.IR preg .
+One member of that structure
+(other than
+.IR re_endp )
+is publicized:
+.IR re_nsub ,
+of type
+.IR size_t ,
+contains the number of parenthesized subexpressions within the RE
+(except that the value of this member is undefined if the
+REG_NOSUB flag was used).
+If
+.I regcomp
+fails, it returns a non-zero error code;
+see DIAGNOSTICS.
+.PP
+.I Regexec
+matches the compiled RE pointed to by
+.I preg
+against the
+.IR string ,
+subject to the flags in
+.IR eflags ,
+and reports results using
+.IR nmatch ,
+.IR pmatch ,
+and the returned value.
+The RE must have been compiled by a previous invocation of
+.IR regcomp .
+The compiled form is not altered during execution of
+.IR regexec ,
+so a single compiled RE can be used simultaneously by multiple threads.
+.PP
+By default,
+the NUL-terminated string pointed to by
+.I string
+is considered to be the text of an entire line, minus any terminating
+newline.
+The
+.I eflags
+argument is the bitwise OR of zero or more of the following flags:
+.IP REG_NOTBOL \w'REG_STARTEND'u+2n
+The first character of
+the string
+is not the beginning of a line, so the `^' anchor should not match before it.
+This does not affect the behavior of newlines under REG_NEWLINE.
+.IP REG_NOTEOL
+The NUL terminating
+the string
+does not end a line, so the `$' anchor should not match before it.
+This does not affect the behavior of newlines under REG_NEWLINE.
+.IP REG_STARTEND
+The string is considered to start at
+\fIstring\fR\ + \fIpmatch\fR[0].\fIrm_so\fR
+and to have a terminating NUL located at
+\fIstring\fR\ + \fIpmatch\fR[0].\fIrm_eo\fR
+(there need not actually be a NUL at that location),
+regardless of the value of
+.IR nmatch .
+See below for the definition of
+.IR pmatch
+and
+.IR nmatch .
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+Note that a non-zero \fIrm_so\fR does not imply REG_NOTBOL;
+REG_STARTEND affects only the location of the string,
+not how it is matched.
+.PP
+See
+.ZR
+for a discussion of what is matched in situations where an RE or a
+portion thereof could match any of several substrings of
+.IR string .
+.PP
+Normally,
+.I regexec
+returns 0 for success and the non-zero code REG_NOMATCH for failure.
+Other non-zero error codes may be returned in exceptional situations;
+see DIAGNOSTICS.
+.PP
+If REG_NOSUB was specified in the compilation of the RE,
+or if
+.I nmatch
+is 0,
+.I regexec
+ignores the
+.I pmatch
+argument (but see below for the case where REG_STARTEND is specified).
+Otherwise,
+.I pmatch
+points to an array of
+.I nmatch
+structures of type
+.IR regmatch_t .
+Such a structure has at least the members
+.I rm_so
+and
+.IR rm_eo ,
+both of type
+.I regoff_t
+(a signed arithmetic type at least as large as an
+.I off_t
+and a
+.IR ssize_t ),
+containing respectively the offset of the first character of a substring
+and the offset of the first character after the end of the substring.
+Offsets are measured from the beginning of the
+.I string
+argument given to
+.IR regexec .
+An empty substring is denoted by equal offsets,
+both indicating the character following the empty substring.
+.PP
+The 0th member of the
+.I pmatch
+array is filled in to indicate what substring of
+.I string
+was matched by the entire RE.
+Remaining members report what substring was matched by parenthesized
+subexpressions within the RE;
+member
+.I i
+reports subexpression
+.IR i ,
+with subexpressions counted (starting at 1) by the order of their opening
+parentheses in the RE, left to right.
+Unused entries in the array\(emcorresponding either to subexpressions that
+did not participate in the match at all, or to subexpressions that do not
+exist in the RE (that is, \fIi\fR\ > \fIpreg\fR\->\fIre_nsub\fR)\(emhave both
+.I rm_so
+and
+.I rm_eo
+set to \-1.
+If a subexpression participated in the match several times,
+the reported substring is the last one it matched.
+(Note, as an example in particular, that when the RE `(b*)+' matches `bbb',
+the parenthesized subexpression matches each of the three `b's and then
+an infinite number of empty strings following the last `b',
+so the reported substring is one of the empties.)
+.PP
+If REG_STARTEND is specified,
+.I pmatch
+must point to at least one
+.I regmatch_t
+(even if
+.I nmatch
+is 0 or REG_NOSUB was specified),
+to hold the input offsets for REG_STARTEND.
+Use for output is still entirely controlled by
+.IR nmatch ;
+if
+.I nmatch
+is 0 or REG_NOSUB was specified,
+the value of
+.IR pmatch [0]
+will not be changed by a successful
+.IR regexec .
+.PP
+.I Regerror
+maps a non-zero
+.I errcode
+from either
+.I regcomp
+or
+.I regexec
+to a human-readable, printable message.
+If
+.I preg
+is non-NULL,
+the error code should have arisen from use of
+the
+.I regex_t
+pointed to by
+.IR preg ,
+and if the error code came from
+.IR regcomp ,
+it should have been the result from the most recent
+.I regcomp
+using that
+.IR regex_t .
+.RI ( Regerror
+may be able to supply a more detailed message using information
+from the
+.IR regex_t .)
+.I Regerror
+places the NUL-terminated message into the buffer pointed to by
+.IR errbuf ,
+limiting the length (including the NUL) to at most
+.I errbuf_size
+bytes.
+If the whole message won't fit,
+as much of it as will fit before the terminating NUL is supplied.
+In any case,
+the returned value is the size of buffer needed to hold the whole
+message (including terminating NUL).
+If
+.I errbuf_size
+is 0,
+.I errbuf
+is ignored but the return value is still correct.
+.PP
+If the
+.I errcode
+given to
+.I regerror
+is first ORed with REG_ITOA,
+the ``message'' that results is the printable name of the error code,
+e.g. ``REG_NOMATCH'',
+rather than an explanation thereof.
+If
+.I errcode
+is REG_ATOI,
+then
+.I preg
+shall be non-NULL and the
+.I re_endp
+member of the structure it points to
+must point to the printable name of an error code;
+in this case, the result in
+.I errbuf
+is the decimal digits of
+the numeric value of the error code
+(0 if the name is not recognized).
+REG_ITOA and REG_ATOI are intended primarily as debugging facilities;
+they are extensions,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+Be warned also that they are considered experimental and changes are possible.
+.PP
+.I Regfree
+frees any dynamically-allocated storage associated with the compiled RE
+pointed to by
+.IR preg .
+The remaining
+.I regex_t
+is no longer a valid compiled RE
+and the effect of supplying it to
+.I regexec
+or
+.I regerror
+is undefined.
+.PP
+None of these functions references global variables except for tables
+of constants;
+all are safe for use from multiple threads if the arguments are safe.
+.SH IMPLEMENTATION CHOICES
+There are a number of decisions that 1003.2 leaves up to the implementor,
+either by explicitly saying ``undefined'' or by virtue of them being
+forbidden by the RE grammar.
+This implementation treats them as follows.
+.PP
+See
+.ZR
+for a discussion of the definition of case-independent matching.
+.PP
+There is no particular limit on the length of REs,
+except insofar as memory is limited.
+Memory usage is approximately linear in RE size, and largely insensitive
+to RE complexity, except for bounded repetitions.
+See BUGS for one short RE using them
+that will run almost any system out of memory.
+.PP
+A backslashed character other than one specifically given a magic meaning
+by 1003.2 (such magic meanings occur only in obsolete [``basic''] REs)
+is taken as an ordinary character.
+.PP
+Any unmatched [ is a REG_EBRACK error.
+.PP
+Equivalence classes cannot begin or end bracket-expression ranges.
+The endpoint of one range cannot begin another.
+.PP
+RE_DUP_MAX, the limit on repetition counts in bounded repetitions, is 255.
+.PP
+A repetition operator (?, *, +, or bounds) cannot follow another
+repetition operator.
+A repetition operator cannot begin an expression or subexpression
+or follow `^' or `|'.
+.PP
+`|' cannot appear first or last in a (sub)expression or after another `|',
+i.e. an operand of `|' cannot be an empty subexpression.
+An empty parenthesized subexpression, `()', is legal and matches an
+empty (sub)string.
+An empty string is not a legal RE.
+.PP
+A `{' followed by a digit is considered the beginning of bounds for a
+bounded repetition, which must then follow the syntax for bounds.
+A `{' \fInot\fR followed by a digit is considered an ordinary character.
+.PP
+`^' and `$' beginning and ending subexpressions in obsolete (``basic'')
+REs are anchors, not ordinary characters.
+.SH SEE ALSO
+grep(1), re_format(7)
+.PP
+POSIX 1003.2, sections 2.8 (Regular Expression Notation)
+and
+B.5 (C Binding for Regular Expression Matching).
+.SH DIAGNOSTICS
+Non-zero error codes from
+.I regcomp
+and
+.I regexec
+include the following:
+.PP
+.nf
+.ta \w'REG_ECOLLATE'u+3n
+REG_NOMATCH regexec() failed to match
+REG_BADPAT invalid regular expression
+REG_ECOLLATE invalid collating element
+REG_ECTYPE invalid character class
+REG_EESCAPE \e applied to unescapable character
+REG_ESUBREG invalid backreference number
+REG_EBRACK brackets [ ] not balanced
+REG_EPAREN parentheses ( ) not balanced
+REG_EBRACE braces { } not balanced
+REG_BADBR invalid repetition count(s) in { }
+REG_ERANGE invalid character range in [ ]
+REG_ESPACE ran out of memory
+REG_BADRPT ?, *, or + operand invalid
+REG_EMPTY empty (sub)expression
+REG_ASSERT ``can't happen''\(emyou found a bug
+REG_INVARG invalid argument, e.g. negative-length string
+.fi
+.SH HISTORY
+Originally written by Henry Spencer.
+Altered for inclusion in the 4.4BSD distribution.
+.SH BUGS
+This is an alpha release with known defects.
+Please report problems.
+.PP
+There is one known functionality bug.
+The implementation of internationalization is incomplete:
+the locale is always assumed to be the default one of 1003.2,
+and only the collating elements etc. of that locale are available.
+.PP
+The back-reference code is subtle and doubts linger about its correctness
+in complex cases.
+.PP
+.I Regexec
+performance is poor.
+This will improve with later releases.
+.I Nmatch
+exceeding 0 is expensive;
+.I nmatch
+exceeding 1 is worse.
+.I Regexec
+is largely insensitive to RE complexity \fIexcept\fR that back
+references are massively expensive.
+RE length does matter; in particular, there is a strong speed bonus
+for keeping RE length under about 30 characters,
+with most special characters counting roughly double.
+.PP
+.I Regcomp
+implements bounded repetitions by macro expansion,
+which is costly in time and space if counts are large
+or bounded repetitions are nested.
+An RE like, say,
+`((((a{1,100}){1,100}){1,100}){1,100}){1,100}'
+will (eventually) run almost any existing machine out of swap space.
+.PP
+There are suspected problems with response to obscure error conditions.
+Notably,
+certain kinds of internal overflow,
+produced only by truly enormous REs or by multiply nested bounded repetitions,
+are probably not handled well.
+.PP
+Due to a mistake in 1003.2, things like `a)b' are legal REs because `)' is
+a special character only in the presence of a previous unmatched `('.
+This can't be fixed until the spec is fixed.
+.PP
+The standard's definition of back references is vague.
+For example, does
+`a\e(\e(b\e)*\e2\e)*d' match `abbbd'?
+Until the standard is clarified,
+behavior in such cases should not be relied on.
+.PP
+The implementation of word-boundary matching is a bit of a kludge,
+and bugs may lurk in combinations of word-boundary matching and anchoring.
--- /dev/null
+/*-
+ * Copyright (c) 1992 Henry Spencer.
+ * Copyright (c) 1992, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer of the University of Toronto.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)regex.h 8.2 (Berkeley) 1/3/94
+ */
+
+#ifndef _REGEX_H_
+#define _REGEX_H_
+
+/* #include */
+/* since not all systems have cdefs.h, we'll use our own here - jolly */
+#include "cdefs.h"
+
+/* types */
+typedef off_t regoff_t;
+
+typedef struct {
+ int re_magic;
+ size_t re_nsub; /* number of parenthesized subexpressions */
+ __const char *re_endp; /* end pointer for REG_PEND */
+ struct re_guts *re_g; /* none of your business :-) */
+} regex_t;
+
+typedef struct {
+ regoff_t rm_so; /* start of match */
+ regoff_t rm_eo; /* end of match */
+} regmatch_t;
+
+/* regcomp() flags */
+#define REG_BASIC 0000
+#define REG_EXTENDED 0001
+#define REG_ICASE 0002
+#define REG_NOSUB 0004
+#define REG_NEWLINE 0010
+#define REG_NOSPEC 0020
+#define REG_PEND 0040
+#define REG_DUMP 0200
+
+/* regerror() flags */
+#define REG_NOMATCH 1
+#define REG_BADPAT 2
+#define REG_ECOLLATE 3
+#define REG_ECTYPE 4
+#define REG_EESCAPE 5
+#define REG_ESUBREG 6
+#define REG_EBRACK 7
+#define REG_EPAREN 8
+#define REG_EBRACE 9
+#define REG_BADBR 10
+#define REG_ERANGE 11
+#define REG_ESPACE 12
+#define REG_BADRPT 13
+#define REG_EMPTY 14
+#define REG_ASSERT 15
+#define REG_INVARG 16
+#define REG_ATOI 255 /* convert name to number (!) */
+#define REG_ITOA 0400 /* convert number to name (!) */
+
+/* regexec() flags */
+#define REG_NOTBOL 00001
+#define REG_NOTEOL 00002
+#define REG_STARTEND 00004
+#define REG_TRACE 00400 /* tracing of execution */
+#define REG_LARGE 01000 /* force large representation */
+#define REG_BACKR 02000 /* force use of backref code */
+
+__BEGIN_DECLS
+int pg95_regcomp __P((regex_t *, const char *, int));
+size_t pg95_regerror __P((int, const regex_t *, char *, size_t));
+int pg95_regexec __P((const regex_t *,
+ const char *, size_t, regmatch_t [], int));
+void pg95_regfree __P((regex_t *));
+__END_DECLS
+
+#endif /* !_REGEX_H_ */
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)regex2.h 8.4 (Berkeley) 3/20/94
+ */
+
+/*
+ * First, the stuff that ends up in the outside-world include file
+*/
+/*
+ typedef off_t regoff_t;
+ typedef struct {
+ int re_magic;
+ size_t re_nsub; // number of parenthesized subexpressions
+ const char *re_endp; // end pointer for REG_PEND
+ struct re_guts *re_g; // none of your business :-)
+ } regex_t;
+ typedef struct {
+ regoff_t rm_so; // start of match
+ regoff_t rm_eo; // end of match
+ } regmatch_t;
+*/
+/*
+ * internals of regex_t
+ */
+#define MAGIC1 ((('r'^0200)<<8) | 'e')
+
+/*
+ * The internal representation is a *strip*, a sequence of
+ * operators ending with an endmarker. (Some terminology etc. is a
+ * historical relic of earlier versions which used multiple strips.)
+ * Certain oddities in the representation are there to permit running
+ * the machinery backwards; in particular, any deviation from sequential
+ * flow must be marked at both its source and its destination. Some
+ * fine points:
+ *
+ * - OPLUS_ and O_PLUS are *inside* the loop they create.
+ * - OQUEST_ and O_QUEST are *outside* the bypass they create.
+ * - OCH_ and O_CH are *outside* the multi-way branch they create, while
+ * OOR1 and OOR2 are respectively the end and the beginning of one of
+ * the branches. Note that there is an implicit OOR2 following OCH_
+ * and an implicit OOR1 preceding O_CH.
+ *
+ * In state representations, an operator's bit is on to signify a state
+ * immediately *preceding* "execution" of that operator.
+ */
+typedef unsigned long sop; /* strip operator */
+typedef long sopno;
+#define OPRMASK 0xf8000000
+#define OPDMASK 0x07ffffff
+#define OPSHIFT ((unsigned)27)
+#define OP(n) ((n)&OPRMASK)
+#define OPND(n) ((n)&OPDMASK)
+#define SOP(op, opnd) ((op)|(opnd))
+/* operators meaning operand */
+/* (back, fwd are offsets) */
+#define OEND (1<
+#define OCHAR (2<
+#define OBOL (3<
+#define OEOL (4<
+#define OANY (5<
+#define OANYOF (6<
+#define OBACK_ (7<
+#define O_BACK (8<
+#define OPLUS_ (9<
+#define O_PLUS (10<
+#define OQUEST_ (11<
+#define O_QUEST (12<
+#define OLPAREN (13<
+#define ORPAREN (14<
+#define OCH_ (15<
+#define OOR1 (16<
+#define OOR2 (17<
+#define O_CH (18<
+#define OBOW (19<
+#define OEOW (20<
+
+/*
+ * Structure for [] character-set representation. Character sets are
+ * done as bit vectors, grouped 8 to a byte vector for compactness.
+ * The individual set therefore has both a pointer to the byte vector
+ * and a mask to pick out the relevant bit of each byte. A hash code
+ * simplifies testing whether two sets could be identical.
+ *
+ * This will get trickier for multicharacter collating elements. As
+ * preliminary hooks for dealing with such things, we also carry along
+ * a string of multi-character elements, and decide the size of the
+ * vectors at run time.
+ */
+typedef struct {
+ uch *ptr; /* -> uch [csetsize] */
+ uch mask; /* bit within array */
+ uch hash; /* hash code */
+ size_t smultis;
+ char *multis; /* -> char[smulti] ab\0cd\0ef\0\0 */
+} cset;
+/* note that CHadd and CHsub are unsafe, and CHIN doesn't yield 0/1 */
+#define CHadd(cs, c) ((cs)->ptr[(uch)(c)] |= (cs)->mask, (cs)->hash += (c))
+#define CHsub(cs, c) ((cs)->ptr[(uch)(c)] &= ~(cs)->mask, (cs)->hash -= (c))
+#define CHIN(cs, c) ((cs)->ptr[(uch)(c)] & (cs)->mask)
+#define MCadd(p, cs, cp) mcadd(p, cs, cp) /* regcomp() internal fns */
+#define MCsub(p, cs, cp) mcsub(p, cs, cp)
+#define MCin(p, cs, cp) mcin(p, cs, cp)
+
+/* stuff for character categories */
+typedef unsigned char cat_t;
+
+/*
+ * main compiled-expression structure
+ */
+struct re_guts {
+ int magic;
+# define MAGIC2 ((('R'^0200)<<8)|'E')
+ sop *strip; /* malloced area for strip */
+ int csetsize; /* number of bits in a cset vector */
+ int ncsets; /* number of csets in use */
+ cset *sets; /* -> cset [ncsets] */
+ uch *setbits; /* -> uch[csetsize][ncsets/CHAR_BIT] */
+ int cflags; /* copy of regcomp() cflags argument */
+ sopno nstates; /* = number of sops */
+ sopno firststate; /* the initial OEND (normally 0) */
+ sopno laststate; /* the final OEND */
+ int iflags; /* internal flags */
+# define USEBOL 01 /* used ^ */
+# define USEEOL 02 /* used $ */
+# define BAD 04 /* something wrong */
+ int nbol; /* number of ^ used */
+ int neol; /* number of $ used */
+ int ncategories; /* how many character categories */
+ cat_t *categories; /* ->catspace[-CHAR_MIN] */
+ char *must; /* match must contain this string */
+ int mlen; /* length of must */
+ size_t nsub; /* copy of re_nsub */
+ int backrefs; /* does it use back references? */
+ sopno nplus; /* how deep does it nest +s? */
+ /* catspace must be last */
+ cat_t catspace[1]; /* actually [NC] */
+};
+
+/* misc utilities */
+#define OUT (CHAR_MAX+1) /* a non-character value */
+#define ISWORD(c) (isalnum(c) || (c) == '_')
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)regexec.c 8.3 (Berkeley) 3/20/94
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)regexec.c 8.3 (Berkeley) 3/20/94";
+#endif /* LIBC_SCCS and not lint */
+
+/*
+ * the outer shell of regexec()
+ *
+ * This file includes engine.c *twice*, after muchos fiddling with the
+ * macros that code uses. This lets the same code operate on two different
+ * representations for state sets.
+ */
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "utils.h"
+#include "regex2.h"
+
+static int nope = 0; /* for use in asserts; shuts lint up */
+
+/* macros for manipulating states, small version */
+#define states long
+#define states1 states /* for later use in regexec() decision */
+#define CLEAR(v) ((v) = 0)
+#define SET0(v, n) ((v) &= ~(1 << (n)))
+#define SET1(v, n) ((v) |= 1 << (n))
+#define ISSET(v, n) ((v) & (1 << (n)))
+#define ASSIGN(d, s) ((d) = (s))
+#define EQ(a, b) ((a) == (b))
+#define STATEVARS int dummy /* dummy version */
+#define STATESETUP(m, n) /* nothing */
+#define STATETEARDOWN(m) /* nothing */
+#define SETUP(v) ((v) = 0)
+#define onestate int
+#define INIT(o, n) ((o) = (unsigned)1 << (n))
+#define INC(o) ((o) <<= 1)
+#define ISSTATEIN(v, o) ((v) & (o))
+/* some abbreviations; note that some of these know variable names! */
+/* do "if I'm here, I can also be there" etc without branches */
+#define FWD(dst, src, n) ((dst) |= ((unsigned)(src)&(here)) << (n))
+#define BACK(dst, src, n) ((dst) |= ((unsigned)(src)&(here)) >> (n))
+#define ISSETBACK(v, n) ((v) & ((unsigned)here >> (n)))
+/* function names */
+#define SNAMES /* engine.c looks after details */
+
+#include "engine.c"
+
+/* now undo things */
+#undef states
+#undef CLEAR
+#undef SET0
+#undef SET1
+#undef ISSET
+#undef ASSIGN
+#undef EQ
+#undef STATEVARS
+#undef STATESETUP
+#undef STATETEARDOWN
+#undef SETUP
+#undef onestate
+#undef INIT
+#undef INC
+#undef ISSTATEIN
+#undef FWD
+#undef BACK
+#undef ISSETBACK
+#undef SNAMES
+
+/* macros for manipulating states, large version */
+#define states char *
+#define CLEAR(v) memset(v, 0, m->g->nstates)
+#define SET0(v, n) ((v)[n] = 0)
+#define SET1(v, n) ((v)[n] = 1)
+#define ISSET(v, n) ((v)[n])
+#define ASSIGN(d, s) memcpy(d, s, m->g->nstates)
+#define EQ(a, b) (memcmp(a, b, m->g->nstates) == 0)
+#define STATEVARS int vn; char *space
+#define STATESETUP(m, nv) { (m)->space = malloc((nv)*(m)->g->nstates); \
+ if ((m)->space == NULL) return(REG_ESPACE); \
+ (m)->vn = 0; }
+#define STATETEARDOWN(m) { free((m)->space); }
+#define SETUP(v) ((v) = &m->space[m->vn++ * m->g->nstates])
+#define onestate int
+#define INIT(o, n) ((o) = (n))
+#define INC(o) ((o)++)
+#define ISSTATEIN(v, o) ((v)[o])
+/* some abbreviations; note that some of these know variable names! */
+/* do "if I'm here, I can also be there" etc without branches */
+#define FWD(dst, src, n) ((dst)[here+(n)] |= (src)[here])
+#define BACK(dst, src, n) ((dst)[here-(n)] |= (src)[here])
+#define ISSETBACK(v, n) ((v)[here - (n)])
+/* function names */
+#define LNAMES /* flag */
+
+#include "engine.c"
+
+/*
+ - regexec - interface for matching
+ = extern int regexec(const regex_t *, const char *, size_t, \
+ = regmatch_t [], int);
+ = #define REG_NOTBOL 00001
+ = #define REG_NOTEOL 00002
+ = #define REG_STARTEND 00004
+ = #define REG_TRACE 00400 // tracing of execution
+ = #define REG_LARGE 01000 // force large representation
+ = #define REG_BACKR 02000 // force use of backref code
+ *
+ * We put this here so we can exploit knowledge of the state representation
+ * when choosing which matcher to call. Also, by this point the matchers
+ * have been prototyped.
+ */
+int /* 0 success, REG_NOMATCH failure */
+pg95_regexec(preg, string, nmatch, pmatch, eflags)
+const regex_t *preg;
+const char *string;
+size_t nmatch;
+regmatch_t pmatch[];
+int eflags;
+{
+ register struct re_guts *g = preg->re_g;
+#ifdef REDEBUG
+# define GOODFLAGS(f) (f)
+#else
+# define GOODFLAGS(f) ((f)&(REG_NOTBOL|REG_NOTEOL|REG_STARTEND))
+#endif
+
+ if (preg->re_magic != MAGIC1 || g->magic != MAGIC2)
+ return(REG_BADPAT);
+ assert(!(g->iflags&BAD));
+ if (g->iflags&BAD) /* backstop for no-debug case */
+ return(REG_BADPAT);
+ eflags = GOODFLAGS(eflags);
+
+ if (g->nstates <= CHAR_BIT*sizeof(states1) && !(eflags®_LARGE))
+ return(smatcher(g, (char *)string, nmatch, pmatch, eflags));
+ else
+ return(lmatcher(g, (char *)string, nmatch, pmatch, eflags));
+}
--- /dev/null
+/*
+ * Copyright (c) 1986 by University of Toronto.
+ * Copyright (c) 1989, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley
+ * by Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)regexp.h 8.1 (Berkeley) 6/2/93
+ */
+
+#ifndef _REGEXP_H_
+#define _REGEXP_H_
+
+/*
+ * Definitions etc. for regexp(3) routines.
+ *
+ * Caveat: this is V8 regexp(3) [actually, a reimplementation thereof],
+ * not the System V one.
+ */
+#define NSUBEXP 10
+typedef struct regexp {
+ char *startp[NSUBEXP];
+ char *endp[NSUBEXP];
+ char regstart; /* Internal use only. */
+ char reganch; /* Internal use only. */
+ char *regmust; /* Internal use only. */
+ int regmlen; /* Internal use only. */
+ char program[1]; /* Unwarranted chumminess with compiler. */
+} regexp;
+
+/* #include */
+/* since not all systems have cdefs.h, we'll use our own here - jolly */
+#include "cdefs.h"
+
+__BEGIN_DECLS
+regexp *pg95_regcomp __P((const char *));
+int pg95_regexec __P((const regexp *, const char *));
+void pg95_regsub __P((const regexp *, const char *, char *));
+void pg95_regerror __P((const char *));
+__END_DECLS
+
+#endif /* !_REGEXP_H_ */
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)regfree.c 8.3 (Berkeley) 3/20/94
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)regfree.c 8.3 (Berkeley) 3/20/94";
+#endif /* LIBC_SCCS and not lint */
+
+#include
+#include
+#include
+#include
+
+#include "utils.h"
+#include "regex2.h"
+
+/*
+ - regfree - free everything
+ = extern void regfree(regex_t *);
+ */
+void
+pg95_regfree(preg)
+regex_t *preg;
+{
+ register struct re_guts *g;
+
+ if (preg->re_magic != MAGIC1) /* oops */
+ return; /* nice to complain, but hard */
+
+ g = preg->re_g;
+ if (g == NULL || g->magic != MAGIC2) /* oops again */
+ return;
+ preg->re_magic = 0; /* mark it invalid */
+ g->magic = 0; /* mark it invalid */
+
+ if (g->strip != NULL)
+ free((char *)g->strip);
+ if (g->sets != NULL)
+ free((char *)g->sets);
+ if (g->setbits != NULL)
+ free((char *)g->setbits);
+ if (g->must != NULL)
+ free(g->must);
+ free((char *)g);
+}
--- /dev/null
+/*-
+ * Copyright (c) 1992, 1993, 1994 Henry Spencer.
+ * Copyright (c) 1992, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Henry Spencer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)utils.h 8.3 (Berkeley) 3/20/94
+ */
+
+/* utility definitions */
+#define DUPMAX 100000000 /* xxx is this right? */
+#define INFINITY (DUPMAX + 1)
+#define NC (CHAR_MAX - CHAR_MIN + 1)
+typedef unsigned char uch;
+
+/* switch off assertions (if not already off) if no REDEBUG */
+#ifndef REDEBUG
+#ifndef NDEBUG
+#define NDEBUG /* no assertions please */
+#endif
+#endif
+
+/* for old systems with bcopy() but no memmove() */
+#if defined(PORTNAME_sparc)
+#define memmove(d, s, c) bcopy(s, d, c)
+#endif
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for the rewrite rules module
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/rewrite/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:51 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+VPATH:= $(VPATH):$(CURDIR)/rewrite
+
+
+SRCS_REWRITE= rewriteRemove.c rewriteDefine.c \
+ rewriteHandler.c rewriteManip.c rewriteSupport.c locks.c
+
+HEADERS+= rewriteRemove.h rewriteDefine.h rewriteHandler.h \
+ rewriteManip.h rewriteSupport.h locks.h prs2lock.h
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * locks.c--
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/Attic/locks.c,v 1.1.1.1 1996/07/09 06:21:51 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h" /* for oid defs */
+#include "utils/elog.h" /* for elog */
+#include "nodes/pg_list.h" /* lisp support package */
+#include "nodes/parsenodes.h"
+#include "nodes/primnodes.h" /* Var node def */
+#include "utils/syscache.h" /* for SearchSysCache */
+#include "rewrite/locks.h" /* for rewrite specific lock defns */
+
+/*
+ * ThisLockWasTriggered
+ *
+ * walk the tree, if there we find a varnode,
+ * we check the varattno against the attnum
+ * if we find at least one such match, we return true
+ * otherwise, we return false
+ */
+bool
+nodeThisLockWasTriggered(Node *node, int varno, AttrNumber attnum)
+{
+ if (node==NULL)
+ return FALSE;
+ switch(nodeTag(node)) {
+ case T_Var:
+ {
+ Var *var = (Var *)node;
+ if (varno == var->varno &&
+ (attnum == var->varattno || attnum == -1))
+ return TRUE;
+ }
+ break;
+ case T_Expr:
+ {
+ Expr *expr = (Expr*)node;
+ return
+ nodeThisLockWasTriggered((Node*)expr->args, varno, attnum);
+ }
+ break;
+ case T_TargetEntry:
+ {
+ TargetEntry *tle = (TargetEntry *)node;
+ return
+ nodeThisLockWasTriggered(tle->expr, varno, attnum);
+ }
+ break;
+ case T_List:
+ {
+ List *l;
+
+ foreach(l, (List*)node) {
+ if (nodeThisLockWasTriggered(lfirst(l), varno, attnum))
+ return TRUE;
+ }
+ return FALSE;
+ }
+ break;
+ default:
+ break;
+ }
+ return (FALSE);
+}
+
+/*
+ * thisLockWasTriggered -
+ * walk the tree, if there we find a varnode, we check the varattno
+ * against the attnum if we find at least one such match, we return true
+ * otherwise, we return false
+ */
+static bool
+thisLockWasTriggered(int varno,
+ AttrNumber attnum,
+ Query *parsetree)
+{
+ return
+ (nodeThisLockWasTriggered(parsetree->qual, varno, attnum) ||
+ nodeThisLockWasTriggered((Node*)parsetree->targetList,
+ varno, attnum));
+}
+
+/*
+ * matchLocks -
+ * match the list of locks and returns the matching rules
+ */
+List *
+matchLocks(CmdType event,
+ RuleLock *rulelocks,
+ int varno,
+ Query *parsetree)
+{
+ List *real_locks = NIL;
+ int nlocks;
+ int i;
+
+ Assert(rulelocks != NULL); /* we get called iff there is some lock */
+ Assert(parsetree != NULL);
+
+ if (parsetree->commandType != CMD_SELECT) {
+ if (parsetree->resultRelation != varno) {
+ return ( NULL );
+ }
+ }
+
+ nlocks = rulelocks->numLocks;
+
+ for (i = 0; i < nlocks; i++) {
+ RewriteRule *oneLock = rulelocks->rules[i];
+
+ if (oneLock->event == event) {
+ if (parsetree->commandType != CMD_SELECT ||
+ thisLockWasTriggered(varno,
+ oneLock->attrno,
+ parsetree)) {
+ real_locks = lappend(real_locks, oneLock);
+ }
+ }
+ }
+
+ return (real_locks);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * locks.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: locks.h,v 1.1.1.1 1996/07/09 06:21:51 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef LOCKS_H
+#define LOCKS_H
+
+#include "rewrite/prs2lock.h"
+
+extern List *matchLocks(CmdType event, RuleLock *rulelocks, int varno,
+ Query *parsetree);
+
+#endif /* LOCKS_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * prs2lock.h--
+ * data structures for POSTGRES Rule System II (rewrite rules only)
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: prs2lock.h,v 1.1.1.1 1996/07/09 06:21:51 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PRS2LOCK_H
+#define PRS2LOCK_H
+
+#include "access/attnum.h"
+#include "nodes/pg_list.h"
+
+/*
+ * RewriteRule -
+ * holds a info for a rewrite rule
+ *
+ */
+typedef struct RewriteRule {
+ Oid ruleId;
+ CmdType event;
+ AttrNumber attrno;
+ Node *qual;
+ List *actions;
+ bool isInstead;
+} RewriteRule;
+
+/*
+ * RuleLock -
+ * all rules that apply to a particular relation. Even though we only
+ * have the rewrite rule system left and these are not really "locks",
+ * the name is kept for historical reasons.
+ */
+typedef struct RuleLock {
+ int numLocks;
+ RewriteRule **rules;
+} RuleLock;
+
+#endif /* REWRITE_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * rewriteDefine.c--
+ * routines for defining a rewrite rule
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteDefine.c,v 1.1.1.1 1996/07/09 06:21:51 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include "postgres.h"
+
+#include "utils/rel.h" /* for Relation stuff */
+#include "access/heapam.h" /* access methods like amopenr */
+#include "utils/builtins.h"
+#include "utils/elog.h" /* for elog */
+#include "utils/palloc.h"
+#include "utils/lsyscache.h" /* for get_typlen */
+#include "nodes/pg_list.h" /* for Lisp support */
+#include "nodes/parsenodes.h"
+#include "parser/catalog_utils.h"
+#include "rewrite/locks.h"
+#include "rewrite/rewriteRemove.h"
+#include "rewrite/rewriteSupport.h"
+#include "tcop/tcopprot.h"
+
+Oid LastOidProcessed = InvalidOid;
+
+/*
+ * This is too small for many rule plans, but it'll have to do for now.
+ * Rule plans, etc will eventually have to be large objects.
+ *
+ * should this be smaller?
+ */
+#define RULE_PLAN_SIZE 8192
+
+static void
+strcpyq(char *dest, char *source)
+{
+ char *current=source,*destp= dest;
+
+ for(current=source; *current; current++) {
+ if (*current == '\"') {
+ *destp = '\\';
+ destp++;
+ }
+ *destp = *current;
+ destp++;
+ }
+ *destp = '\0';
+}
+
+/*
+ * InsertRule -
+ * takes the arguments and inserts them as attributes into the system
+ * relation "pg_rewrite"
+ *
+ * MODS : changes the value of LastOidProcessed as a side
+ * effect of inserting the rule tuple
+ *
+ * ARGS : rulname - name of the rule
+ * evtype - one of RETRIEVE,REPLACE,DELETE,APPEND
+ * evobj - name of relation
+ * evslot - comma delimited list of slots
+ * if null => multi-attr rule
+ * evinstead - is an instead rule
+ * actiontree - parsetree(s) of rule action
+ */
+static Oid
+InsertRule(char *rulname,
+ int evtype,
+ char *evobj,
+ char *evslot,
+ char *evqual,
+ bool evinstead,
+ char *actiontree)
+{
+ static char rulebuf[RULE_PLAN_SIZE];
+ static char actionbuf[RULE_PLAN_SIZE];
+ static char qualbuf[RULE_PLAN_SIZE];
+ Oid eventrel_oid = InvalidOid;
+ AttrNumber evslot_index = InvalidAttrNumber;
+ Relation eventrel = NULL;
+ char *is_instead = "f";
+ extern void eval_as_new_xact();
+ char *template;
+
+ eventrel = heap_openr(evobj);
+ if (eventrel == NULL) {
+ elog(WARN, "rules cannot be defined on relations not in schema");
+ }
+ eventrel_oid = RelationGetRelationId(eventrel);
+
+ /*
+ * if the slotname is null, we know that this is a multi-attr
+ * rule
+ */
+ if (evslot == NULL)
+ evslot_index = -1;
+ else
+ evslot_index = varattno(eventrel, (char*)evslot);
+ heap_close(eventrel);
+
+ if (evinstead)
+ is_instead = "t";
+
+ if (evqual == NULL)
+ evqual = "nil";
+
+ if (IsDefinedRewriteRule(rulname))
+ elog(WARN, "Attempt to insert rule '%s' failed: already exists",
+ rulname);
+ strcpyq(actionbuf,actiontree);
+ strcpyq(qualbuf, evqual);
+
+ template = "INSERT INTO pg_rewrite \
+(rulename, ev_type, ev_class, ev_attr, action, ev_qual, is_instead) VALUES \
+('%s', %d::char, %d::oid, %d::int2, '%s'::text, '%s'::text, \
+ '%s'::bool);";
+ if (strlen(template) + strlen(rulname) + strlen(actionbuf) +
+ strlen(qualbuf) + 20 /* fudge fac */ > RULE_PLAN_SIZE) {
+ elog(WARN, "DefineQueryRewrite: rule plan string too big.");
+ }
+ sprintf(rulebuf, template,
+ rulname, evtype, eventrel_oid, evslot_index, actionbuf,
+ qualbuf, is_instead);
+
+ pg_eval(rulebuf, (char **) NULL, (Oid *) NULL, 0);
+
+ return (LastOidProcessed);
+}
+
+/*
+ * for now, event_object must be a single attribute
+ */
+static void
+ValidateRule(int event_type,
+ char *eobj_string,
+ char *eslot_string,
+ Node *event_qual,
+ List **action,
+ int is_instead,
+ Oid event_attype)
+{
+ if (((event_type == CMD_INSERT) || (event_type == CMD_DELETE)) &&
+ eslot_string) {
+ elog(WARN,
+ "rules not allowed for insert or delete events to an attribute");
+ }
+
+ if (event_qual && !*action && is_instead)
+ elog(WARN,
+ "event_quals on 'instead nothing' rules not currently supported");
+
+#if 0
+ /* on retrieve to class.attribute do instead nothing is converted
+ * to 'on retrieve to class.attribute do instead
+ * retrieve (attribute = NULL)'
+ * --- this is also a terrible hack that works well -- glass*/
+ if (is_instead && !*action && eslot_string && event_type == CMD_SELECT) {
+ char *temp_buffer = (char *) palloc(strlen(template)+80);
+ sprintf(temp_buffer, template, event_attype,
+ get_typlen(event_attype), eslot_string,
+ event_attype);
+
+ *action = (List*) stringToNode(temp_buffer);
+
+ pfree(temp_buffer);
+ }
+#endif
+}
+
+void
+DefineQueryRewrite(RuleStmt *stmt)
+{
+ CmdType event_type = stmt->event;
+ Attr *event_obj = stmt->object;
+ Node *event_qual = stmt->whereClause;
+ bool is_instead = stmt->instead;
+ List *action = stmt->actions;
+ Relation event_relation = NULL ;
+ Oid ruleId;
+ Oid ev_relid = 0;
+ char *eslot_string = NULL;
+ int event_attno = 0;
+ Oid event_attype = 0;
+ char *actionP, *event_qualP;
+
+ extern Oid att_typeid();
+
+ if (event_obj->attrs)
+ eslot_string = strVal(lfirst(event_obj->attrs));
+ else
+ eslot_string = NULL;
+
+ event_relation = heap_openr(event_obj->relname);
+ if ( event_relation == NULL ) {
+ elog(WARN, "virtual relations not supported yet");
+ }
+ ev_relid = RelationGetRelationId(event_relation);
+
+ if (eslot_string == NULL) {
+ event_attno = -1;
+ event_attype = -1; /* XXX - don't care */
+ } else {
+ event_attno = varattno(event_relation, eslot_string);
+ event_attype = att_typeid(event_relation,event_attno);
+ }
+ heap_close(event_relation);
+
+ /* fix bug about instead nothing */
+ ValidateRule(event_type, event_obj->relname,
+ eslot_string, event_qual, &action,
+ is_instead,event_attype);
+
+ if (action == NULL) {
+ if (!is_instead) return; /* doesn't do anything */
+
+ event_qualP = nodeToString(event_qual);
+
+ ruleId = InsertRule(stmt->rulename,
+ event_type,
+ event_obj->relname,
+ eslot_string,
+ event_qualP,
+ true,
+ "nil");
+ prs2_addToRelation(ev_relid, ruleId, event_type, event_attno, TRUE,
+ event_qual, NIL);
+
+ } else {
+ event_qualP = nodeToString(event_qual);
+ actionP = nodeToString(action);
+
+ ruleId = InsertRule(stmt->rulename,
+ event_type,
+ event_obj->relname,
+ eslot_string,
+ event_qualP,
+ is_instead,
+ actionP);
+
+ /* what is the max size of type text? XXX -- glass */
+ if (length(action) > 15 )
+ elog(WARN,"max # of actions exceeded");
+ prs2_addToRelation(ev_relid, ruleId, event_type, event_attno,
+ is_instead, event_qual, action);
+ }
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * rewriteDefine.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: rewriteDefine.h,v 1.1.1.1 1996/07/09 06:21:51 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef REWRITEDEFINE_H
+#define REWRITEDEFINE_H
+
+extern void DefineQueryRewrite(RuleStmt *args);
+
+#endif /* REWRITEDEFINE_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * rewriteHandler.c--
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.1.1.1 1996/07/09 06:21:51 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+#include "miscadmin.h"
+#include "utils/palloc.h"
+#include "utils/elog.h"
+#include "utils/rel.h"
+#include "nodes/pg_list.h"
+#include "nodes/primnodes.h"
+
+#include "parser/parsetree.h" /* for parsetree manipulation */
+#include "nodes/parsenodes.h"
+
+#include "rewrite/rewriteSupport.h"
+#include "rewrite/rewriteHandler.h"
+#include "rewrite/rewriteManip.h"
+#include "rewrite/locks.h"
+
+#include "commands/creatinh.h"
+#include "access/heapam.h"
+
+static void ApplyRetrieveRule(Query *parsetree, RewriteRule *rule,
+ int rt_index, int relation_level, int *modified);
+static List *fireRules(Query *parsetree, int rt_index, CmdType event,
+ bool *instead_flag, List *locks, List **qual_products);
+static List *deepRewriteQuery(Query *parsetree);
+
+/*
+ * gatherRewriteMeta -
+ * Gather meta information about parsetree, and rule. Fix rule body
+ * and qualifier so that they can be mixed with the parsetree and
+ * maintain semantic validity
+ */
+static RewriteInfo *
+gatherRewriteMeta(Query *parsetree,
+ Query *rule_action,
+ Node *rule_qual,
+ int rt_index,
+ CmdType event,
+ bool *instead_flag)
+{
+ RewriteInfo *info;
+ int rt_length;
+ int result_reln;
+
+ info = (RewriteInfo *) palloc(sizeof(RewriteInfo));
+ info->rt_index = rt_index;
+ info->event = event;
+ info->instead_flag = *instead_flag;
+/* info->rule_action = rule_action; this needs to be a copy here, I think! - jolly*/
+ info->rule_action = (Query*)copyObject(rule_action);
+ info->rule_qual = (Node*)copyObject(rule_qual);
+ info->nothing = FALSE;
+ info->action = info->rule_action->commandType;
+ if (info->rule_action == NULL) info->nothing = TRUE;
+ if (info->nothing)
+ return info;
+
+ info->current_varno = rt_index;
+ info->rt = parsetree->rtable;
+ rt_length = length(info->rt);
+ info->rt = append(info->rt, info->rule_action->rtable);
+
+
+ info->new_varno = PRS2_NEW_VARNO + rt_length;
+ OffsetVarNodes(info->rule_action->qual, rt_length);
+ OffsetVarNodes((Node*)info->rule_action->targetList, rt_length);
+ OffsetVarNodes(info->rule_qual, rt_length);
+ ChangeVarNodes((Node*)info->rule_action->qual,
+ PRS2_CURRENT_VARNO+rt_length, rt_index);
+ ChangeVarNodes((Node*)info->rule_action->targetList,
+ PRS2_CURRENT_VARNO+rt_length, rt_index);
+ ChangeVarNodes(info->rule_qual, PRS2_CURRENT_VARNO+rt_length, rt_index);
+
+ /*
+ * bug here about replace CURRENT -- sort of
+ * replace current is deprecated now so this code shouldn't really
+ * need to be so clutzy but.....
+ */
+ if (info->action != CMD_SELECT) { /* i.e update XXXXX */
+ int new_result_reln = 0;
+ result_reln = info->rule_action->resultRelation;
+ switch (result_reln) {
+ case PRS2_CURRENT_VARNO: new_result_reln = rt_index;
+ break;
+ case PRS2_NEW_VARNO: /* XXX */
+ default:
+ new_result_reln = result_reln + rt_length;
+ break;
+ }
+ info->rule_action->resultRelation = new_result_reln;
+ }
+
+ return info;
+}
+
+static List *
+OptimizeRIRRules(List *locks)
+{
+ List *attr_level = NIL, *i;
+ List *relation_level = NIL;
+
+ foreach (i, locks) {
+ RewriteRule *rule_lock = lfirst(i);
+
+ if (rule_lock->attrno == -1)
+ relation_level = lappend(relation_level, rule_lock);
+ else
+ attr_level = lappend(attr_level, rule_lock);
+ }
+ return nconc(relation_level, attr_level);
+}
+
+/*
+ * idea is to put instead rules before regular rules so that
+ * excess semantically queasy queries aren't processed
+ */
+static List *
+orderRules(List *locks)
+{
+ List *regular = NIL, *i;
+ List *instead_rules = NIL;
+
+ foreach (i, locks) {
+ RewriteRule *rule_lock = (RewriteRule *)lfirst(i);
+
+ if (rule_lock->isInstead)
+ instead_rules = lappend(instead_rules, rule_lock);
+ else
+ regular = lappend(regular, rule_lock);
+ }
+ return nconc(regular, instead_rules);
+}
+
+static int
+AllRetrieve(List *actions)
+{
+ List *n;
+
+ foreach(n, actions) {
+ Query *pt = lfirst(n);
+
+ /*
+ * in the old postgres code, we check whether command_type is
+ * a consp of '('*'.commandType). but we've never supported transitive
+ * closures. Hence removed - ay 10/94.
+ */
+ if (pt->commandType != CMD_SELECT)
+ return false;
+ }
+ return true;
+}
+
+static List *
+FireRetrieveRulesAtQuery(Query *parsetree,
+ int rt_index,
+ Relation relation,
+ bool *instead_flag,
+ int rule_flag)
+{
+ List *i, *locks;
+ RuleLock *rt_entry_locks = NULL;
+ List *work = NIL;
+
+ if ((rt_entry_locks = relation->rd_rules) == NULL)
+ return NIL;
+
+ locks = matchLocks(CMD_SELECT, rt_entry_locks, rt_index, parsetree);
+
+ /* find all retrieve instead */
+ foreach (i, locks) {
+ RewriteRule *rule_lock = (RewriteRule *)lfirst(i);
+
+ if (!rule_lock->isInstead)
+ continue;
+ work = lappend(work, rule_lock);
+ }
+ if (work != NIL) {
+ work = OptimizeRIRRules(locks);
+ foreach (i, work) {
+ RewriteRule *rule_lock = lfirst(i);
+ int relation_level;
+ int modified = FALSE;
+
+ relation_level = (rule_lock->attrno == -1);
+ if (rule_lock->actions == NIL) {
+ *instead_flag = TRUE;
+ return NIL;
+ }
+ if (!rule_flag &&
+ length(rule_lock->actions) >= 2 &&
+ AllRetrieve(rule_lock->actions)) {
+ *instead_flag = TRUE;
+ return rule_lock->actions;
+ }
+ ApplyRetrieveRule(parsetree, rule_lock, rt_index, relation_level,
+ &modified);
+ if (modified) {
+ *instead_flag = TRUE;
+ FixResdomTypes(parsetree->targetList);
+ return lcons(parsetree,NIL);
+ }
+ }
+ }
+ return NIL;
+}
+
+
+/* Idea is like this:
+ *
+ * retrieve-instead-retrieve rules have different semantics than update nodes
+ * Separate RIR rules from others. Pass others to FireRules.
+ * Order RIR rules and process.
+ *
+ * side effect: parsetree's rtable field might be changed
+ */
+static void
+ApplyRetrieveRule(Query *parsetree,
+ RewriteRule *rule,
+ int rt_index,
+ int relation_level,
+ int *modified)
+{
+ Query *rule_action = NULL;
+ Node *rule_qual;
+ List *rtable, *rt;
+ int nothing, rt_length;
+ int badsql= FALSE;
+
+ rule_qual = rule->qual;
+ if (rule->actions) {
+ if (length(rule->actions) > 1) /* ??? because we don't handle rules
+ with more than one action? -ay */
+ return;
+ rule_action = copyObject(lfirst(rule->actions));
+ nothing = FALSE;
+ } else {
+ nothing = TRUE;
+ }
+
+ rtable = copyObject(parsetree->rtable);
+ foreach (rt, rtable) {
+ RangeTblEntry *rte = lfirst(rt);
+ /*
+ * this is to prevent add_missing_vars_to_base_rels() from
+ * adding a bogus entry to the new target list.
+ */
+ rte->inFromCl = false;
+ }
+ rt_length = length(rtable);
+ rtable = nconc(rtable, copyObject(rule_action->rtable));
+ parsetree->rtable = rtable;
+
+ rule_action->rtable = rtable;
+ OffsetVarNodes(rule_action->qual, rt_length);
+ OffsetVarNodes((Node*)rule_action->targetList, rt_length);
+ OffsetVarNodes(rule_qual, rt_length);
+ ChangeVarNodes(rule_action->qual,
+ PRS2_CURRENT_VARNO+rt_length, rt_index);
+ ChangeVarNodes((Node*)rule_action->targetList,
+ PRS2_CURRENT_VARNO+rt_length, rt_index);
+ ChangeVarNodes(rule_qual, PRS2_CURRENT_VARNO+rt_length, rt_index);
+ if (relation_level) {
+ HandleViewRule(parsetree, rtable, rule_action->targetList, rt_index,
+ modified);
+ } else {
+ HandleRIRAttributeRule(parsetree, rtable, rule_action->targetList,
+ rt_index, rule->attrno, modified, &badsql);
+ }
+ if (*modified && !badsql)
+ AddQual(parsetree, rule_action->qual);
+}
+
+static List *
+ProcessRetrieveQuery(Query *parsetree,
+ List *rtable,
+ bool *instead_flag,
+ bool rule)
+{
+ List *rt;
+ List *product_queries = NIL;
+ int rt_index = 0;
+
+ foreach (rt, rtable) {
+ RangeTblEntry *rt_entry = lfirst(rt);
+ Relation rt_entry_relation = NULL;
+ List *result = NIL;
+
+ rt_index++;
+ rt_entry_relation = heap_openr(rt_entry->relname);
+
+ if (rt_entry_relation->rd_rules != NULL) {
+ result =
+ FireRetrieveRulesAtQuery(parsetree,
+ rt_index,
+ rt_entry_relation,
+ instead_flag,
+ rule);
+ }
+ heap_close(rt_entry_relation);
+ if (*instead_flag)
+ return result;
+ }
+ if (rule)
+ return NIL;
+
+ foreach (rt, rtable) {
+ RangeTblEntry *rt_entry = lfirst(rt);
+ Relation rt_entry_relation = NULL;
+ RuleLock *rt_entry_locks = NULL;
+ List *result = NIL;
+ List *locks = NIL;
+ List *dummy_products;
+
+ rt_index++;
+ rt_entry_relation = heap_openr(rt_entry->relname);
+ rt_entry_locks = rt_entry_relation->rd_rules;
+ heap_close(rt_entry_relation);
+
+ if (rt_entry_locks) {
+ locks =
+ matchLocks(CMD_SELECT, rt_entry_locks, rt_index, parsetree);
+ }
+ if (locks != NIL) {
+ result = fireRules(parsetree, rt_index, CMD_SELECT,
+ instead_flag, locks, &dummy_products);
+ if (*instead_flag)
+ return lappend(NIL, result);
+ if (result != NIL)
+ product_queries = nconc(product_queries, result);
+ }
+ }
+ return product_queries;
+}
+
+static Query *
+CopyAndAddQual(Query *parsetree,
+ List *actions,
+ Node *rule_qual,
+ int rt_index,
+ CmdType event)
+{
+ Query *new_tree = (Query *) copyObject(parsetree);
+ Node *new_qual = NULL;
+ Query *rule_action = NULL;
+
+ if (actions)
+ rule_action = lfirst(actions);
+ if (rule_qual != NULL)
+ new_qual = (Node *)copyObject(rule_qual);
+ if (rule_action != NULL) {
+ List *rtable;
+ int rt_length;
+
+ rtable = new_tree->rtable;
+ rt_length = length(rtable);
+ rtable = append(rtable,listCopy(rule_action->rtable));
+ new_tree->rtable = rtable;
+ OffsetVarNodes(new_qual, rt_length);
+ ChangeVarNodes(new_qual, PRS2_CURRENT_VARNO+rt_length, rt_index);
+ }
+ /* XXX -- where current doesn't work for instead nothing.... yet*/
+ AddNotQual(new_tree, new_qual);
+
+ return new_tree;
+}
+
+
+/*
+ * fireRules -
+ * Iterate through rule locks applying rules. After an instead rule
+ * rule has been applied, return just new parsetree and let RewriteQuery
+ * start the process all over again. The locks are reordered to maintain
+ * sensible semantics. remember: reality is for dead birds -- glass
+ *
+ */
+static List *
+fireRules(Query *parsetree,
+ int rt_index,
+ CmdType event,
+ bool *instead_flag,
+ List *locks,
+ List **qual_products)
+{
+ RewriteInfo *info;
+ List *results = NIL;
+ List *i;
+
+ /* choose rule to fire from list of rules */
+ if (locks == NIL) {
+ (void) ProcessRetrieveQuery(parsetree,
+ parsetree->rtable,
+ instead_flag, TRUE);
+ if (*instead_flag)
+ return lappend(NIL, parsetree);
+ else
+ return NIL;
+ }
+
+ locks = orderRules(locks); /* instead rules first */
+ foreach (i, locks) {
+ RewriteRule *rule_lock = (RewriteRule *)lfirst(i);
+ Node *qual, *event_qual;
+ List *actions;
+ List *r;
+ bool orig_instead_flag = *instead_flag;
+
+ /* multiple rule action time */
+ *instead_flag = rule_lock->isInstead;
+ event_qual = rule_lock->qual;
+ actions = rule_lock->actions;
+ if (event_qual != NULL && *instead_flag)
+ *qual_products =
+ lappend(*qual_products,
+ CopyAndAddQual(parsetree, actions, event_qual,
+ rt_index, event));
+ foreach (r, actions) {
+ Query *rule_action = lfirst(r);
+ Node *rule_qual = copyObject(event_qual);
+
+ /*--------------------------------------------------
+ * Step 1:
+ * Rewrite current.attribute or current to tuple variable
+ * this appears to be done in parser?
+ *--------------------------------------------------
+ */
+ info = gatherRewriteMeta(parsetree, rule_action, rule_qual,
+ rt_index,event,instead_flag);
+
+ /* handle escapable cases, or those handled by other code */
+ if (info->nothing) {
+ if (*instead_flag)
+ return NIL;
+ else
+ continue;
+ }
+
+ if (info->action == info->event &&
+ info->event == CMD_SELECT)
+ continue;
+
+ /*
+ * Event Qualification forces copying of parsetree --- XXX
+ * and splitting into two queries one w/rule_qual, one
+ * w/NOT rule_qual. Also add user query qual onto rule action
+ */
+ qual = parsetree->qual;
+ AddQual(info->rule_action, qual);
+
+ if (info->rule_qual != NULL)
+ AddQual(info->rule_action, info->rule_qual);
+
+ /*--------------------------------------------------
+ * Step 2:
+ * Rewrite new.attribute w/ right hand side of target-list
+ * entry for appropriate field name in insert/update
+ *--------------------------------------------------
+ */
+ if ((info->event == CMD_INSERT) || (info->event == CMD_UPDATE)) {
+ FixNew(info, parsetree);
+ }
+
+ /*--------------------------------------------------
+ * Step 3:
+ * rewriting due to retrieve rules
+ *--------------------------------------------------
+ */
+ info->rule_action->rtable = info->rt;
+ (void) ProcessRetrieveQuery(info->rule_action, info->rt,
+ &orig_instead_flag, TRUE);
+
+ /*--------------------------------------------------
+ * Step 4
+ * Simplify? hey, no algorithm for simplification... let
+ * the planner do it.
+ *--------------------------------------------------
+ */
+ results = lappend(results, info->rule_action);
+
+ pfree(info);
+ }
+ if (*instead_flag) break;
+ }
+ return results;
+}
+
+static List *
+RewriteQuery(Query *parsetree, bool *instead_flag, List **qual_products)
+{
+ CmdType event;
+ List *product_queries = NIL;
+ int result_relation = 0;
+
+ Assert(parsetree != NULL);
+
+ event = parsetree->commandType;
+
+ if (event == CMD_UTILITY)
+ return NIL;
+
+ /*
+ * only for a delete may the targetlist be NULL
+ */
+ if (event != CMD_DELETE) {
+ Assert(parsetree->targetList != NULL);
+ }
+
+ result_relation = parsetree->resultRelation;
+
+ if (event != CMD_SELECT) {
+ /*
+ * the statement is an update, insert or delete
+ */
+ RangeTblEntry *rt_entry;
+ Relation rt_entry_relation = NULL;
+ RuleLock *rt_entry_locks = NULL;
+
+ rt_entry = rt_fetch(result_relation, parsetree->rtable);
+ rt_entry_relation = heap_openr(rt_entry->relname);
+ rt_entry_locks = rt_entry_relation->rd_rules;
+ heap_close(rt_entry_relation);
+
+ if (rt_entry_locks != NULL) {
+ List *locks =
+ matchLocks(event, rt_entry_locks, result_relation, parsetree);
+
+ product_queries =
+ fireRules(parsetree,
+ result_relation,
+ event,
+ instead_flag,
+ locks,
+ qual_products);
+ }
+ return product_queries;
+ }else {
+ /*
+ * the statement is a select
+ */
+ Query *other;
+
+ other = copyObject(parsetree); /* ApplyRetrieveRule changes the
+ range table */
+ return
+ ProcessRetrieveQuery(other, parsetree->rtable,
+ instead_flag, FALSE);
+ }
+}
+
+/*
+ * to avoid infinite recursion, we restrict the number of times a query
+ * can be rewritten. Detecting cycles is left for the reader as an excercise.
+ */
+#ifndef REWRITE_INVOKE_MAX
+#define REWRITE_INVOKE_MAX 10
+#endif
+
+static int numQueryRewriteInvoked = 0;
+
+/*
+ * QueryRewrite -
+ * rewrite one query via QueryRewrite system, possibly returning 0, or many
+ * queries
+ */
+List *
+QueryRewrite(Query *parsetree)
+{
+ numQueryRewriteInvoked = 0;
+
+ /*
+ * take a deep breath and apply all the rewrite rules - ay
+ */
+ return deepRewriteQuery(parsetree);
+}
+
+/*
+ * deepRewriteQuery -
+ * rewrites the query and apply the rules again on the queries rewritten
+ */
+static List *
+deepRewriteQuery(Query *parsetree)
+{
+ List *n;
+ List *rewritten = NIL;
+ List *result = NIL;
+ bool instead;
+ List *qual_products = NIL;
+
+ if (++numQueryRewriteInvoked > REWRITE_INVOKE_MAX) {
+ elog(WARN, "query rewritten %d times, may contain cycles",
+ numQueryRewriteInvoked-1);
+ }
+
+ instead = FALSE;
+ result = RewriteQuery(parsetree, &instead, &qual_products);
+ if (!instead)
+ rewritten = lcons(parsetree, NIL);
+
+ foreach(n, result) {
+ Query *pt = lfirst(n);
+ List *newstuff = NIL;
+
+ newstuff = deepRewriteQuery(pt);
+ if (newstuff != NIL)
+ rewritten = nconc(rewritten, newstuff);
+ }
+ if (qual_products != NIL)
+ rewritten = nconc(rewritten, qual_products);
+
+ return rewritten;
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * rewriteHandler.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: rewriteHandler.h,v 1.1.1.1 1996/07/09 06:21:51 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef REWRITEHANDLER_H
+#define REWRITEHANDLER_H
+
+
+struct _rewrite_meta_knowledge {
+ List *rt;
+ int rt_index;
+ bool instead_flag;
+ int event;
+ CmdType action;
+ int current_varno;
+ int new_varno;
+ Query *rule_action;
+ Node *rule_qual;
+ bool nothing;
+};
+
+typedef struct _rewrite_meta_knowledge RewriteInfo;
+
+
+extern List *QueryRewrite(Query *parsetree);
+
+#endif /*REWRITEHANDLER_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * rewriteManip.c--
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+#include "nodes/pg_list.h"
+#include "utils/elog.h"
+#include "nodes/nodes.h"
+#include "nodes/relation.h"
+#include "nodes/primnodes.h"
+#include "parser/parsetree.h" /* for getrelid() */
+#include "utils/lsyscache.h"
+#include "utils/builtins.h"
+#include "rewrite/rewriteHandler.h"
+#include "rewrite/rewriteSupport.h"
+#include "rewrite/locks.h"
+
+#include "nodes/plannodes.h"
+#include "optimizer/clauses.h"
+
+static void ResolveNew(RewriteInfo *info, List *targetlist, Node **node);
+
+
+
+void
+OffsetVarNodes(Node *node, int offset)
+{
+ if (node==NULL)
+ return;
+ switch (nodeTag(node)) {
+ case T_TargetEntry:
+ {
+ TargetEntry *tle = (TargetEntry *)node;
+ OffsetVarNodes(tle->expr, offset);
+ }
+ break;
+ case T_Expr:
+ {
+ Expr *expr = (Expr*)node;
+ OffsetVarNodes((Node*)expr->args, offset);
+ }
+ break;
+ case T_Var:
+ {
+ Var *var = (Var*)node;
+ var->varno += offset;
+ var->varnoold += offset;
+ }
+ break;
+ case T_List:
+ {
+ List *l;
+
+ foreach(l, (List*)node) {
+ OffsetVarNodes(lfirst(l), offset);
+ }
+ }
+ break;
+ default:
+ /* ignore the others */
+ break;
+ }
+}
+
+void
+ChangeVarNodes(Node *node, int old_varno, int new_varno)
+{
+ if (node==NULL)
+ return;
+ switch (nodeTag(node)) {
+ case T_TargetEntry:
+ {
+ TargetEntry *tle = (TargetEntry *)node;
+ ChangeVarNodes(tle->expr, old_varno, new_varno);
+ }
+ break;
+ case T_Expr:
+ {
+ Expr *expr = (Expr*)node;
+ ChangeVarNodes((Node*)expr->args, old_varno, new_varno);
+ }
+ break;
+ case T_Var:
+ {
+ Var *var = (Var*)node;
+ if (var->varno == old_varno) {
+ var->varno = new_varno;
+ var->varnoold = new_varno;
+ }
+ }
+ break;
+ case T_List:
+ {
+ List *l;
+ foreach (l, (List*)node) {
+ ChangeVarNodes(lfirst(l), old_varno, new_varno);
+ }
+ }
+ break;
+ default:
+ /* ignore the others */
+ break;
+ }
+}
+
+void
+AddQual(Query *parsetree, Node *qual)
+{
+ Node *copy, *old;
+
+ if (qual == NULL)
+ return;
+
+ copy = copyObject(qual);
+ old = parsetree->qual;
+ if (old == NULL)
+ parsetree->qual = copy;
+ else
+ parsetree->qual =
+ (Node*)make_andclause(makeList(parsetree->qual, copy, -1));
+}
+
+void
+AddNotQual(Query *parsetree, Node *qual)
+{
+ Node *copy;
+
+ if (qual == NULL) return;
+
+ copy = (Node*)make_notclause(copyObject(qual));
+
+ AddQual(parsetree,copy);
+}
+
+static Node *
+make_null(Oid type)
+{
+ Const *c = makeNode(Const);
+
+ c->consttype = type;
+ c->constlen = get_typlen(type);
+ c->constvalue = PointerGetDatum(NULL);
+ c->constisnull = true;
+ c->constbyval = get_typbyval(type);
+ return (Node*)c;
+}
+
+void
+FixResdomTypes (List *tlist)
+{
+ List *i;
+
+ foreach (i, tlist) {
+ TargetEntry *tle = lfirst(i);
+
+ if (nodeTag(tle->expr) == T_Var) {
+ Var *var = (Var*)tle->expr;
+
+ tle->resdom->restype = var->vartype;
+ tle->resdom->reslen = get_typlen(var->vartype);
+ }
+ }
+}
+
+static Node *
+FindMatchingNew(List *tlist, int attno)
+{
+ List *i;
+
+ foreach (i, tlist ) {
+ TargetEntry *tle = lfirst(i);
+
+ if (tle->resdom->resno == attno ) {
+ return (tle->expr);
+ }
+ }
+ return NULL;
+}
+
+static Node *
+FindMatchingTLEntry(List *tlist, char *e_attname)
+{
+ List *i;
+
+ foreach (i, tlist) {
+ TargetEntry *tle = lfirst(i);
+ char *resname;
+
+ resname = tle->resdom->resname;
+ if (!strcmp(e_attname, resname))
+ return (tle->expr);
+ }
+ return NULL;
+}
+
+static void
+ResolveNew(RewriteInfo *info, List *targetlist, Node **nodePtr)
+{
+ Node *node = *nodePtr;
+
+ if (node == NULL)
+ return;
+
+ switch(nodeTag(node)) {
+ case T_TargetEntry:
+ ResolveNew(info, targetlist, &((TargetEntry*)node)->expr);
+ break;
+ case T_Expr:
+ ResolveNew(info, targetlist, (Node**)(&(((Expr*)node)->args)));
+ break;
+ case T_Var: {
+ int this_varno = (int)((Var*)node)->varno;
+ Node *n;
+
+ if (this_varno == info->new_varno) {
+ n = FindMatchingNew(targetlist,
+ ((Var*)node)->varattno);
+ if (n == NULL) {
+ if (info->event == CMD_UPDATE) {
+ ((Var*)node)->varno = info->current_varno;
+ ((Var*)node)->varnoold = info->current_varno;
+ } else {
+ *nodePtr = make_null(((Var*)node)->vartype);
+ }
+ } else {
+ *nodePtr = n;
+ }
+ }
+ break;
+ }
+ case T_List: {
+ List *l;
+ foreach(l, (List*)node) {
+ ResolveNew(info, targetlist, (Node**)&(lfirst(l)));
+ }
+ break;
+ }
+ default:
+ /* ignore the others */
+ break;
+ }
+}
+
+void
+FixNew(RewriteInfo* info, Query *parsetree)
+{
+ ResolveNew(info, parsetree->targetList,
+ (Node**)&(info->rule_action->targetList));
+ ResolveNew(info, parsetree->targetList, &info->rule_action->qual);
+}
+
+static void
+nodeHandleRIRAttributeRule(Node **nodePtr,
+ List *rtable,
+ List *targetlist,
+ int rt_index,
+ int attr_num,
+ int *modified,
+ int *badsql)
+{
+ Node *node = *nodePtr;
+
+ if (node == NULL)
+ return;
+ switch (nodeTag(node)) {
+ case T_List:
+ {
+ List *i;
+ foreach(i, (List*)node) {
+ nodeHandleRIRAttributeRule((Node**)(&(lfirst(i))), rtable,
+ targetlist, rt_index, attr_num,
+ modified, badsql);
+ }
+ }
+ break;
+ case T_TargetEntry:
+ {
+ TargetEntry *tle = (TargetEntry *)node;
+ nodeHandleRIRAttributeRule(&tle->expr, rtable, targetlist,
+ rt_index, attr_num, modified, badsql);
+ }
+ break;
+ case T_Expr:
+ {
+ Expr *expr = (Expr *)node;
+ nodeHandleRIRAttributeRule((Node**)(&(expr->args)), rtable,
+ targetlist, rt_index, attr_num,
+ modified, badsql);
+ }
+ break;
+ case T_Var:
+ {
+ int this_varno = (int) ((Var*)node)->varno;
+ NameData name_to_look_for;
+ memset(name_to_look_for.data, 0, NAMEDATALEN);
+
+ if (this_varno == rt_index &&
+ ((Var*) node)->varattno == attr_num) {
+ if (((Var*)node)->vartype == 32) { /* HACK */
+ *nodePtr = make_null(((Var*)node)->vartype);
+ *modified = TRUE;
+ *badsql = TRUE;
+ break;
+ } else {
+ namestrcpy(&name_to_look_for,
+ (char *)get_attname(getrelid(this_varno,
+ rtable),
+ attr_num));
+ }
+ }
+ if (name_to_look_for.data[0]) {
+ Node *n;
+
+ n = FindMatchingTLEntry(targetlist, &name_to_look_for);
+ if (n == NULL) {
+ *nodePtr = make_null(((Var*) node)->vartype);
+ } else {
+ *nodePtr = n;
+ }
+ *modified = TRUE;
+ }
+ }
+ break;
+ default:
+ /* ignore the others */
+ break;
+ }
+}
+
+/*
+ * Handles 'on retrieve to relation.attribute
+ * do instead retrieve (attribute = expression) w/qual'
+ */
+void
+HandleRIRAttributeRule(Query *parsetree,
+ List *rtable,
+ List *targetlist,
+ int rt_index,
+ int attr_num,
+ int *modified,
+ int *badsql)
+{
+ nodeHandleRIRAttributeRule((Node**)(&(parsetree->targetList)), rtable,
+ targetlist, rt_index, attr_num,
+ modified, badsql);
+ nodeHandleRIRAttributeRule(&parsetree->qual, rtable, targetlist,
+ rt_index, attr_num, modified, badsql);
+}
+
+
+static void
+nodeHandleViewRule(Node **nodePtr,
+ List *rtable,
+ List *targetlist,
+ int rt_index,
+ int *modified)
+{
+ Node *node = *nodePtr;
+
+ if (node == NULL)
+ return;
+
+ switch (nodeTag(node)) {
+ case T_List:
+ {
+ List *l;
+ foreach (l, (List*)node) {
+ nodeHandleViewRule((Node**) (&(lfirst(l))),
+ rtable, targetlist,
+ rt_index, modified);
+ }
+ }
+ break;
+ case T_TargetEntry:
+ {
+ TargetEntry *tle = (TargetEntry *)node;
+ nodeHandleViewRule(&(tle->expr), rtable, targetlist,
+ rt_index, modified);
+ }
+ break;
+ case T_Expr:
+ {
+ Expr *expr = (Expr*)node;
+ nodeHandleViewRule((Node**)(&(expr->args)),
+ rtable, targetlist,
+ rt_index, modified);
+ }
+ break;
+ case T_Var:
+ {
+ Var *var = (Var*)node;
+ int this_varno = var->varno;
+ Node *n;
+
+ if (this_varno == rt_index) {
+ n = FindMatchingTLEntry(targetlist,
+ get_attname(getrelid(this_varno,
+ rtable),
+ var->varattno));
+ if (n == NULL) {
+ *nodePtr = make_null(((Var*) node)->vartype);
+ } else {
+ *nodePtr = n;
+ }
+ *modified = TRUE;
+ }
+ break;
+ }
+ default:
+ /* ignore the others */
+ break;
+ }
+}
+
+void
+HandleViewRule(Query *parsetree,
+ List *rtable,
+ List *targetlist,
+ int rt_index,
+ int *modified)
+{
+ nodeHandleViewRule(&parsetree->qual, rtable, targetlist, rt_index,
+ modified);
+ nodeHandleViewRule((Node**)(&(parsetree->targetList)), rtable, targetlist,
+ rt_index, modified);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * rewriteManip.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: rewriteManip.h,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef REWRITEMANIP_H
+#define REWRITEMANIP_H
+
+/* RewriteManip.c */
+void OffsetVarNodes(Node *node, int offset);
+void ChangeVarNodes(Node *node, int old_varno, int new_varno);
+void AddQual(Query *parsetree, Node *qual);
+void AddNotQual(Query *parsetree, Node *qual);
+void FixResdomTypes(List *user_tlist);
+void FixNew(RewriteInfo *info, Query *parsetree);
+
+void HandleRIRAttributeRule(Query *parsetree, List *rtable, List *targetlist,
+ int rt_index, int attr_num, int *modified,
+ int *badpostquel);
+void HandleViewRule(Query *parsetree, List *rtable, List *targetlist,
+ int rt_index, int *modified);
+
+#endif /* REWRITEMANIP_H */
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * rewriteRemove.c--
+ * routines for removing rewrite rules
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteRemove.c,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "access/skey.h"
+#include "catalog/pg_rewrite.h"
+#include "catalog/catname.h" /* for RewriteRelationName */
+#include "utils/syscache.h"
+#include "utils/elog.h" /* for elog stuff */
+#include "utils/palloc.h"
+#include "utils/tqual.h" /* 'NowTimeQual' defined here.. */
+#include "access/heapam.h" /* heap AM calls defined here */
+#include "fmgr.h" /* for CHAR_16_EQ */
+
+#include "rewrite/rewriteRemove.h" /* where the decls go */
+#include "rewrite/rewriteSupport.h"
+
+/*-----------------------------------------------------------------------
+ * RewriteGetRuleEventRel
+ *-----------------------------------------------------------------------
+ */
+char*
+RewriteGetRuleEventRel(char *rulename)
+{
+ HeapTuple htp;
+ Oid eventrel;
+
+ htp = SearchSysCacheTuple(REWRITENAME, PointerGetDatum(rulename),
+ 0,0,0);
+ if (!HeapTupleIsValid(htp))
+ elog(WARN, "RewriteGetRuleEventRel: rule \"%s\" not found",
+ rulename);
+ eventrel = ((Form_pg_rewrite) GETSTRUCT(htp))->ev_class;
+ htp = SearchSysCacheTuple(RELOID, PointerGetDatum(eventrel),
+ 0,0,0);
+ if (!HeapTupleIsValid(htp))
+ elog(WARN, "RewriteGetRuleEventRel: class %d not found",
+ eventrel);
+ return ((Form_pg_class) GETSTRUCT(htp))->relname.data;
+}
+
+/* ----------------------------------------------------------------
+ *
+ * RemoveRewriteRule
+ *
+ * Delete a rule given its rulename.
+ *
+ * There are three steps.
+ * 1) Find the corresponding tuple in 'pg_rewrite' relation.
+ * Find the rule Id (i.e. the Oid of the tuple) and finally delete
+ * the tuple.
+ * 3) Delete the locks from the 'pg_class' relation.
+ *
+ *
+ * ----------------------------------------------------------------
+ */
+void
+RemoveRewriteRule(char *ruleName)
+{
+ Relation RewriteRelation = NULL;
+ HeapScanDesc scanDesc = NULL;
+ ScanKeyData scanKeyData;
+ HeapTuple tuple = NULL;
+ Oid ruleId = (Oid)0;
+ Oid eventRelationOid = (Oid)NULL;
+ Datum eventRelationOidDatum = (Datum)NULL;
+ Buffer buffer = (Buffer)NULL;
+ bool isNull = false;
+
+ /*
+ * Open the pg_rewrite relation.
+ */
+ RewriteRelation = heap_openr(RewriteRelationName);
+
+ /*
+ * Scan the RuleRelation ('pg_rewrite') until we find a tuple
+ */
+ ScanKeyEntryInitialize(&scanKeyData, 0, Anum_pg_rewrite_rulename,
+ F_CHAR16EQ, NameGetDatum(ruleName));
+ scanDesc = heap_beginscan(RewriteRelation,
+ 0, NowTimeQual, 1, &scanKeyData);
+
+ tuple = heap_getnext(scanDesc, 0, (Buffer *)NULL);
+
+ /*
+ * complain if no rule with such name existed
+ */
+ if (!HeapTupleIsValid(tuple)) {
+ heap_close(RewriteRelation);
+ elog(WARN, "No rule with name = '%s' was found.\n", ruleName);
+ }
+
+ /*
+ * Store the OID of the rule (i.e. the tuple's OID)
+ * and the event relation's OID
+ */
+ ruleId = tuple->t_oid;
+ eventRelationOidDatum =
+ PointerGetDatum(heap_getattr(tuple,
+ buffer,
+ Anum_pg_rewrite_ev_class,
+ RelationGetTupleDescriptor(RewriteRelation),
+ &isNull));
+ if (isNull) {
+ /* XXX strange!!! */
+ elog(WARN, "RemoveRewriteRule: null event target relation!");
+ }
+ eventRelationOid = DatumGetObjectId(eventRelationOidDatum);
+
+ /*
+ * Now delete the relation level locks from the updated relation.
+ * (Make sure we do this before we remove the rule from pg_rewrite.
+ * Otherwise, heap_openr on eventRelationOid which reads pg_rwrite
+ * for the rules will fail.)
+ */
+ prs2_deleteFromRelation(eventRelationOid, ruleId);
+
+ /*
+ * Now delete the tuple...
+ */
+ heap_delete(RewriteRelation, &(tuple->t_ctid));
+ heap_close(RewriteRelation);
+ heap_endscan(scanDesc);
+}
+
+/*
+ * RelationRemoveRules -
+ * removes all rules associated with the relation when the relation is
+ * being removed.
+ */
+void
+RelationRemoveRules(Oid relid)
+{
+ Relation RewriteRelation = NULL;
+ HeapScanDesc scanDesc = NULL;
+ ScanKeyData scanKeyData;
+ HeapTuple tuple = NULL;
+
+ /*
+ * Open the pg_rewrite relation.
+ */
+ RewriteRelation = heap_openr(RewriteRelationName);
+
+ /*
+ * Scan the RuleRelation ('pg_rewrite') for all the tuples that
+ * has the same ev_class as relid (the relation to be removed).
+ */
+ ScanKeyEntryInitialize(&scanKeyData,
+ 0,
+ Anum_pg_rewrite_ev_class,
+ F_OIDEQ,
+ ObjectIdGetDatum(relid));
+ scanDesc = heap_beginscan(RewriteRelation,
+ 0, NowTimeQual, 1, &scanKeyData);
+
+ for(;;) {
+ tuple = heap_getnext(scanDesc, 0, (Buffer *)NULL);
+
+ if (!HeapTupleIsValid(tuple)) {
+ break; /* we're done */
+ }
+
+ /*
+ * delete the tuple...
+ */
+ heap_delete(RewriteRelation, &(tuple->t_ctid));
+ }
+
+ heap_endscan(scanDesc);
+ heap_close(RewriteRelation);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * rewriteRemove.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: rewriteRemove.h,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef REWRITEREMOVE_H
+#define REWRITEREMOVE_H
+
+extern char *RewriteGetRuleEventRel(char *rulename);
+extern void RemoveRewriteRule(char *ruleName);
+extern void RelationRemoveRules(Oid relid);
+
+#endif /* REWRITEREMOVE_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * rewriteSupport.c--
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteSupport.c,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+#include "catalog/catname.h"
+#include "catalog/pg_rewrite.h"
+#include "utils/syscache.h" /* for SearchSysCache */
+#include "nodes/pg_list.h"
+#include "nodes/parsenodes.h"
+#include "utils/builtins.h" /* for textout */
+#include "utils/rel.h" /* for Relation, RelationData ... */
+#include "utils/elog.h" /* for elog */
+#include "storage/buf.h" /* for InvalidBuffer */
+#include "rewrite/rewriteSupport.h"
+#include "access/heapam.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_proc.h"
+#include "catalog/indexing.h"
+#include "utils/catcache.h" /* for CacheContext */
+#include "utils/mcxt.h" /* MemoryContext stuff */
+#include "utils/palloc.h"
+#include "fmgr.h"
+
+/*
+ * RuleIdGetActionInfo -
+ * given a rule oid, look it up and return the rule-event-qual and
+ * list of parsetrees for the rule (in parseTrees)
+ */
+static Node *
+RuleIdGetActionInfo(Oid ruleoid, bool *instead_flag, Query **parseTrees)
+{
+ HeapTuple ruletuple;
+ char *ruleaction = NULL;
+ bool action_is_null = false;
+ bool instead_is_null = false;
+ Relation ruleRelation = NULL;
+ TupleDesc ruleTupdesc = NULL;
+ Query *ruleparse = NULL;
+ char *rule_evqual_string = NULL;
+ Node *rule_evqual = NULL;
+
+ ruleRelation = heap_openr (RewriteRelationName);
+ ruleTupdesc = RelationGetTupleDescriptor(ruleRelation);
+ ruletuple = SearchSysCacheTuple (RULOID,
+ ObjectIdGetDatum(ruleoid),
+ 0,0,0);
+ if (ruletuple == NULL)
+ elog(WARN, "rule %d isn't in rewrite system relation");
+
+ ruleaction = heap_getattr(ruletuple,
+ InvalidBuffer,
+ Anum_pg_rewrite_action,
+ ruleTupdesc,
+ &action_is_null ) ;
+ rule_evqual_string = heap_getattr(ruletuple, InvalidBuffer,
+ Anum_pg_rewrite_ev_qual,
+ ruleTupdesc, &action_is_null) ;
+ *instead_flag = (bool) heap_getattr(ruletuple, InvalidBuffer,
+ Anum_pg_rewrite_is_instead,
+ ruleTupdesc, &instead_is_null) ;
+
+ if (action_is_null || instead_is_null) {
+ elog(WARN, "internal error: rewrite rule not properly set up");
+ }
+
+ ruleaction = textout((struct varlena *)ruleaction);
+ rule_evqual_string = textout((struct varlena *)rule_evqual_string);
+
+ ruleparse = (Query*)stringToNode(ruleaction);
+ rule_evqual = (Node*)stringToNode(rule_evqual_string);
+
+ heap_close(ruleRelation);
+
+ *parseTrees = ruleparse;
+ return rule_evqual;
+}
+
+int
+IsDefinedRewriteRule(char *ruleName)
+{
+ Relation RewriteRelation = NULL;
+ HeapScanDesc scanDesc = NULL;
+ ScanKeyData scanKey;
+ HeapTuple tuple = NULL;
+
+
+ /*
+ * Open the pg_rewrite relation.
+ */
+ RewriteRelation = heap_openr(RewriteRelationName);
+
+ /*
+ * Scan the RuleRelation ('pg_rewrite') until we find a tuple
+ */
+ ScanKeyEntryInitialize(&scanKey, 0, Anum_pg_rewrite_rulename,
+ NameEqualRegProcedure, PointerGetDatum(ruleName));
+ scanDesc = heap_beginscan(RewriteRelation,
+ 0, NowTimeQual, 1, &scanKey);
+
+ tuple = heap_getnext(scanDesc, 0, (Buffer *)NULL);
+
+ /*
+ * return whether or not the rewrite rule existed
+ */
+ heap_close(RewriteRelation);
+ heap_endscan(scanDesc);
+ return (HeapTupleIsValid(tuple));
+}
+
+static void
+setRelhasrulesInRelation(Oid relationId, bool relhasrules)
+{
+ Relation relationRelation;
+ HeapTuple tuple;
+ HeapTuple newTuple;
+ Relation idescs[Num_pg_class_indices];
+ Form_pg_class relp;
+
+ /*
+ * Lock a relation given its Oid.
+ * Go to the RelationRelation (i.e. pg_relation), find the
+ * appropriate tuple, and add the specified lock to it.
+ */
+ relationRelation = heap_openr(RelationRelationName);
+ tuple = ClassOidIndexScan(relationRelation, relationId);
+
+ /*
+ * Create a new tuple (i.e. a copy of the old tuple
+ * with its rule lock field changed and replace the old
+ * tuple in the RelationRelation
+ * NOTE: XXX ??? do we really need to make that copy ????
+ */
+ newTuple = heap_copytuple(tuple);
+
+ relp = (Form_pg_class) GETSTRUCT(newTuple);
+ relp->relhasrules = relhasrules;
+
+ (void) heap_replace(relationRelation, &(tuple->t_ctid), newTuple);
+
+ /* keep the catalog indices up to date */
+ CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices, idescs);
+ CatalogIndexInsert(idescs, Num_pg_class_indices, relationRelation,
+ newTuple);
+ CatalogCloseIndices(Num_pg_class_indices, idescs);
+
+ /* be tidy */
+ pfree(tuple);
+ pfree(newTuple);
+
+ heap_close(relationRelation);
+}
+
+void
+prs2_addToRelation(Oid relid,
+ Oid ruleId,
+ CmdType event_type,
+ AttrNumber attno,
+ bool isInstead,
+ Node *qual,
+ List *actions)
+{
+ Relation relation;
+ RewriteRule *thisRule;
+ RuleLock *rulelock;
+ MemoryContext oldcxt;
+
+ /*
+ * create an in memory RewriteRule data structure which is cached by
+ * every Relation descriptor. (see utils/cache/relcache.c)
+ */
+ oldcxt = MemoryContextSwitchTo((MemoryContext)CacheCxt);
+ thisRule = (RewriteRule *)palloc(sizeof(RewriteRule));
+ MemoryContextSwitchTo(oldcxt);
+
+ thisRule->ruleId = ruleId;
+ thisRule->event = event_type;
+ thisRule->attrno = attno;
+ thisRule->qual = qual;
+ thisRule->actions = actions;
+ thisRule->isInstead = isInstead;
+
+ relation = heap_open(relid);
+
+ /*
+ * modify or create a RuleLock cached by Relation
+ */
+ if (relation->rd_rules == NULL) {
+
+ oldcxt = MemoryContextSwitchTo((MemoryContext)CacheCxt);
+ rulelock = (RuleLock *)palloc(sizeof(RuleLock));
+ rulelock->numLocks = 1;
+ rulelock->rules = (RewriteRule **)palloc(sizeof(RewriteRule*));
+ rulelock->rules[0] = thisRule;
+ relation->rd_rules = rulelock;
+ MemoryContextSwitchTo(oldcxt);
+
+ /*
+ * the fact that relation->rd_rules is NULL means the relhasrules
+ * attribute of the tuple of this relation in pg_class is false. We
+ * need to set it to true.
+ */
+ setRelhasrulesInRelation(relid, TRUE);
+ } else {
+ int numlock;
+
+ rulelock = relation->rd_rules;
+ numlock = rulelock->numLocks;
+ /* expand, for safety reasons */
+ oldcxt = MemoryContextSwitchTo((MemoryContext)CacheCxt);
+ rulelock->rules =
+ (RewriteRule **)repalloc(rulelock->rules,
+ sizeof(RewriteRule*)*(numlock+1));
+ MemoryContextSwitchTo(oldcxt);
+ rulelock->rules[numlock] = thisRule;
+ rulelock->numLocks++;
+ }
+
+ heap_close(relation);
+
+ return;
+}
+
+void
+prs2_deleteFromRelation(Oid relid, Oid ruleId)
+{
+ RuleLock *rulelock;
+ Relation relation;
+ int numlock;
+ int i;
+ MemoryContext oldcxt;
+
+ relation = heap_open(relid);
+ rulelock = relation->rd_rules;
+ Assert(rulelock != NULL);
+
+ numlock = rulelock->numLocks;
+ for(i=0; i < numlock; i++) {
+ if (rulelock->rules[i]->ruleId == ruleId)
+ break;
+ }
+ Assert(i
+ oldcxt = MemoryContextSwitchTo((MemoryContext)CacheCxt);
+ pfree(rulelock->rules[i]);
+ MemoryContextSwitchTo(oldcxt);
+ if (numlock==1) {
+ relation->rd_rules = NULL;
+ /*
+ * we don't have rules any more, flag the relhasrules attribute of
+ * the tuple of this relation in pg_class false.
+ */
+ setRelhasrulesInRelation(relid, FALSE);
+ } else {
+ rulelock->rules[i] = rulelock->rules[numlock-1];
+ rulelock->rules[numlock-1] = NULL;
+ rulelock->numLocks--;
+ }
+
+ heap_close(relation);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * rewriteSupport.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: rewriteSupport.h,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef REWRITESUPPORT_H
+#define REWRITESUPPORT_H
+
+#include "nodes/pg_list.h"
+
+extern int IsDefinedRewriteRule(char *ruleName);
+
+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);
+
+
+#endif /* REWRITESUPPORT_H */
+
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for the storage modules
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/storage/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+stordir= $(CURDIR)/storage
+VPATH:= $(VPATH):$(stordir):$(stordir)/buffer:$(stordir)/file:$(stordir)/ipc:\
+ $(stordir)/large_object:$(stordir)/lmgr:$(stordir)/page:$(stordir)/smgr
+
+SUBSRCS=
+include $(stordir)/buffer/Makefile.inc
+include $(stordir)/file/Makefile.inc
+include $(stordir)/ipc/Makefile.inc
+include $(stordir)/large_object/Makefile.inc
+include $(stordir)/lmgr/Makefile.inc
+include $(stordir)/page/Makefile.inc
+include $(stordir)/smgr/Makefile.inc
+SRCS_STORAGE:= $(SUBSRCS)
+
+HEADERS+= backendid.h block.h buf.h buf_internals.h bufmgr.h bufpage.h \
+ fd.h ipc.h item.h itemid.h itempos.h \
+ itemptr.h large_object.h lmgr.h lock.h multilev.h off.h page.h \
+ pagenum.h pos.h proc.h shmem.h sinval.h sinvaladt.h smgr.h spin.h
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * backendid.h--
+ * POSTGRES backend id communication definitions
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: backendid.h,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BACKENDID_H
+#define BACKENDID_H
+
+/* ----------------
+ * pulled out of sinval.h to temporarily reduce #include nesting.
+ * -cim 8/17/90
+ * ----------------
+ */
+typedef int16 BackendId; /* unique currently active backend identifier */
+
+#define InvalidBackendId (-1)
+
+typedef int32 BackendTag; /* unique backend identifier */
+
+#define InvalidBackendTag (-1)
+
+extern BackendId MyBackendId; /* backend id of this backend */
+extern BackendTag MyBackendTag; /* backend tag of this backend */
+
+#endif /* BACKENDID_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * block.h--
+ * POSTGRES disk block definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: block.h,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BLOCK_H
+#define BLOCK_H
+
+#include "c.h"
+
+/*
+ * BlockNumber:
+ *
+ * each data file (heap or index) is divided into postgres disk blocks
+ * (which may be thought of as the unit of i/o -- a postgres buffer
+ * contains exactly one disk block). the blocks are numbered
+ * sequentially, 0 to 0xFFFFFFFE.
+ *
+ * InvalidBlockNumber is the same thing as P_NEW in buf.h.
+ *
+ * the access methods, the buffer manager and the storage manager are
+ * more or less the only pieces of code that should be accessing disk
+ * blocks directly.
+ */
+typedef uint32 BlockNumber;
+
+#define InvalidBlockNumber ((BlockNumber) 0xFFFFFFFF)
+
+/*
+ * BlockId:
+ *
+ * this is a storage type for BlockNumber. in other words, this type
+ * is used for on-disk structures (e.g., in HeapTupleData) whereas
+ * BlockNumber is the type on which calculations are performed (e.g.,
+ * in access method code).
+ *
+ * there doesn't appear to be any reason to have separate types except
+ * for the fact that BlockIds can be SHORTALIGN'd (and therefore any
+ * structures that contains them, such as ItemPointerData, can also be
+ * SHORTALIGN'd). this is an important consideration for reducing the
+ * space requirements of the line pointer (ItemIdData) array on each
+ * page and the header of each heap or index tuple, so it doesn't seem
+ * wise to change this without good reason.
+ */
+typedef struct BlockIdData {
+ uint16 bi_hi;
+ uint16 bi_lo;
+} BlockIdData;
+
+typedef BlockIdData *BlockId; /* block identifier */
+
+/* ----------------
+ * support macros
+ * ----------------
+ */
+
+/*
+ * BlockNumberIsValid --
+ * True iff blockNumber is valid.
+ */
+#define BlockNumberIsValid(blockNumber) \
+ ((bool) ((int32) (blockNumber) != InvalidBlockNumber))
+
+/*
+ * BlockIdIsValid --
+ * True iff the block identifier is valid.
+ */
+#define BlockIdIsValid(blockId) \
+ ((bool) PointerIsValid(blockId))
+
+/*
+ * BlockIdSet --
+ * Sets a block identifier to the specified value.
+ */
+#define BlockIdSet(blockId, blockNumber) \
+ Assert(PointerIsValid(blockId)); \
+ (blockId)->bi_hi = (blockNumber) >> 16; \
+ (blockId)->bi_lo = (blockNumber) & 0xffff
+
+/*
+ * BlockIdCopy --
+ * Copy a block identifier.
+ */
+#define BlockIdCopy(toBlockId, fromBlockId) \
+ Assert(PointerIsValid(toBlockId)); \
+ Assert(PointerIsValid(fromBlockId)); \
+ (toBlockId)->bi_hi = (fromBlockId)->bi_hi; \
+ (toBlockId)->bi_lo = (fromBlockId)->bi_lo
+
+/*
+ * BlockIdEquals --
+ * Check for block number equality.
+ */
+#define BlockIdEquals(blockId1, blockId2) \
+ ((blockId1)->bi_hi == (blockId2)->bi_hi && \
+ (blockId1)->bi_lo == (blockId2)->bi_lo)
+
+/*
+ * BlockIdGetBlockNumber --
+ * Retrieve the block number from a block identifier.
+ */
+#define BlockIdGetBlockNumber(blockId) \
+ (AssertMacro(BlockIdIsValid(blockId)) ? \
+ (BlockNumber) (((blockId)->bi_hi << 16) | ((uint16) (blockId)->bi_lo)) : \
+ (BlockNumber) InvalidBlockNumber)
+
+#endif /* BLOCK_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * buf.h--
+ * Basic buffer manager data types.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: buf.h,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BUF_H
+#define BUF_H
+
+#define InvalidBuffer (0)
+#define UnknownBuffer (-99999)
+
+typedef long Buffer;
+
+/*
+ * BufferIsInvalid --
+ * True iff the buffer is invalid.
+ */
+#define BufferIsInvalid(buffer) ((buffer) == InvalidBuffer)
+
+/*
+ * BufferIsUnknown --
+ * True iff the buffer is unknown.
+ */
+#define BufferIsUnknown(buffer) ((buffer) == UnknownBuffer)
+
+/*
+ * BufferIsLocal --
+ * True iff the buffer is local (not visible to other servers).
+ */
+#define BufferIsLocal(buffer) ((buffer) < 0)
+
+/*
+ * If NO_BUFFERISVALID is defined, all error checking using BufferIsValid()
+ * are suppressed. Decision-making using BufferIsValid is not affected.
+ * This should be set only if one is sure there will be no errors.
+ * - plai 9/10/90
+ */
+#undef NO_BUFFERISVALID
+
+#endif /* BUF_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * buf_internals.h--
+ * Internal definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: buf_internals.h,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+ *
+ * NOTE
+ * If BUFFERPAGE0 is defined, then 0 will be used as a
+ * valid buffer page number.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BUFMGR_INTERNALS_H
+#define BUFMGR_INTERNALS_H
+
+#include "postgres.h"
+#include "storage/buf.h"
+#include "storage/ipc.h"
+#include "storage/shmem.h"
+#include "miscadmin.h"
+#include "storage/lmgr.h"
+#include "utils/rel.h"
+#include "utils/relcache.h"
+
+/* Buf Mgr constants */
+/* in bufmgr.c */
+extern int NBuffers;
+extern int Data_Descriptors;
+extern int Free_List_Descriptor;
+extern int Lookup_List_Descriptor;
+extern int Num_Descriptors;
+
+/*
+ * Flags for buffer descriptors
+ */
+#define BM_DIRTY (1 << 0)
+#define BM_PRIVATE (1 << 1)
+#define BM_VALID (1 << 2)
+#define BM_DELETED (1 << 3)
+#define BM_FREE (1 << 4)
+#define BM_IO_IN_PROGRESS (1 << 5)
+#define BM_IO_ERROR (1 << 6)
+
+typedef bits16 BufFlags;
+
+typedef struct sbufdesc BufferDesc;
+typedef struct sbufdesc BufferHdr;
+typedef struct buftag BufferTag;
+/* long * so alignment will be correct */
+typedef long **BufferBlock;
+
+struct buftag{
+ LRelId relId;
+ BlockNumber blockNum; /* blknum relative to begin of reln */
+};
+
+#define CLEAR_BUFFERTAG(a)\
+ (a)->relId.dbId = InvalidOid; \
+ (a)->relId.relId = InvalidOid; \
+ (a)->blockNum = InvalidBlockNumber
+
+#define INIT_BUFFERTAG(a,xx_reln,xx_blockNum) \
+{ \
+ (a)->blockNum = xx_blockNum;\
+ (a)->relId = RelationGetLRelId(xx_reln); \
+}
+
+#define COPY_BUFFERTAG(a,b)\
+{ \
+ (a)->blockNum = (b)->blockNum;\
+ LRelIdAssign(*(a),*(b));\
+}
+
+#define EQUAL_BUFFERTAG(a,b) \
+ (((a)->blockNum == (b)->blockNum) &&\
+ (OID_Equal((a)->relId.relId,(b)->relId.relId)))
+
+
+#define BAD_BUFFER_ID(bid) ((bid<1) || (bid>(NBuffers)))
+#define INVALID_DESCRIPTOR (-3)
+
+/*
+ * bletch hack -- anyplace that we declare space for relation or
+ * database names, we just use '16', not a symbolic constant, to
+ * specify their lengths. BM_NAMESIZE is the length of these names,
+ * and is used in the buffer manager code. somebody with lots of
+ * spare time should do this for all the other modules, too.
+ */
+#define BM_NAMESIZE 16
+
+/*
+ * struct sbufdesc -- shared buffer cache metadata for a single
+ * shared buffer descriptor.
+ *
+ * We keep the name of the database and relation in which this
+ * buffer appears in order to avoid a catalog lookup on cache
+ * flush if we don't have the reldesc in the cache. It is also
+ * possible that the relation to which this buffer belongs is
+ * not visible to all backends at the time that it gets flushed.
+ * Dbname, relname, dbid, and relid are enough to determine where
+ * to put the buffer, for all storage managers.
+ */
+
+struct sbufdesc {
+ Buffer freeNext; /* link for freelist chain */
+ Buffer freePrev;
+ SHMEM_OFFSET data; /* pointer to data in buf pool */
+
+ /* tag and id must be together for table lookup to work */
+ BufferTag tag; /* file/block identifier */
+ int buf_id; /* maps global desc to local desc */
+
+ BufFlags flags; /* described below */
+ int16 bufsmgr; /* storage manager id for buffer */
+ unsigned refcount; /* # of times buffer is pinned */
+
+ char *sb_dbname; /* name of db in which buf belongs */
+ char *sb_relname; /* name of reln */
+#ifdef HAS_TEST_AND_SET
+ /* can afford a dedicated lock if test-and-set locks are available */
+ slock_t io_in_progress_lock;
+#endif /* HAS_TEST_AND_SET */
+
+ /*
+ * I padded this structure to a power of 2 (128 bytes on a MIPS) because
+ * BufferDescriptorGetBuffer is called a billion times and it does an
+ * C pointer subtraction (i.e., "x - y" -> array index of x relative
+ * to y, which is calculated using division by struct size). Integer
+ * ".div" hits you for 35 cycles, as opposed to a 1-cycle "sra" ...
+ * this hack cut 10% off of the time to create the Wisconsin database!
+ * It eats up more shared memory, of course, but we're (allegedly)
+ * going to make some of these types bigger soon anyway... -pma 1/2/93
+ */
+#if defined(PORTNAME_ultrix4)
+ char sb_pad[60]; /* no slock_t */
+#endif /* mips */
+#if defined(PORTNAME_sparc) || defined(PORTNAME_sparc_solaris) || defined(PORTNAME_irix5)
+ char sb_pad[56]; /* has slock_t */
+#endif /* sparc || irix5 */
+#if defined(PORTNAME_hpux)
+ char sb_pad[44]; /* has slock_t */
+#endif /* alpha */
+#if defined(PORTNAME_alpha)
+ char sb_pad[40]; /* has slock_t */
+#endif /* alpha */
+};
+
+/*
+ * mao tracing buffer allocation
+ */
+
+/*#define BMTRACE*/
+#ifdef BMTRACE
+
+typedef struct _bmtrace {
+ int bmt_pid;
+ long bmt_buf;
+ long bmt_dbid;
+ long bmt_relid;
+ int bmt_blkno;
+ int bmt_op;
+
+#define BMT_NOTUSED 0
+#define BMT_ALLOCFND 1
+#define BMT_ALLOCNOTFND 2
+#define BMT_DEALLOC 3
+
+} bmtrace;
+
+#endif /* BMTRACE */
+
+
+/*
+ * Bufmgr Interface:
+ */
+
+/* Internal routines: only called by buf.c */
+
+/*freelist.c*/
+extern void AddBufferToFreelist(BufferDesc *bf);
+extern void PinBuffer(BufferDesc *buf);
+extern void PinBuffer_Debug(char *file, int line, BufferDesc *buf);
+extern void UnpinBuffer(BufferDesc *buf);
+extern void UnpinBuffer_Debug(char *file, int line, BufferDesc *buf);
+extern BufferDesc *GetFreeBuffer(void);
+extern void InitFreeList(bool init);
+extern void DBG_FreeListCheck(int nfree);
+
+/* buf_table.c */
+extern void InitBufTable(void);
+extern BufferDesc *BufTableLookup(BufferTag *tagPtr);
+extern bool BufTableDelete(BufferDesc *buf);
+extern bool BufTableInsert(BufferDesc *buf);
+extern void DBG_LookupListCheck(int nlookup);
+
+/* bufmgr.c */
+extern BufferDesc *BufferDescriptors;
+extern BufferBlock BufferBlocks;
+extern long *PrivateRefCount;
+extern long *LastRefCount;
+extern SPINLOCK BufMgrLock;
+
+/* localbuf.c */
+extern long *LocalRefCount;
+extern BufferDesc *LocalBufferDescriptors;
+extern int NLocBuffer;
+
+extern BufferDesc *LocalBufferAlloc(Relation reln, BlockNumber blockNum,
+ bool *foundPtr);
+extern int WriteLocalBuffer(Buffer buffer, bool release);
+extern int FlushLocalBuffer(Buffer buffer);
+extern void InitLocalBuffer();
+extern void LocalBufferSync();
+extern void ResetLocalBufferPool();
+
+#endif /* BUFMGR_INTERNALS_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for storage/buffer
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/storage/buffer/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= buf_table.c buf_init.c bufmgr.c freelist.c localbuf.c
+
+SRCS_SITEMGR+= buf_table.c buf_init.c freelist.c
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * buf_init.c--
+ * buffer manager initialization routines
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_init.c,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include
+#include
+
+/* declarations split between these three files */
+#include "storage/buf.h"
+#include "storage/buf_internals.h"
+#include "storage/bufmgr.h"
+
+#include "storage/fd.h"
+#include "storage/ipc.h"
+#include "storage/shmem.h"
+#include "storage/spin.h"
+#include "storage/smgr.h"
+#include "storage/lmgr.h"
+#include "miscadmin.h"
+#include "utils/builtins.h"
+#include "utils/hsearch.h"
+#include "utils/elog.h"
+#include "utils/memutils.h"
+#include "executor/execdebug.h" /* for NDirectFileRead */
+#include "catalog/catalog.h"
+
+/*
+ * if BMTRACE is defined, we trace the last 200 buffer allocations and
+ * deallocations in a circular buffer in shared memory.
+ */
+#ifdef BMTRACE
+bmtrace *TraceBuf;
+long *CurTraceBuf;
+#define BMT_LIMIT 200
+#endif /* BMTRACE */
+int ShowPinTrace = 0;
+
+int NBuffers = NDBUFS; /* NDBUFS defined in miscadmin.h */
+int Data_Descriptors;
+int Free_List_Descriptor;
+int Lookup_List_Descriptor;
+int Num_Descriptors;
+
+BufferDesc *BufferDescriptors;
+BufferBlock BufferBlocks;
+#ifndef HAS_TEST_AND_SET
+long *NWaitIOBackendP;
+#endif
+
+extern IpcSemaphoreId WaitIOSemId;
+
+long *PrivateRefCount; /* also used in freelist.c */
+long *LastRefCount; /* refcounts of last ExecMain level */
+
+/*
+ * Data Structures:
+ * buffers live in a freelist and a lookup data structure.
+ *
+ *
+ * Buffer Lookup:
+ * Two important notes. First, the buffer has to be
+ * available for lookup BEFORE an IO begins. Otherwise
+ * a second process trying to read the buffer will
+ * allocate its own copy and the buffeer pool will
+ * become inconsistent.
+ *
+ * Buffer Replacement:
+ * see freelist.c. A buffer cannot be replaced while in
+ * use either by data manager or during IO.
+ *
+ * WriteBufferBack:
+ * currently, a buffer is only written back at the time
+ * it is selected for replacement. It should
+ * be done sooner if possible to reduce latency of
+ * BufferAlloc(). Maybe there should be a daemon process.
+ *
+ * Synchronization/Locking:
+ *
+ * BufMgrLock lock -- must be acquired before manipulating the
+ * buffer queues (lookup/freelist). Must be released
+ * before exit and before doing any IO.
+ *
+ * IO_IN_PROGRESS -- this is a flag in the buffer descriptor.
+ * It must be set when an IO is initiated and cleared at
+ * the end of the IO. It is there to make sure that one
+ * process doesn't start to use a buffer while another is
+ * faulting it in. see IOWait/IOSignal.
+ *
+ * refcount -- A buffer is pinned during IO and immediately
+ * after a BufferAlloc(). A buffer is always either pinned
+ * or on the freelist but never both. The buffer must be
+ * released, written, or flushed before the end of
+ * transaction.
+ *
+ * PrivateRefCount -- Each buffer also has a private refcount the keeps
+ * track of the number of times the buffer is pinned in the current
+ * processes. This is used for two purposes, first, if we pin a
+ * a buffer more than once, we only need to change the shared refcount
+ * once, thus only lock the buffer pool once, second, when a transaction
+ * aborts, it should only unpin the buffers exactly the number of times it
+ * has pinned them, so that it will not blow away buffers of another
+ * backend.
+ *
+ */
+
+SPINLOCK BufMgrLock;
+
+/* delayed write: TRUE on, FALSE off */
+int LateWrite = TRUE;
+
+int ReadBufferCount;
+int BufferHitCount;
+int BufferFlushCount;
+
+
+/*
+ * Initialize module:
+ *
+ * should calculate size of pool dynamically based on the
+ * amount of available memory.
+ */
+void
+InitBufferPool(IPCKey key)
+{
+ bool foundBufs,foundDescs;
+ int i;
+
+ Data_Descriptors = NBuffers;
+ Free_List_Descriptor = Data_Descriptors;
+ Lookup_List_Descriptor = Data_Descriptors + 1;
+ Num_Descriptors = Data_Descriptors + 1;
+
+ SpinAcquire(BufMgrLock);
+
+#ifdef BMTRACE
+ CurTraceBuf = (long *) ShmemInitStruct("Buffer trace",
+ (BMT_LIMIT * sizeof(bmtrace)) + sizeof(long),
+ &foundDescs);
+ if (!foundDescs)
+ memset(CurTraceBuf, 0, (BMT_LIMIT * sizeof(bmtrace)) + sizeof(long));
+
+ TraceBuf = (bmtrace *) &(CurTraceBuf[1]);
+#endif
+
+ BufferDescriptors = (BufferDesc *)
+ ShmemInitStruct("Buffer Descriptors",
+ Num_Descriptors*sizeof(BufferDesc),&foundDescs);
+
+ BufferBlocks = (BufferBlock)
+ ShmemInitStruct("Buffer Blocks",
+ NBuffers*BLCKSZ,&foundBufs);
+
+#ifndef HAS_TEST_AND_SET
+ {
+ bool foundNWaitIO;
+
+ NWaitIOBackendP = (long *)ShmemInitStruct("#Backends Waiting IO",
+ sizeof(long),
+ &foundNWaitIO);
+ if (!foundNWaitIO)
+ *NWaitIOBackendP = 0;
+ }
+#endif
+
+ if (foundDescs || foundBufs) {
+
+ /* both should be present or neither */
+ Assert(foundDescs && foundBufs);
+
+ } else {
+ BufferDesc *buf;
+ unsigned long block;
+
+ buf = BufferDescriptors;
+ block = (unsigned long) BufferBlocks;
+
+ /*
+ * link the buffers into a circular, doubly-linked list to
+ * initialize free list. Still don't know anything about
+ * replacement strategy in this file.
+ */
+ for (i = 0; i < Data_Descriptors; block+=BLCKSZ,buf++,i++) {
+ Assert(ShmemIsValid((unsigned long)block));
+
+ buf->freeNext = i+1;
+ buf->freePrev = i-1;
+
+ CLEAR_BUFFERTAG(&(buf->tag));
+ buf->data = MAKE_OFFSET(block);
+ buf->flags = (BM_DELETED | BM_FREE | BM_VALID);
+ buf->refcount = 0;
+ buf->buf_id = i;
+#ifdef HAS_TEST_AND_SET
+ S_INIT_LOCK(&(buf->io_in_progress_lock));
+#endif
+ }
+
+ /* close the circular queue */
+ BufferDescriptors[0].freePrev = Data_Descriptors-1;
+ BufferDescriptors[Data_Descriptors-1].freeNext = 0;
+ }
+
+ /* Init the rest of the module */
+ InitBufTable();
+ InitFreeList(!foundDescs);
+
+ SpinRelease(BufMgrLock);
+
+#ifndef HAS_TEST_AND_SET
+ {
+ int status;
+ WaitIOSemId = IpcSemaphoreCreate(IPCKeyGetWaitIOSemaphoreKey(key),
+ 1, IPCProtection, 0, 1, &status);
+ }
+#endif
+ PrivateRefCount = (long *) calloc(NBuffers, sizeof(long));
+ LastRefCount = (long *) calloc(NBuffers, sizeof(long));
+}
+
+/* -----------------------------------------------------
+ * BufferShmemSize
+ *
+ * compute the size of shared memory for the buffer pool including
+ * data pages, buffer descriptors, hash tables, etc.
+ * ----------------------------------------------------
+ */
+int
+BufferShmemSize()
+{
+ int size = 0;
+ int nbuckets;
+ int nsegs;
+ int tmp;
+
+ nbuckets = 1 << (int)my_log2((NBuffers - 1) / DEF_FFACTOR + 1);
+ nsegs = 1 << (int)my_log2((nbuckets - 1) / DEF_SEGSIZE + 1);
+
+ /* size of shmem binding table */
+ size += MAXALIGN(my_log2(BTABLE_SIZE) * sizeof(void *)); /* HTAB->dir */
+ size += MAXALIGN(sizeof(HHDR)); /* HTAB->hctl */
+ size += MAXALIGN(DEF_SEGSIZE * sizeof(SEGMENT));
+ size += BUCKET_ALLOC_INCR *
+ (MAXALIGN(sizeof(BUCKET_INDEX)) +
+ MAXALIGN(BTABLE_KEYSIZE) +
+ MAXALIGN(BTABLE_DATASIZE));
+
+ /* size of buffer descriptors */
+ size += MAXALIGN((NBuffers + 1) * sizeof(BufferDesc));
+
+ /* size of data pages */
+ size += NBuffers * MAXALIGN(BLCKSZ);
+
+ /* size of buffer hash table */
+ size += MAXALIGN(my_log2(NBuffers) * sizeof(void *)); /* HTAB->dir */
+ size += MAXALIGN(sizeof(HHDR)); /* HTAB->hctl */
+ size += nsegs * MAXALIGN(DEF_SEGSIZE * sizeof(SEGMENT));
+ tmp = (int)ceil((double)NBuffers/BUCKET_ALLOC_INCR);
+ size += tmp * BUCKET_ALLOC_INCR *
+ (MAXALIGN(sizeof(BUCKET_INDEX)) +
+ MAXALIGN(sizeof(BufferTag)) +
+ MAXALIGN(sizeof(Buffer)));
+
+#ifdef BMTRACE
+ size += (BMT_LIMIT * sizeof(bmtrace)) + sizeof(long);
+#endif
+ return size;
+}
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * buf_table.c--
+ * routines for finding buffers in the buffer pool.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_table.c,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ * OLD COMMENTS
+ *
+ * Data Structures:
+ *
+ * Buffers are identified by their BufferTag (buf.h). This
+ * file contains routines for allocating a shmem hash table to
+ * map buffer tags to buffer descriptors.
+ *
+ * Synchronization:
+ *
+ * All routines in this file assume buffer manager spinlock is
+ * held by their caller.
+ */
+#include "storage/bufmgr.h"
+#include "storage/buf_internals.h" /* where the declarations go */
+#include "storage/shmem.h"
+#include "storage/spin.h"
+#include "utils/hsearch.h"
+#include "utils/elog.h"
+
+static HTAB *SharedBufHash;
+
+extern HTAB *ShmemInitHash();
+
+typedef struct lookup {
+ BufferTag key;
+ Buffer id;
+} LookupEnt;
+
+/*
+ * Initialize shmem hash table for mapping buffers
+ */
+void
+InitBufTable()
+{
+ HASHCTL info;
+ int hash_flags;
+
+ /* assume lock is held */
+
+ /* BufferTag maps to Buffer */
+ info.keysize = sizeof(BufferTag);
+ info.datasize = sizeof(Buffer);
+ info.hash = tag_hash;
+
+ hash_flags = (HASH_ELEM | HASH_FUNCTION);
+
+
+ SharedBufHash = (HTAB *) ShmemInitHash("Shared Buf Lookup Table",
+ NBuffers,NBuffers,
+ &info,hash_flags);
+
+ if (! SharedBufHash) {
+ elog(FATAL,"couldn't initialize shared buffer pool Hash Tbl");
+ exit(1);
+ }
+
+}
+
+BufferDesc *
+BufTableLookup(BufferTag *tagPtr)
+{
+ LookupEnt * result;
+ bool found;
+
+ if (tagPtr->blockNum == P_NEW)
+ return(NULL);
+
+ result = (LookupEnt *)
+ hash_search(SharedBufHash,(char *) tagPtr,HASH_FIND,&found);
+
+ if (! result){
+ elog(WARN,"BufTableLookup: BufferLookup table corrupted");
+ return(NULL);
+ }
+ if (! found) {
+ return(NULL);
+ }
+ return(&(BufferDescriptors[result->id]));
+}
+
+/*
+ * BufTableDelete
+ */
+bool
+BufTableDelete(BufferDesc *buf)
+{
+ LookupEnt * result;
+ bool found;
+
+ /* buffer not initialized or has been removed from
+ * table already. BM_DELETED keeps us from removing
+ * buffer twice.
+ */
+ if (buf->flags & BM_DELETED) {
+ return(TRUE);
+ }
+
+ buf->flags |= BM_DELETED;
+
+ result = (LookupEnt *)
+ hash_search(SharedBufHash,(char *) &(buf->tag),HASH_REMOVE,&found);
+
+ if (! (result && found)) {
+ elog(WARN,"BufTableDelete: BufferLookup table corrupted");
+ return(FALSE);
+ }
+
+ return(TRUE);
+}
+
+bool
+BufTableInsert(BufferDesc *buf)
+{
+ LookupEnt * result;
+ bool found;
+
+ /* cannot insert it twice */
+ Assert (buf->flags & BM_DELETED);
+ buf->flags &= ~(BM_DELETED);
+
+ result = (LookupEnt *)
+ hash_search(SharedBufHash,(char *) &(buf->tag),HASH_ENTER,&found);
+
+ if (! result) {
+ Assert(0);
+ elog(WARN,"BufTableInsert: BufferLookup table corrupted");
+ return(FALSE);
+ }
+ /* found something else in the table ! */
+ if (found) {
+ Assert(0);
+ elog(WARN,"BufTableInsert: BufferLookup table corrupted");
+ return(FALSE);
+ }
+
+ result->id = buf->buf_id;
+ return(TRUE);
+}
+
+/* prints out collision stats for the buf table */
+void
+DBG_LookupListCheck(int nlookup)
+{
+ nlookup = 10;
+
+ hash_stats("Shared",SharedBufHash);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * bufmgr.c--
+ * buffer manager interface routines
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.1.1.1 1996/07/09 06:21:54 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ *
+ * BufferAlloc() -- lookup a buffer in the buffer table. If
+ * it isn't there add it, but do not read it into memory.
+ * This is used when we are about to reinitialize the
+ * buffer so don't care what the current disk contents are.
+ * BufferAlloc() pins the new buffer in memory.
+ *
+ * ReadBuffer() -- same as BufferAlloc() but reads the data
+ * on a buffer cache miss.
+ *
+ * ReleaseBuffer() -- unpin the buffer
+ *
+ * WriteNoReleaseBuffer() -- mark the buffer contents as "dirty"
+ * but don't unpin. The disk IO is delayed until buffer
+ * replacement if LateWrite flag is set.
+ *
+ * WriteBuffer() -- WriteNoReleaseBuffer() + ReleaseBuffer()
+ *
+ * DirtyBufferCopy() -- For a given dbid/relid/blockno, if the buffer is
+ * in the cache and is dirty, mark it clean and copy
+ * it to the requested location. This is a logical
+ * write, and has been installed to support the cache
+ * management code for write-once storage managers.
+ *
+ * FlushBuffer() -- as above but never delayed write.
+ *
+ * BufferSync() -- flush all dirty buffers in the buffer pool.
+ *
+ * InitBufferPool() -- Init the buffer module.
+ *
+ * See other files:
+ * freelist.c -- chooses victim for buffer replacement
+ * buf_table.c -- manages the buffer lookup table
+ */
+#include
+#include
+#include
+#include
+
+/* declarations split between these three files */
+#include "storage/buf.h"
+#include "storage/buf_internals.h"
+#include "storage/bufmgr.h"
+
+#include "storage/fd.h"
+#include "storage/ipc.h"
+#include "storage/shmem.h"
+#include "storage/spin.h"
+#include "storage/smgr.h"
+#include "storage/lmgr.h"
+#include "miscadmin.h"
+#include "utils/builtins.h"
+#include "utils/hsearch.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/memutils.h"
+#include "executor/execdebug.h" /* for NDirectFileRead */
+#include "catalog/catalog.h"
+
+extern int LateWrite;
+extern SPINLOCK BufMgrLock;
+extern int ReadBufferCount;
+extern int BufferHitCount;
+extern int BufferFlushCount;
+
+static void WaitIO(BufferDesc *buf, SPINLOCK spinlock);
+#ifndef HAS_TEST_AND_SET
+static void SignalIO(BufferDesc *buf);
+extern long *NWaitIOBackendP; /* defined in buf_init.c */
+#endif /* HAS_TEST_AND_SET */
+
+static Buffer ReadBufferWithBufferLock(Relation relation, BlockNumber blockNum,
+ bool bufferLockHeld);
+static BufferDesc *BufferAlloc(Relation reln, BlockNumber blockNum,
+ bool *foundPtr, bool bufferLockHeld);
+static int FlushBuffer(Buffer buffer);
+static void BufferSync(void);
+static int BufferReplace(BufferDesc *bufHdr, bool bufferLockHeld);
+
+/* ---------------------------------------------------
+ * RelationGetBufferWithBuffer
+ * see if the given buffer is what we want
+ * if yes, we don't need to bother the buffer manager
+ * ---------------------------------------------------
+ */
+Buffer
+RelationGetBufferWithBuffer(Relation relation,
+ BlockNumber blockNumber,
+ Buffer buffer)
+{
+ BufferDesc *bufHdr;
+ LRelId lrelId;
+
+ if (BufferIsValid(buffer)) {
+ if (!BufferIsLocal(buffer)) {
+ bufHdr = &BufferDescriptors[buffer-1];
+ lrelId = RelationGetLRelId(relation);
+ SpinAcquire(BufMgrLock);
+ if (bufHdr->tag.blockNum == blockNumber &&
+ bufHdr->tag.relId.relId == lrelId.relId &&
+ bufHdr->tag.relId.dbId == lrelId.dbId) {
+ SpinRelease(BufMgrLock);
+ return(buffer);
+ }
+ return(ReadBufferWithBufferLock(relation, blockNumber, true));
+ } else {
+ bufHdr = &LocalBufferDescriptors[-buffer-1];
+ if (bufHdr->tag.relId.relId == relation->rd_id &&
+ bufHdr->tag.blockNum == blockNumber) {
+ return(buffer);
+ }
+ }
+ }
+ return(ReadBuffer(relation, blockNumber));
+}
+
+/*
+ * ReadBuffer -- returns a buffer containing the requested
+ * block of the requested relation. If the blknum
+ * requested is P_NEW, extend the relation file and
+ * allocate a new block.
+ *
+ * Returns: the buffer number for the buffer containing
+ * the block read or NULL on an error.
+ *
+ * Assume when this function is called, that reln has been
+ * opened already.
+ */
+
+extern int ShowPinTrace;
+
+
+#undef ReadBuffer /* conflicts with macro when BUFMGR_DEBUG defined */
+
+/*
+ * ReadBuffer --
+ *
+ */
+Buffer
+ReadBuffer(Relation reln, BlockNumber blockNum)
+{
+ return ReadBufferWithBufferLock(reln, blockNum, false);
+}
+
+/*
+ * is_userbuffer
+ *
+ * XXX caller must have already acquired BufMgrLock
+ */
+static bool
+is_userbuffer(Buffer buffer)
+{
+ BufferDesc *buf = &BufferDescriptors[buffer-1];
+
+ if (IsSystemRelationName(buf->sb_relname))
+ return false;
+ return true;
+}
+
+Buffer
+ReadBuffer_Debug(char *file,
+ int line,
+ Relation reln,
+ BlockNumber blockNum)
+{
+ Buffer buffer;
+
+ buffer = ReadBufferWithBufferLock(reln, blockNum, false);
+ if (ShowPinTrace && !BufferIsLocal(buffer) && is_userbuffer(buffer)) {
+ BufferDesc *buf = &BufferDescriptors[buffer-1];
+
+ fprintf(stderr, "PIN(RD) %ld relname = %s, blockNum = %d, \
+refcount = %ld, file: %s, line: %d\n",
+ buffer, buf->sb_relname, buf->tag.blockNum,
+ PrivateRefCount[buffer - 1], file, line);
+ }
+ return buffer;
+}
+
+/*
+ * ReadBufferWithBufferLock -- does the work of
+ * ReadBuffer() but with the possibility that
+ * the buffer lock has already been held. this
+ * is yet another effort to reduce the number of
+ * semops in the system.
+ */
+static Buffer
+ReadBufferWithBufferLock(Relation reln,
+ BlockNumber blockNum,
+ bool bufferLockHeld)
+{
+ BufferDesc *bufHdr;
+ int extend; /* extending the file by one block */
+ int status;
+ bool found;
+ bool isLocalBuf;
+
+ extend = (blockNum == P_NEW);
+ isLocalBuf = reln->rd_islocal;
+
+ if (isLocalBuf) {
+ bufHdr = LocalBufferAlloc(reln, blockNum, &found);
+ } else {
+ ReadBufferCount++;
+
+ /* lookup the buffer. IO_IN_PROGRESS is set if the requested
+ * block is not currently in memory.
+ */
+ bufHdr = BufferAlloc(reln, blockNum, &found, bufferLockHeld);
+ if (found) BufferHitCount++;
+ }
+
+ if (!bufHdr) {
+ return(InvalidBuffer);
+ }
+
+ /* if its already in the buffer pool, we're done */
+ if (found) {
+ /*
+ * This happens when a bogus buffer was returned previously and is
+ * floating around in the buffer pool. A routine calling this would
+ * want this extended.
+ */
+ if (extend) {
+ /* new buffers are zero-filled */
+ memset((char *) MAKE_PTR(bufHdr->data), 0, BLCKSZ);
+ (void) smgrextend(bufHdr->bufsmgr, reln,
+ (char *) MAKE_PTR(bufHdr->data));
+ }
+ return (BufferDescriptorGetBuffer(bufHdr));
+
+ }
+
+ /*
+ * if we have gotten to this point, the reln pointer must be ok
+ * and the relation file must be open.
+ */
+ if (extend) {
+ /* new buffers are zero-filled */
+ (void) memset((char *) MAKE_PTR(bufHdr->data), 0, BLCKSZ);
+ status = smgrextend(bufHdr->bufsmgr, reln,
+ (char *) MAKE_PTR(bufHdr->data));
+ } else {
+ status = smgrread(bufHdr->bufsmgr, reln, blockNum,
+ (char *) MAKE_PTR(bufHdr->data));
+ }
+
+ if (isLocalBuf)
+ return (BufferDescriptorGetBuffer(bufHdr));
+
+ /* lock buffer manager again to update IO IN PROGRESS */
+ SpinAcquire(BufMgrLock);
+
+ if (status == SM_FAIL) {
+ /* IO Failed. cleanup the data structures and go home */
+
+ if (! BufTableDelete(bufHdr)) {
+ SpinRelease(BufMgrLock);
+ elog(FATAL,"BufRead: buffer table broken after IO error\n");
+ }
+ /* remember that BufferAlloc() pinned the buffer */
+ UnpinBuffer(bufHdr);
+
+ /*
+ * Have to reset the flag so that anyone waiting for
+ * the buffer can tell that the contents are invalid.
+ */
+ bufHdr->flags |= BM_IO_ERROR;
+
+ } else {
+ /* IO Succeeded. clear the flags, finish buffer update */
+
+ bufHdr->flags &= ~(BM_IO_ERROR | BM_IO_IN_PROGRESS);
+ }
+
+ /* If anyone was waiting for IO to complete, wake them up now */
+#ifdef HAS_TEST_AND_SET
+ S_UNLOCK(&(bufHdr->io_in_progress_lock));
+#else
+ if (bufHdr->refcount > 1)
+ SignalIO(bufHdr);
+#endif
+
+ SpinRelease(BufMgrLock);
+
+ return(BufferDescriptorGetBuffer(bufHdr));
+}
+
+/*
+ * BufferAlloc -- Get a buffer from the buffer pool but dont
+ * read it.
+ *
+ * Returns: descriptor for buffer
+ *
+ * When this routine returns, the BufMgrLock is guaranteed NOT be held.
+ */
+static BufferDesc *
+BufferAlloc(Relation reln,
+ BlockNumber blockNum,
+ bool *foundPtr,
+ bool bufferLockHeld)
+{
+ BufferDesc *buf, *buf2;
+ BufferTag newTag; /* identity of requested block */
+ bool inProgress; /* buffer undergoing IO */
+ bool newblock = FALSE;
+
+ /* create a new tag so we can lookup the buffer */
+ /* assume that the relation is already open */
+ if (blockNum == P_NEW) {
+ newblock = TRUE;
+ blockNum = smgrnblocks(reln->rd_rel->relsmgr, reln);
+ }
+
+ INIT_BUFFERTAG(&newTag,reln,blockNum);
+
+ if (!bufferLockHeld)
+ SpinAcquire(BufMgrLock);
+
+ /* see if the block is in the buffer pool already */
+ buf = BufTableLookup(&newTag);
+ if (buf != NULL) {
+ /* Found it. Now, (a) pin the buffer so no
+ * one steals it from the buffer pool,
+ * (b) check IO_IN_PROGRESS, someone may be
+ * faulting the buffer into the buffer pool.
+ */
+
+ PinBuffer(buf);
+ inProgress = (buf->flags & BM_IO_IN_PROGRESS);
+
+ *foundPtr = TRUE;
+ if (inProgress) {
+ WaitIO(buf, BufMgrLock);
+ if (buf->flags & BM_IO_ERROR) {
+ /* wierd race condition:
+ *
+ * We were waiting for someone else to read the buffer.
+ * While we were waiting, the reader boof'd in some
+ * way, so the contents of the buffer are still
+ * invalid. By saying that we didn't find it, we can
+ * make the caller reinitialize the buffer. If two
+ * processes are waiting for this block, both will
+ * read the block. The second one to finish may overwrite
+ * any updates made by the first. (Assume higher level
+ * synchronization prevents this from happening).
+ *
+ * This is never going to happen, don't worry about it.
+ */
+ *foundPtr = FALSE;
+ }
+ }
+#ifdef BMTRACE
+ _bm_trace((reln->rd_rel->relisshared ? 0 : MyDatabaseId), reln->rd_id, blockNum, BufferDescriptorGetBuffer(buf), BMT_ALLOCFND);
+#endif /* BMTRACE */
+
+ SpinRelease(BufMgrLock);
+
+ return(buf);
+ }
+
+ *foundPtr = FALSE;
+
+ /*
+ * Didn't find it in the buffer pool. We'll have
+ * to initialize a new buffer. First, grab one from
+ * the free list. If it's dirty, flush it to disk.
+ * Remember to unlock BufMgr spinlock while doing the IOs.
+ */
+ inProgress = FALSE;
+ for (buf = (BufferDesc *) NULL; buf == (BufferDesc *) NULL; ) {
+
+ /* GetFreeBuffer will abort if it can't find a free buffer */
+ buf = GetFreeBuffer();
+
+ /*
+ * There should be exactly one pin on the buffer after
+ * it is allocated -- ours. If it had a pin it wouldn't
+ * have been on the free list. No one else could have
+ * pinned it between GetFreeBuffer and here because we
+ * have the BufMgrLock.
+ */
+ Assert(buf->refcount == 0);
+ buf->refcount = 1;
+ PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 1;
+
+ if (buf->flags & BM_DIRTY) {
+ /*
+ * Set BM_IO_IN_PROGRESS to keep anyone from doing anything
+ * with the contents of the buffer while we write it out.
+ * We don't really care if they try to read it, but if they
+ * can complete a BufferAlloc on it they can then scribble
+ * into it, and we'd really like to avoid that while we are
+ * flushing the buffer. Setting this flag should block them
+ * in WaitIO until we're done.
+ */
+ inProgress = TRUE;
+ buf->flags |= BM_IO_IN_PROGRESS;
+#ifdef HAS_TEST_AND_SET
+ /*
+ * All code paths that acquire this lock pin the buffer
+ * first; since no one had it pinned (it just came off the
+ * free list), no one else can have this lock.
+ */
+ Assert(S_LOCK_FREE(&(buf->io_in_progress_lock)));
+ S_LOCK(&(buf->io_in_progress_lock));
+#endif /* HAS_TEST_AND_SET */
+
+ /*
+ * Write the buffer out, being careful to release BufMgrLock
+ * before starting the I/O.
+ *
+ * This #ifndef is here because a few extra semops REALLY kill
+ * you on machines that don't have spinlocks. If you don't
+ * operate with much concurrency, well...
+ */
+ (void) BufferReplace(buf, true);
+ BufferFlushCount++;
+#ifndef OPTIMIZE_SINGLE
+ SpinAcquire(BufMgrLock);
+#endif /* OPTIMIZE_SINGLE */
+
+ /*
+ * Somebody could have pinned the buffer while we were
+ * doing the I/O and had given up the BufMgrLock (though
+ * they would be waiting for us to clear the BM_IO_IN_PROGRESS
+ * flag). That's why this is a loop -- if so, we need to clear
+ * the I/O flags, remove our pin and start all over again.
+ *
+ * People may be making buffers free at any time, so there's
+ * no reason to think that we have an immediate disaster on
+ * our hands.
+ */
+ if (buf->refcount > 1) {
+ inProgress = FALSE;
+ buf->flags &= ~BM_IO_IN_PROGRESS;
+#ifdef HAS_TEST_AND_SET
+ S_UNLOCK(&(buf->io_in_progress_lock));
+#else /* !HAS_TEST_AND_SET */
+ if (buf->refcount > 1)
+ SignalIO(buf);
+#endif /* !HAS_TEST_AND_SET */
+ PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 0;
+ buf->refcount--;
+ buf = (BufferDesc *) NULL;
+ }
+
+ /*
+ * Somebody could have allocated another buffer for the
+ * same block we are about to read in. (While we flush out
+ * the dirty buffer, we don't hold the lock and someone could
+ * have allocated another buffer for the same block. The problem
+ * is we haven't gotten around to insert the new tag into
+ * the buffer table. So we need to check here. -ay 3/95
+ */
+ buf2 = BufTableLookup(&newTag);
+ if (buf2 != NULL) {
+ /* Found it. Someone has already done what we're about
+ * to do. We'll just handle this as if it were found in
+ * the buffer pool in the first place.
+ */
+
+ PinBuffer(buf2);
+ inProgress = (buf2->flags & BM_IO_IN_PROGRESS);
+
+ *foundPtr = TRUE;
+ if (inProgress) {
+ WaitIO(buf2, BufMgrLock);
+ if (buf2->flags & BM_IO_ERROR) {
+ *foundPtr = FALSE;
+ }
+ }
+
+#ifdef HAS_TEST_AND_SET
+ S_UNLOCK(&(buf->io_in_progress_lock));
+#else /* !HAS_TEST_AND_SET */
+ if (buf->refcount > 1)
+ SignalIO(buf);
+#endif /* !HAS_TEST_AND_SET */
+
+ /* give up the buffer since we don't need it any more */
+ buf->refcount--;
+ PrivateRefCount[BufferDescriptorGetBuffer(buf) - 1] = 0;
+ AddBufferToFreelist(buf);
+ buf->flags |= BM_FREE;
+ buf->flags &= ~BM_DIRTY;
+ buf->flags &= ~BM_IO_IN_PROGRESS;
+
+ SpinRelease(BufMgrLock);
+
+ return(buf2);
+ }
+ }
+ }
+ /*
+ * At this point we should have the sole pin on a non-dirty
+ * buffer and we may or may not already have the BM_IO_IN_PROGRESS
+ * flag set.
+ */
+
+ /*
+ * Change the name of the buffer in the lookup table:
+ *
+ * Need to update the lookup table before the read starts.
+ * If someone comes along looking for the buffer while
+ * we are reading it in, we don't want them to allocate
+ * a new buffer. For the same reason, we didn't want
+ * to erase the buf table entry for the buffer we were
+ * writing back until now, either.
+ */
+
+ if (! BufTableDelete(buf)) {
+ SpinRelease(BufMgrLock);
+ elog(FATAL,"buffer wasn't in the buffer table\n");
+
+ }
+
+ if (buf->flags & BM_DIRTY) {
+ /* must clear flag first because of wierd race
+ * condition described below.
+ */
+ buf->flags &= ~BM_DIRTY;
+ }
+
+ /* record the database name and relation name for this buffer */
+ buf->sb_relname = pstrdup(reln->rd_rel->relname.data);
+ buf->sb_dbname = pstrdup(GetDatabaseName());
+
+ /* remember which storage manager is responsible for it */
+ buf->bufsmgr = reln->rd_rel->relsmgr;
+
+ INIT_BUFFERTAG(&(buf->tag),reln,blockNum);
+ if (! BufTableInsert(buf)) {
+ SpinRelease(BufMgrLock);
+ elog(FATAL,"Buffer in lookup table twice \n");
+ }
+
+ /* Buffer contents are currently invalid. Have
+ * to mark IO IN PROGRESS so no one fiddles with
+ * them until the read completes. If this routine
+ * has been called simply to allocate a buffer, no
+ * io will be attempted, so the flag isnt set.
+ */
+ if (!inProgress) {
+ buf->flags |= BM_IO_IN_PROGRESS;
+#ifdef HAS_TEST_AND_SET
+ Assert(S_LOCK_FREE(&(buf->io_in_progress_lock)));
+ S_LOCK(&(buf->io_in_progress_lock));
+#endif /* HAS_TEST_AND_SET */
+ }
+
+#ifdef BMTRACE
+ _bm_trace((reln->rd_rel->relisshared ? 0 : MyDatabaseId), reln->rd_id, blockNum, BufferDescriptorGetBuffer(buf), BMT_ALLOCNOTFND);
+#endif /* BMTRACE */
+
+ SpinRelease(BufMgrLock);
+
+ return (buf);
+}
+
+/*
+ * WriteBuffer--
+ *
+ * Pushes buffer contents to disk if LateWrite is
+ * not set. Otherwise, marks contents as dirty.
+ *
+ * Assume that buffer is pinned. Assume that reln is
+ * valid.
+ *
+ * Side Effects:
+ * Pin count is decremented.
+ */
+
+#undef WriteBuffer
+
+int
+WriteBuffer(Buffer buffer)
+{
+ BufferDesc *bufHdr;
+
+ if (! LateWrite) {
+ return(FlushBuffer(buffer));
+ } else {
+
+ if (BufferIsLocal(buffer))
+ return WriteLocalBuffer(buffer, TRUE);
+
+ if (BAD_BUFFER_ID(buffer))
+ return(FALSE);
+
+ bufHdr = &BufferDescriptors[buffer-1];
+
+ SpinAcquire(BufMgrLock);
+ Assert(bufHdr->refcount > 0);
+ bufHdr->flags |= BM_DIRTY;
+ UnpinBuffer(bufHdr);
+ SpinRelease(BufMgrLock);
+ }
+ return(TRUE);
+}
+
+void
+WriteBuffer_Debug(char *file, int line, Buffer buffer)
+{
+ WriteBuffer(buffer);
+ if (ShowPinTrace && BufferIsLocal(buffer) && is_userbuffer(buffer)) {
+ BufferDesc *buf;
+ buf = &BufferDescriptors[buffer-1];
+ fprintf(stderr, "UNPIN(WR) %ld relname = %s, blockNum = %d, \
+refcount = %ld, file: %s, line: %d\n",
+ buffer, buf->sb_relname, buf->tag.blockNum,
+ PrivateRefCount[buffer - 1], file, line);
+ }
+}
+
+/*
+ * DirtyBufferCopy() -- Copy a given dirty buffer to the requested
+ * destination.
+ *
+ * We treat this as a write. If the requested buffer is in the pool
+ * and is dirty, we copy it to the location requested and mark it
+ * clean. This routine supports the Sony jukebox storage manager,
+ * which agrees to take responsibility for the data once we mark
+ * it clean.
+ *
+ * NOTE: used by sony jukebox code in postgres 4.2 - ay 2/95
+ */
+void
+DirtyBufferCopy(Oid dbid, Oid relid, BlockNumber blkno, char *dest)
+{
+ BufferDesc *buf;
+ BufferTag btag;
+
+ btag.relId.relId = relid;
+ btag.relId.dbId = dbid;
+ btag.blockNum = blkno;
+
+ SpinAcquire(BufMgrLock);
+ buf = BufTableLookup(&btag);
+
+ if (buf == (BufferDesc *) NULL
+ || !(buf->flags & BM_DIRTY)
+ || !(buf->flags & BM_VALID)) {
+ SpinRelease(BufMgrLock);
+ return;
+ }
+
+ /* hate to do this holding the lock, but release and reacquire is slower */
+ memmove(dest, (char *) MAKE_PTR(buf->data), BLCKSZ);
+
+ buf->flags &= ~BM_DIRTY;
+
+ SpinRelease(BufMgrLock);
+}
+
+/*
+ * FlushBuffer -- like WriteBuffer, but force the page to disk.
+ *
+ * 'buffer' is known to be dirty/pinned, so there should not be a
+ * problem reading the BufferDesc members without the BufMgrLock
+ * (nobody should be able to change tags, flags, etc. out from under
+ * us).
+ */
+static int
+FlushBuffer(Buffer buffer)
+{
+ BufferDesc *bufHdr;
+
+ if (BufferIsLocal(buffer))
+ return FlushLocalBuffer(buffer);
+
+ if (BAD_BUFFER_ID(buffer))
+ return (STATUS_ERROR);
+
+ bufHdr = &BufferDescriptors[buffer-1];
+
+ if (!BufferReplace(bufHdr, false)) {
+ elog(WARN, "FlushBuffer: cannot flush %d", bufHdr->tag.blockNum);
+ return (STATUS_ERROR);
+ }
+
+ SpinAcquire(BufMgrLock);
+ bufHdr->flags &= ~BM_DIRTY;
+ UnpinBuffer(bufHdr);
+ SpinRelease(BufMgrLock);
+
+ return(STATUS_OK);
+}
+
+/*
+ * WriteNoReleaseBuffer -- like WriteBuffer, but do not unpin the buffer
+ * when the operation is complete.
+ *
+ * We know that the buffer is for a relation in our private cache,
+ * because this routine is called only to write out buffers that
+ * were changed by the executing backend.
+ */
+int
+WriteNoReleaseBuffer(Buffer buffer)
+{
+ BufferDesc *bufHdr;
+
+ if (! LateWrite) {
+ return(FlushBuffer(buffer));
+ } else {
+
+ if (BufferIsLocal(buffer))
+ return WriteLocalBuffer(buffer, FALSE);
+
+ if (BAD_BUFFER_ID(buffer))
+ return (STATUS_ERROR);
+
+ bufHdr = &BufferDescriptors[buffer-1];
+
+ SpinAcquire(BufMgrLock);
+ bufHdr->flags |= BM_DIRTY;
+ SpinRelease(BufMgrLock);
+ }
+ return(STATUS_OK);
+}
+
+
+#undef ReleaseAndReadBuffer
+/*
+ * ReleaseAndReadBuffer -- combine ReleaseBuffer() and ReadBuffer()
+ * so that only one semop needs to be called.
+ *
+ */
+Buffer
+ReleaseAndReadBuffer(Buffer buffer,
+ Relation relation,
+ BlockNumber blockNum)
+{
+ BufferDesc *bufHdr;
+ Buffer retbuf;
+
+ if (BufferIsLocal(buffer)) {
+ Assert(LocalRefCount[-buffer - 1] > 0);
+ LocalRefCount[-buffer - 1]--;
+ } else {
+ if (BufferIsValid(buffer)) {
+ bufHdr = &BufferDescriptors[buffer-1];
+ Assert(PrivateRefCount[buffer - 1] > 0);
+ PrivateRefCount[buffer - 1]--;
+ if (PrivateRefCount[buffer - 1] == 0 &&
+ LastRefCount[buffer - 1] == 0) {
+ /* only release buffer if it is not pinned in previous ExecMain
+ level */
+ SpinAcquire(BufMgrLock);
+ bufHdr->refcount--;
+ if (bufHdr->refcount == 0) {
+ AddBufferToFreelist(bufHdr);
+ bufHdr->flags |= BM_FREE;
+ }
+ retbuf = ReadBufferWithBufferLock(relation, blockNum, true);
+ return retbuf;
+ }
+ }
+ }
+
+ return (ReadBuffer(relation, blockNum));
+}
+
+/*
+ * BufferSync -- Flush all dirty buffers in the pool.
+ *
+ * This is called at transaction commit time. It does the wrong thing,
+ * right now. We should flush only our own changes to stable storage,
+ * and we should obey the lock protocol on the buffer manager metadata
+ * as we do it. Also, we need to be sure that no other transaction is
+ * modifying the page as we flush it. This is only a problem for objects
+ * that use a non-two-phase locking protocol, like btree indices. For
+ * those objects, we would like to set a write lock for the duration of
+ * our IO. Another possibility is to code updates to btree pages
+ * carefully, so that writing them out out of order cannot cause
+ * any unrecoverable errors.
+ *
+ * I don't want to think hard about this right now, so I will try
+ * to come back to it later.
+ */
+static void
+BufferSync()
+{
+ int i;
+ Oid bufdb;
+ Oid bufrel;
+ Relation reln;
+ BufferDesc *bufHdr;
+ int status;
+
+ SpinAcquire(BufMgrLock);
+ for (i=0, bufHdr = BufferDescriptors; i < NBuffers; i++, bufHdr++) {
+ if ((bufHdr->flags & BM_VALID) && (bufHdr->flags & BM_DIRTY)) {
+ bufdb = bufHdr->tag.relId.dbId;
+ bufrel = bufHdr->tag.relId.relId;
+ if (bufdb == MyDatabaseId || bufdb == (Oid) 0) {
+ reln = RelationIdCacheGetRelation(bufrel);
+
+ /*
+ * If we didn't have the reldesc in our local cache, flush this
+ * page out using the 'blind write' storage manager routine. If
+ * we did find it, use the standard interface.
+ */
+
+#ifndef OPTIMIZE_SINGLE
+ SpinRelease(BufMgrLock);
+#endif /* OPTIMIZE_SINGLE */
+ if (reln == (Relation) NULL) {
+ status = smgrblindwrt(bufHdr->bufsmgr, bufHdr->sb_dbname,
+ bufHdr->sb_relname, bufdb, bufrel,
+ bufHdr->tag.blockNum,
+ (char *) MAKE_PTR(bufHdr->data));
+ } else {
+ status = smgrwrite(bufHdr->bufsmgr, reln,
+ bufHdr->tag.blockNum,
+ (char *) MAKE_PTR(bufHdr->data));
+ }
+#ifndef OPTIMIZE_SINGLE
+ SpinAcquire(BufMgrLock);
+#endif /* OPTIMIZE_SINGLE */
+
+ if (status == SM_FAIL) {
+ elog(WARN, "cannot write %d for %16s",
+ bufHdr->tag.blockNum, bufHdr->sb_relname);
+ }
+
+ bufHdr->flags &= ~BM_DIRTY;
+ if (reln != (Relation)NULL)
+ RelationDecrementReferenceCount(reln);
+ }
+ }
+ }
+ SpinRelease(BufMgrLock);
+
+ LocalBufferSync();
+}
+
+
+/*
+ * WaitIO -- Block until the IO_IN_PROGRESS flag on 'buf'
+ * is cleared. Because IO_IN_PROGRESS conflicts are
+ * expected to be rare, there is only one BufferIO
+ * lock in the entire system. All processes block
+ * on this semaphore when they try to use a buffer
+ * that someone else is faulting in. Whenever a
+ * process finishes an IO and someone is waiting for
+ * the buffer, BufferIO is signaled (SignalIO). All
+ * waiting processes then wake up and check to see
+ * if their buffer is now ready. This implementation
+ * is simple, but efficient enough if WaitIO is
+ * rarely called by multiple processes simultaneously.
+ *
+ * ProcSleep atomically releases the spinlock and goes to
+ * sleep.
+ *
+ * Note: there is an easy fix if the queue becomes long.
+ * save the id of the buffer we are waiting for in
+ * the queue structure. That way signal can figure
+ * out which proc to wake up.
+ */
+#ifdef HAS_TEST_AND_SET
+static void
+WaitIO(BufferDesc *buf, SPINLOCK spinlock)
+{
+ SpinRelease(spinlock);
+ S_LOCK(&(buf->io_in_progress_lock));
+ S_UNLOCK(&(buf->io_in_progress_lock));
+ SpinAcquire(spinlock);
+}
+
+#else /* HAS_TEST_AND_SET */
+IpcSemaphoreId WaitIOSemId;
+
+static void
+WaitIO(BufferDesc *buf, SPINLOCK spinlock)
+{
+ bool inProgress;
+
+ for (;;) {
+
+ /* wait until someone releases IO lock */
+ (*NWaitIOBackendP)++;
+ SpinRelease(spinlock);
+ IpcSemaphoreLock(WaitIOSemId, 0, 1);
+ SpinAcquire(spinlock);
+ inProgress = (buf->flags & BM_IO_IN_PROGRESS);
+ if (!inProgress) break;
+ }
+}
+
+/*
+ * SignalIO --
+ */
+static void
+SignalIO(BufferDesc *buf)
+{
+ /* somebody better be waiting. */
+ Assert( buf->refcount > 1);
+ IpcSemaphoreUnlock(WaitIOSemId, 0, *NWaitIOBackendP);
+ *NWaitIOBackendP = 0;
+}
+#endif /* HAS_TEST_AND_SET */
+
+long NDirectFileRead; /* some I/O's are direct file access. bypass bufmgr */
+long NDirectFileWrite; /* e.g., I/O in psort and hashjoin. */
+
+void
+PrintBufferUsage(FILE *statfp)
+{
+ float hitrate;
+
+ if (ReadBufferCount==0)
+ hitrate = 0.0;
+ else
+ hitrate = (float)BufferHitCount * 100.0/ReadBufferCount;
+
+ fprintf(statfp, "!\t%ld blocks read, %ld blocks written, buffer hit rate = %.2f%%\n",
+ ReadBufferCount - BufferHitCount + NDirectFileRead,
+ BufferFlushCount + NDirectFileWrite,
+ hitrate);
+}
+
+void
+ResetBufferUsage()
+{
+ BufferHitCount = 0;
+ ReadBufferCount = 0;
+ BufferFlushCount = 0;
+ NDirectFileRead = 0;
+ NDirectFileWrite = 0;
+}
+
+/* ----------------------------------------------
+ * ResetBufferPool
+ *
+ * this routine is supposed to be called when a transaction aborts.
+ * it will release all the buffer pins held by the transaciton.
+ *
+ * ----------------------------------------------
+ */
+void
+ResetBufferPool()
+{
+ register int i;
+ for (i=1; i<=NBuffers; i++) {
+ if (BufferIsValid(i)) {
+ while(PrivateRefCount[i - 1] > 0) {
+ ReleaseBuffer(i);
+ }
+ }
+ LastRefCount[i - 1] = 0;
+ }
+
+ ResetLocalBufferPool();
+}
+
+/* -----------------------------------------------
+ * BufferPoolCheckLeak
+ *
+ * check if there is buffer leak
+ *
+ * -----------------------------------------------
+ */
+int
+BufferPoolCheckLeak()
+{
+ register int i;
+ void PrintBufferDescs();
+
+ for (i = 1; i <= NBuffers; i++) {
+ if (BufferIsValid(i)) {
+ elog(NOTICE, "buffer leak detected in BufferPoolCheckLeak()");
+ PrintBufferDescs();
+ return(1);
+ }
+ }
+ return(0);
+}
+
+/* ------------------------------------------------
+ * FlushBufferPool
+ *
+ * flush all dirty blocks in buffer pool to disk
+ *
+ * ------------------------------------------------
+ */
+void
+FlushBufferPool(int StableMainMemoryFlag)
+{
+ if (!StableMainMemoryFlag) {
+ BufferSync();
+ smgrcommit();
+ }
+}
+
+/*
+ * BufferIsValid --
+ * True iff the refcnt of the local buffer is > 0
+ * Note:
+ * BufferIsValid(InvalidBuffer) is False.
+ * BufferIsValid(UnknownBuffer) is False.
+ */
+bool
+BufferIsValid(Buffer bufnum)
+{
+ if (BufferIsLocal(bufnum))
+ return (bufnum >= -NLocBuffer && LocalRefCount[-bufnum - 1] > 0);
+
+ if (BAD_BUFFER_ID(bufnum))
+ return(false);
+
+ return ((bool)(PrivateRefCount[bufnum - 1] > 0));
+}
+
+/*
+ * BufferGetBlockNumber --
+ * Returns the block number associated with a buffer.
+ *
+ * Note:
+ * Assumes that the buffer is valid.
+ */
+BlockNumber
+BufferGetBlockNumber(Buffer buffer)
+{
+ Assert(BufferIsValid(buffer));
+
+ /* XXX should be a critical section */
+ if (BufferIsLocal(buffer))
+ return (LocalBufferDescriptors[-buffer-1].tag.blockNum);
+ else
+ return (BufferDescriptors[buffer-1].tag.blockNum);
+}
+
+/*
+ * BufferGetRelation --
+ * Returns the relation desciptor associated with a buffer.
+ *
+ * Note:
+ * Assumes buffer is valid.
+ */
+Relation
+BufferGetRelation(Buffer buffer)
+{
+ Relation relation;
+ Oid relid;
+
+ Assert(BufferIsValid(buffer));
+ Assert(!BufferIsLocal(buffer)); /* not supported for local buffers */
+
+ /* XXX should be a critical section */
+ relid = LRelIdGetRelationId(BufferDescriptors[buffer-1].tag.relId);
+ relation = RelationIdGetRelation(relid);
+
+ RelationDecrementReferenceCount(relation);
+
+ if (RelationHasReferenceCountZero(relation)) {
+ /*
+ elog(NOTICE, "BufferGetRelation: 0->1");
+ */
+
+ RelationIncrementReferenceCount(relation);
+ }
+
+ return (relation);
+}
+
+/*
+ * BufferReplace
+ *
+ * Flush the buffer corresponding to 'bufHdr'
+ *
+ * Assumes that the BufMgrLock has NOT been acquired.
+ */
+static int
+BufferReplace(BufferDesc *bufHdr, bool bufferLockHeld)
+{
+ Relation reln;
+ Oid bufdb, bufrel;
+ int status;
+
+ if (!bufferLockHeld)
+ SpinAcquire(BufMgrLock);
+
+ /*
+ * first try to find the reldesc in the cache, if no luck,
+ * don't bother to build the reldesc from scratch, just do
+ * a blind write.
+ */
+
+ bufdb = bufHdr->tag.relId.dbId;
+ bufrel = bufHdr->tag.relId.relId;
+
+ if (bufdb == MyDatabaseId || bufdb == (Oid) NULL)
+ reln = RelationIdCacheGetRelation(bufrel);
+ else
+ reln = (Relation) NULL;
+
+ SpinRelease(BufMgrLock);
+
+ if (reln != (Relation) NULL) {
+ status = smgrflush(bufHdr->bufsmgr, reln, bufHdr->tag.blockNum,
+ (char *) MAKE_PTR(bufHdr->data));
+ } else {
+
+ /* blind write always flushes */
+ status = smgrblindwrt(bufHdr->bufsmgr, bufHdr->sb_dbname,
+ bufHdr->sb_relname, bufdb, bufrel,
+ bufHdr->tag.blockNum,
+ (char *) MAKE_PTR(bufHdr->data));
+ }
+
+ if (status == SM_FAIL)
+ return (FALSE);
+
+ return (TRUE);
+}
+
+/*
+ * RelationGetNumberOfBlocks --
+ * Returns the buffer descriptor associated with a page in a relation.
+ *
+ * Note:
+ * XXX may fail for huge relations.
+ * XXX should be elsewhere.
+ * XXX maybe should be hidden
+ */
+BlockNumber
+RelationGetNumberOfBlocks(Relation relation)
+{
+ return
+ ((relation->rd_islocal) ? relation->rd_nblocks :
+ smgrnblocks(relation->rd_rel->relsmgr, relation));
+}
+
+/*
+ * BufferGetBlock --
+ * Returns a reference to a disk page image associated with a buffer.
+ *
+ * Note:
+ * Assumes buffer is valid.
+ */
+Block
+BufferGetBlock(Buffer buffer)
+{
+ Assert(BufferIsValid(buffer));
+
+ if (BufferIsLocal(buffer))
+ return((Block)MAKE_PTR(LocalBufferDescriptors[-buffer-1].data));
+ else
+ return((Block)MAKE_PTR(BufferDescriptors[buffer-1].data));
+}
+
+/* ---------------------------------------------------------------------
+ * ReleaseTmpRelBuffers
+ *
+ * this function unmarks all the dirty pages of a temporary
+ * relation in the buffer pool so that at the end of transaction
+ * these pages will not be flushed.
+ * XXX currently it sequentially searches the buffer pool, should be
+ * changed to more clever ways of searching.
+ * --------------------------------------------------------------------
+ */
+void
+ReleaseTmpRelBuffers(Relation tempreldesc)
+{
+ register int i;
+ int holding = 0;
+ BufferDesc *buf;
+
+ for (i=1; i<=NBuffers; i++) {
+ buf = &BufferDescriptors[i-1];
+ if (!holding) {
+ SpinAcquire(BufMgrLock);
+ holding = 1;
+ }
+ if ((buf->flags & BM_DIRTY) &&
+ (buf->tag.relId.dbId == MyDatabaseId) &&
+ (buf->tag.relId.relId == tempreldesc->rd_id)) {
+ buf->flags &= ~BM_DIRTY;
+ if (!(buf->flags & BM_FREE)) {
+ SpinRelease(BufMgrLock);
+ holding = 0;
+ ReleaseBuffer(i);
+ }
+ }
+ }
+ if (holding)
+ SpinRelease(BufMgrLock);
+}
+
+/* ---------------------------------------------------------------------
+ * DropBuffers
+ *
+ * This function marks all the buffers in the buffer cache for a
+ * particular database as clean. This is used when we destroy a
+ * database, to avoid trying to flush data to disk when the directory
+ * tree no longer exists.
+ *
+ * This is an exceedingly non-public interface.
+ * --------------------------------------------------------------------
+ */
+void
+DropBuffers(Oid dbid)
+{
+ register int i;
+ BufferDesc *buf;
+
+ SpinAcquire(BufMgrLock);
+ for (i=1; i<=NBuffers; i++) {
+ buf = &BufferDescriptors[i-1];
+ if ((buf->tag.relId.dbId == dbid) && (buf->flags & BM_DIRTY)) {
+ buf->flags &= ~BM_DIRTY;
+ }
+ }
+ SpinRelease(BufMgrLock);
+}
+
+/* -----------------------------------------------------------------
+ * PrintBufferDescs
+ *
+ * this function prints all the buffer descriptors, for debugging
+ * use only.
+ * -----------------------------------------------------------------
+ */
+void
+PrintBufferDescs()
+{
+ int i;
+ BufferDesc *buf = BufferDescriptors;
+
+ if (IsUnderPostmaster) {
+ SpinAcquire(BufMgrLock);
+ for (i = 0; i < NBuffers; ++i, ++buf) {
+ elog(NOTICE, "[%02d] (freeNext=%d, freePrev=%d, relname=%.*s, \
+blockNum=%d, flags=0x%x, refcount=%d %d)",
+ i, buf->freeNext, buf->freePrev, NAMEDATALEN,
+ &(buf->sb_relname), buf->tag.blockNum, buf->flags,
+ buf->refcount, PrivateRefCount[i]);
+ }
+ SpinRelease(BufMgrLock);
+ } else {
+ /* interactive backend */
+ for (i = 0; i < NBuffers; ++i, ++buf) {
+ printf("[%-2d] (%s, %d) flags=0x%x, refcnt=%d %ld)\n",
+ i, buf->sb_relname, buf->tag.blockNum,
+ buf->flags, buf->refcount, PrivateRefCount[i]);
+ }
+ }
+}
+
+void
+PrintPinnedBufs()
+{
+ int i;
+ BufferDesc *buf = BufferDescriptors;
+
+ SpinAcquire(BufMgrLock);
+ for (i = 0; i < NBuffers; ++i, ++buf) {
+ if (PrivateRefCount[i] > 0)
+ elog(NOTICE, "[%02d] (freeNext=%d, freePrev=%d, relname=%.*s, \
+blockNum=%d, flags=0x%x, refcount=%d %d)\n",
+ i, buf->freeNext, buf->freePrev, NAMEDATALEN, &(buf->sb_relname),
+ buf->tag.blockNum, buf->flags,
+ buf->refcount, PrivateRefCount[i]);
+ }
+ SpinRelease(BufMgrLock);
+}
+
+/*
+ * BufferPoolBlowaway
+ *
+ * this routine is solely for the purpose of experiments -- sometimes
+ * you may want to blowaway whatever is left from the past in buffer
+ * pool and start measuring some performance with a clean empty buffer
+ * pool.
+ */
+void
+BufferPoolBlowaway()
+{
+ register int i;
+
+ BufferSync();
+ for (i=1; i<=NBuffers; i++) {
+ if (BufferIsValid(i)) {
+ while(BufferIsValid(i))
+ ReleaseBuffer(i);
+ }
+ BufTableDelete(&BufferDescriptors[i-1]);
+ }
+}
+
+#undef IncrBufferRefCount
+#undef ReleaseBuffer
+
+void
+IncrBufferRefCount(Buffer buffer)
+{
+ if (BufferIsLocal(buffer)) {
+ Assert(LocalRefCount[-buffer - 1] >= 0);
+ LocalRefCount[-buffer - 1]++;
+ } else {
+ Assert(!BAD_BUFFER_ID(buffer));
+ Assert(PrivateRefCount[buffer - 1] >= 0);
+ PrivateRefCount[buffer - 1]++;
+ }
+}
+
+/*
+ * ReleaseBuffer -- remove the pin on a buffer without
+ * marking it dirty.
+ *
+ */
+int
+ReleaseBuffer(Buffer buffer)
+{
+ BufferDesc *bufHdr;
+
+ if (BufferIsLocal(buffer)) {
+ Assert(LocalRefCount[-buffer - 1] > 0);
+ LocalRefCount[-buffer - 1]--;
+ return (STATUS_OK);
+ }
+
+ if (BAD_BUFFER_ID(buffer))
+ return(STATUS_ERROR);
+
+ bufHdr = &BufferDescriptors[buffer-1];
+
+ Assert(PrivateRefCount[buffer - 1] > 0);
+ PrivateRefCount[buffer - 1]--;
+ if (PrivateRefCount[buffer - 1] == 0 && LastRefCount[buffer - 1] == 0) {
+ /* only release buffer if it is not pinned in previous ExecMain
+ levels */
+ SpinAcquire(BufMgrLock);
+ bufHdr->refcount--;
+ if (bufHdr->refcount == 0) {
+ AddBufferToFreelist(bufHdr);
+ bufHdr->flags |= BM_FREE;
+ }
+ SpinRelease(BufMgrLock);
+ }
+
+ return(STATUS_OK);
+}
+
+void
+IncrBufferRefCount_Debug(char *file, int line, Buffer buffer)
+{
+ IncrBufferRefCount(buffer);
+ if (ShowPinTrace && !BufferIsLocal(buffer) && is_userbuffer(buffer)) {
+ BufferDesc *buf = &BufferDescriptors[buffer-1];
+
+ fprintf(stderr, "PIN(Incr) %ld relname = %s, blockNum = %d, \
+refcount = %ld, file: %s, line: %d\n",
+ buffer, buf->sb_relname, buf->tag.blockNum,
+ PrivateRefCount[buffer - 1], file, line);
+ }
+}
+
+void
+ReleaseBuffer_Debug(char *file, int line, Buffer buffer)
+{
+ ReleaseBuffer(buffer);
+ if (ShowPinTrace && !BufferIsLocal(buffer) && is_userbuffer(buffer)) {
+ BufferDesc *buf = &BufferDescriptors[buffer-1];
+
+ fprintf(stderr, "UNPIN(Rel) %ld relname = %s, blockNum = %d, \
+refcount = %ld, file: %s, line: %d\n",
+ buffer, buf->sb_relname, buf->tag.blockNum,
+ PrivateRefCount[buffer - 1], file, line);
+ }
+}
+
+int
+ReleaseAndReadBuffer_Debug(char *file,
+ int line,
+ Buffer buffer,
+ Relation relation,
+ BlockNumber blockNum)
+{
+ bool bufferValid;
+ Buffer b;
+
+ bufferValid = BufferIsValid(buffer);
+ b = ReleaseAndReadBuffer(buffer, relation, blockNum);
+ if (ShowPinTrace && bufferValid && BufferIsLocal(buffer)
+ && is_userbuffer(buffer)) {
+ BufferDesc *buf = &BufferDescriptors[buffer-1];
+
+ fprintf(stderr, "UNPIN(Rel&Rd) %ld relname = %s, blockNum = %d, \
+refcount = %ld, file: %s, line: %d\n",
+ buffer, buf->sb_relname, buf->tag.blockNum,
+ PrivateRefCount[buffer - 1], file, line);
+ }
+ if (ShowPinTrace && BufferIsLocal(buffer) && is_userbuffer(buffer)) {
+ BufferDesc *buf = &BufferDescriptors[b-1];
+
+ fprintf(stderr, "PIN(Rel&Rd) %ld relname = %s, blockNum = %d, \
+refcount = %ld, file: %s, line: %d\n",
+ b, buf->sb_relname, buf->tag.blockNum,
+ PrivateRefCount[b - 1], file, line);
+ }
+ return b;
+}
+
+#ifdef BMTRACE
+
+/*
+ * trace allocations and deallocations in a circular buffer in
+ * shared memory. check the buffer before doing the allocation,
+ * and die if there's anything fishy.
+ */
+
+_bm_trace(Oid dbId, Oid relId, int blkNo, int bufNo, int allocType)
+{
+ static int mypid = 0;
+ long start, cur;
+ bmtrace *tb;
+
+ if (mypid == 0)
+ mypid = getpid();
+
+ start = *CurTraceBuf;
+
+ if (start > 0)
+ cur = start - 1;
+ else
+ cur = BMT_LIMIT - 1;
+
+ for (;;) {
+ tb = &TraceBuf[cur];
+ if (tb->bmt_op != BMT_NOTUSED) {
+ if (tb->bmt_buf == bufNo) {
+ if ((tb->bmt_op == BMT_DEALLOC)
+ || (tb->bmt_dbid == dbId && tb->bmt_relid == relId
+ && tb->bmt_blkno == blkNo))
+ goto okay;
+
+ /* die holding the buffer lock */
+ _bm_die(dbId, relId, blkNo, bufNo, allocType, start, cur);
+ }
+ }
+
+ if (cur == start)
+ goto okay;
+
+ if (cur == 0)
+ cur = BMT_LIMIT - 1;
+ else
+ cur--;
+ }
+
+ okay:
+ tb = &TraceBuf[start];
+ tb->bmt_pid = mypid;
+ tb->bmt_buf = bufNo;
+ tb->bmt_dbid = dbId;
+ tb->bmt_relid = relId;
+ tb->bmt_blkno = blkNo;
+ tb->bmt_op = allocType;
+
+ *CurTraceBuf = (start + 1) % BMT_LIMIT;
+}
+
+_bm_die(Oid dbId, Oid relId, int blkNo, int bufNo,
+ int allocType, long start, long cur)
+{
+ FILE *fp;
+ bmtrace *tb;
+ int i;
+
+ tb = &TraceBuf[cur];
+
+ if ((fp = fopen("/tmp/death_notice", "w")) == (FILE *) NULL)
+ elog(FATAL, "buffer alloc trace error and can't open log file");
+
+ fprintf(fp, "buffer alloc trace detected the following error:\n\n");
+ fprintf(fp, " buffer %d being %s inconsistently with a previous %s\n\n",
+ bufNo, (allocType == BMT_DEALLOC ? "deallocated" : "allocated"),
+ (tb->bmt_op == BMT_DEALLOC ? "deallocation" : "allocation"));
+
+ fprintf(fp, "the trace buffer contains:\n");
+
+ i = start;
+ for (;;) {
+ tb = &TraceBuf[i];
+ if (tb->bmt_op != BMT_NOTUSED) {
+ fprintf(fp, " [%3d]%spid %d buf %2d for <%d,%d,%d> ",
+ i, (i == cur ? " ---> " : "\t"),
+ tb->bmt_pid, tb->bmt_buf,
+ tb->bmt_dbid, tb->bmt_relid, tb->bmt_blkno);
+
+ switch (tb->bmt_op) {
+ case BMT_ALLOCFND:
+ fprintf(fp, "allocate (found)\n");
+ break;
+
+ case BMT_ALLOCNOTFND:
+ fprintf(fp, "allocate (not found)\n");
+ break;
+
+ case BMT_DEALLOC:
+ fprintf(fp, "deallocate\n");
+ break;
+
+ default:
+ fprintf(fp, "unknown op type %d\n", tb->bmt_op);
+ break;
+ }
+ }
+
+ i = (i + 1) % BMT_LIMIT;
+ if (i == start)
+ break;
+ }
+
+ fprintf(fp, "\noperation causing error:\n");
+ fprintf(fp, "\tpid %d buf %d for <%d,%d,%d> ",
+ getpid(), bufNo, dbId, relId, blkNo);
+
+ switch (allocType) {
+ case BMT_ALLOCFND:
+ fprintf(fp, "allocate (found)\n");
+ break;
+
+ case BMT_ALLOCNOTFND:
+ fprintf(fp, "allocate (not found)\n");
+ break;
+
+ case BMT_DEALLOC:
+ fprintf(fp, "deallocate\n");
+ break;
+
+ default:
+ fprintf(fp, "unknown op type %d\n", allocType);
+ break;
+ }
+
+ (void) fclose(fp);
+
+ kill(getpid(), SIGILL);
+}
+
+#endif /* BMTRACE */
+
+void
+BufferRefCountReset(int *refcountsave)
+{
+ int i;
+ for (i=0; i
+ refcountsave[i] = PrivateRefCount[i];
+ LastRefCount[i] += PrivateRefCount[i];
+ PrivateRefCount[i] = 0;
+ }
+}
+
+void
+BufferRefCountRestore(int *refcountsave)
+{
+ int i;
+ for (i=0; i
+ PrivateRefCount[i] = refcountsave[i];
+ LastRefCount[i] -= refcountsave[i];
+ refcountsave[i] = 0;
+ }
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * freelist.c--
+ * routines for manipulating the buffer pool's replacement strategy
+ * freelist.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/freelist.c,v 1.1.1.1 1996/07/09 06:21:54 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ * OLD COMMENTS
+ *
+ * Data Structures:
+ * SharedFreeList is a circular queue. Notice that this
+ * is a shared memory queue so the next/prev "ptrs" are
+ * buffer ids, not addresses.
+ *
+ * Sync: all routines in this file assume that the buffer
+ * semaphore has been acquired by the caller.
+ */
+#include
+#include "storage/bufmgr.h"
+#include "storage/buf_internals.h" /* where declarations go */
+#include "storage/spin.h"
+#include "utils/elog.h"
+
+
+static BufferDesc *SharedFreeList;
+
+/* only actually used in debugging. The lock
+ * should be acquired before calling the freelist manager.
+ */
+extern SPINLOCK BufMgrLock;
+
+#define IsInQueue(bf) \
+ Assert((bf->freeNext != INVALID_DESCRIPTOR));\
+ Assert((bf->freePrev != INVALID_DESCRIPTOR));\
+ Assert((bf->flags & BM_FREE))
+
+#define NotInQueue(bf) \
+ Assert((bf->freeNext == INVALID_DESCRIPTOR));\
+ Assert((bf->freePrev == INVALID_DESCRIPTOR));\
+ Assert(! (bf->flags & BM_FREE))
+
+
+/*
+ * AddBufferToFreelist --
+ *
+ * In theory, this is the only routine that needs to be changed
+ * if the buffer replacement strategy changes. Just change
+ * the manner in which buffers are added to the freelist queue.
+ * Currently, they are added on an LRU basis.
+ */
+void
+AddBufferToFreelist(BufferDesc *bf)
+{
+#ifdef BMTRACE
+ _bm_trace(bf->tag.relId.dbId, bf->tag.relId.relId, bf->tag.blockNum,
+ BufferDescriptorGetBuffer(bf), BMT_DEALLOC);
+#endif /* BMTRACE */
+ NotInQueue(bf);
+
+ /* change bf so it points to inFrontOfNew and its successor */
+ bf->freePrev = SharedFreeList->freePrev;
+ bf->freeNext = Free_List_Descriptor;
+
+ /* insert new into chain */
+ BufferDescriptors[bf->freeNext].freePrev = bf->buf_id;
+ BufferDescriptors[bf->freePrev].freeNext = bf->buf_id;
+}
+
+#undef PinBuffer
+
+/*
+ * PinBuffer -- make buffer unavailable for replacement.
+ */
+void
+PinBuffer(BufferDesc *buf)
+{
+ long b;
+
+ /* Assert (buf->refcount < 25); */
+
+ if (buf->refcount == 0) {
+ IsInQueue(buf);
+
+ /* remove from freelist queue */
+ BufferDescriptors[buf->freeNext].freePrev = buf->freePrev;
+ BufferDescriptors[buf->freePrev].freeNext = buf->freeNext;
+ buf->freeNext = buf->freePrev = INVALID_DESCRIPTOR;
+
+ /* mark buffer as no longer free */
+ buf->flags &= ~BM_FREE;
+ } else {
+ NotInQueue(buf);
+ }
+
+ b = BufferDescriptorGetBuffer(buf) - 1;
+ Assert(PrivateRefCount[b] >= 0);
+ if (PrivateRefCount[b] == 0 && LastRefCount[b] == 0)
+ buf->refcount++;
+ PrivateRefCount[b]++;
+}
+
+void
+PinBuffer_Debug(char *file, int line, BufferDesc *buf)
+{
+ PinBuffer(buf);
+ if (ShowPinTrace) {
+ Buffer buffer = BufferDescriptorGetBuffer(buf);
+
+ fprintf(stderr, "PIN(Pin) %ld relname = %s, blockNum = %d, \
+refcount = %ld, file: %s, line: %d\n",
+ buffer, buf->sb_relname, buf->tag.blockNum,
+ PrivateRefCount[buffer - 1], file, line);
+ }
+}
+
+#undef UnpinBuffer
+
+/*
+ * UnpinBuffer -- make buffer available for replacement.
+ */
+void
+UnpinBuffer(BufferDesc *buf)
+{
+ long b = BufferDescriptorGetBuffer(buf) - 1;
+
+ Assert(buf->refcount);
+ Assert(PrivateRefCount[b] > 0);
+ PrivateRefCount[b]--;
+ if (PrivateRefCount[b] == 0 && LastRefCount[b] == 0)
+ buf->refcount--;
+ NotInQueue(buf);
+
+ if (buf->refcount == 0) {
+ AddBufferToFreelist(buf);
+ buf->flags |= BM_FREE;
+ } else {
+ /* do nothing */
+ }
+}
+
+void
+UnpinBuffer_Debug(char *file, int line, BufferDesc *buf)
+{
+ UnpinBuffer(buf);
+ if (ShowPinTrace) {
+ Buffer buffer = BufferDescriptorGetBuffer(buf);
+
+ fprintf(stderr, "UNPIN(Unpin) %ld relname = %s, blockNum = %d, \
+refcount = %ld, file: %s, line: %d\n",
+ buffer, buf->sb_relname, buf->tag.blockNum,
+ PrivateRefCount[buffer - 1], file, line);
+ }
+}
+
+/*
+ * GetFreeBuffer() -- get the 'next' buffer from the freelist.
+ *
+ */
+BufferDesc *
+GetFreeBuffer()
+{
+ BufferDesc *buf;
+
+ if (Free_List_Descriptor == SharedFreeList->freeNext) {
+
+ /* queue is empty. All buffers in the buffer pool are pinned. */
+ elog(WARN,"out of free buffers: time to abort !\n");
+ return(NULL);
+ }
+ buf = &(BufferDescriptors[SharedFreeList->freeNext]);
+
+ /* remove from freelist queue */
+ BufferDescriptors[buf->freeNext].freePrev = buf->freePrev;
+ BufferDescriptors[buf->freePrev].freeNext = buf->freeNext;
+ buf->freeNext = buf->freePrev = INVALID_DESCRIPTOR;
+
+ buf->flags &= ~(BM_FREE);
+
+ return(buf);
+}
+
+/*
+ * InitFreeList -- initialize the dummy buffer descriptor used
+ * as a freelist head.
+ *
+ * Assume: All of the buffers are already linked in a circular
+ * queue. Only called by postmaster and only during
+ * initialization.
+ */
+void
+InitFreeList(bool init)
+{
+ SharedFreeList = &(BufferDescriptors[Free_List_Descriptor]);
+
+ if (init) {
+ /* we only do this once, normally the postmaster */
+ SharedFreeList->data = INVALID_OFFSET;
+ SharedFreeList->flags = 0;
+ SharedFreeList->flags &= ~(BM_VALID | BM_DELETED | BM_FREE);
+ SharedFreeList->buf_id = Free_List_Descriptor;
+
+ /* insert it into a random spot in the circular queue */
+ SharedFreeList->freeNext = BufferDescriptors[0].freeNext;
+ SharedFreeList->freePrev = 0;
+ BufferDescriptors[SharedFreeList->freeNext].freePrev =
+ BufferDescriptors[SharedFreeList->freePrev].freeNext =
+ Free_List_Descriptor;
+ }
+}
+
+
+/*
+ * print out the free list and check for breaks.
+ */
+void
+DBG_FreeListCheck(int nfree)
+{
+ int i;
+ BufferDesc *buf;
+
+ buf = &(BufferDescriptors[SharedFreeList->freeNext]);
+ for (i=0;ifreeNext])) {
+
+ if (! (buf->flags & (BM_FREE))){
+ if (buf != SharedFreeList) {
+ printf("\tfree list corrupted: %d flags %x\n",
+ buf->buf_id,buf->flags);
+ } else {
+ printf("\tfree list corrupted: too short -- %d not %d\n",
+ i,nfree);
+
+ }
+
+
+ }
+ if ((BufferDescriptors[buf->freeNext].freePrev != buf->buf_id) ||
+ (BufferDescriptors[buf->freePrev].freeNext != buf->buf_id)) {
+ printf("\tfree list links corrupted: %d %ld %ld\n",
+ buf->buf_id,buf->freePrev,buf->freeNext);
+ }
+
+ }
+ if (buf != SharedFreeList) {
+ printf("\tfree list corrupted: %d-th buffer is %d\n",
+ nfree,buf->buf_id);
+
+ }
+}
+
+/*
+ * PrintBufferFreeList -
+ * prints the buffer free list, for debugging
+ */
+void
+PrintBufferFreeList()
+{
+ BufferDesc *buf;
+
+ if (SharedFreeList->freeNext == Free_List_Descriptor) {
+ printf("free list is empty.\n");
+ return;
+ }
+
+ buf = &(BufferDescriptors[SharedFreeList->freeNext]);
+ for (;;) {
+ int i = (buf - BufferDescriptors);
+ printf("[%-2d] (%s, %d) flags=0x%x, refcnt=%d %ld, nxt=%ld prv=%ld)\n",
+ i, buf->sb_relname, buf->tag.blockNum,
+ buf->flags, buf->refcount, PrivateRefCount[i],
+ buf->freeNext, buf->freePrev);
+
+ if (buf->freeNext == Free_List_Descriptor)
+ break;
+
+ buf = &(BufferDescriptors[buf->freeNext]);
+ }
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * localbuf.c--
+ * local buffer manager. Fast buffer manager for temporary tables
+ * or special cases when the operation is not visible to other backends.
+ *
+ * When a relation is being created, the descriptor will have rd_islocal
+ * set to indicate that the local buffer manager should be used. During
+ * the same transaction the relation is being created, any inserts or
+ * selects from the newly created relation will use the local buffer
+ * pool. rd_islocal is reset at the end of a transaction (commit/abort).
+ * This is useful for queries like SELECT INTO TABLE and create index.
+ *
+ * Copyright (c) 1994-5, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/localbuf.c,v 1.1.1.1 1996/07/09 06:21:54 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include
+#include
+
+/* declarations split between these three files */
+#include "storage/buf.h"
+#include "storage/buf_internals.h"
+#include "storage/bufmgr.h"
+
+#include "storage/fd.h"
+#include "storage/ipc.h"
+#include "storage/shmem.h"
+#include "storage/spin.h"
+#include "storage/smgr.h"
+#include "storage/lmgr.h"
+#include "miscadmin.h"
+#include "utils/builtins.h"
+#include "utils/hsearch.h"
+#include "utils/elog.h"
+#include "utils/memutils.h"
+#include "executor/execdebug.h" /* for NDirectFileRead */
+#include "catalog/catalog.h"
+
+int NLocBuffer = 64;
+BufferDesc *LocalBufferDescriptors = NULL;
+long *LocalRefCount = NULL;
+
+static int nextFreeLocalBuf = 0;
+
+/*#define LBDEBUG*/
+
+/*
+ * LocalBufferAlloc -
+ * allocate a local buffer. We do round robin allocation for now.
+ */
+BufferDesc *
+LocalBufferAlloc(Relation reln, BlockNumber blockNum, bool *foundPtr)
+{
+ int i;
+ BufferDesc *bufHdr = (BufferDesc *) NULL;
+
+ if (blockNum == P_NEW) {
+ blockNum = reln->rd_nblocks;
+ reln->rd_nblocks++;
+ }
+
+ /* a low tech search for now -- not optimized for scans */
+ for (i=0; i < NLocBuffer; i++) {
+ if (LocalBufferDescriptors[i].tag.relId.relId == reln->rd_id &&
+ LocalBufferDescriptors[i].tag.blockNum == blockNum) {
+
+#ifdef LBDEBUG
+ fprintf(stderr, "LB ALLOC (%d,%d) %d\n",
+ reln->rd_id, blockNum, -i-1);
+#endif
+ LocalRefCount[i]++;
+ *foundPtr = TRUE;
+ return &LocalBufferDescriptors[i];
+ }
+ }
+
+#ifdef LBDEBUG
+ fprintf(stderr, "LB ALLOC (%d,%d) %d\n",
+ reln->rd_id, blockNum, -nextFreeLocalBuf-1);
+#endif
+
+ /* need to get a new buffer (round robin for now) */
+ for(i=0; i < NLocBuffer; i++) {
+ int b = (nextFreeLocalBuf + i) % NLocBuffer;
+
+ if (LocalRefCount[b]==0) {
+ bufHdr = &LocalBufferDescriptors[b];
+ LocalRefCount[b]++;
+ nextFreeLocalBuf = (b + 1) % NLocBuffer;
+ break;
+ }
+ }
+ if (bufHdr==NULL)
+ elog(WARN, "no empty local buffer.");
+
+ /*
+ * this buffer is not referenced but it might still be dirty (the
+ * last transaction to touch it doesn't need its contents but has
+ * not flushed it). if that's the case, write it out before
+ * reusing it!
+ */
+ if (bufHdr->flags & BM_DIRTY) {
+ Relation bufrel = RelationIdCacheGetRelation(bufHdr->tag.relId.relId);
+
+ Assert(bufrel != NULL);
+
+ /* flush this page */
+ smgrwrite(bufrel->rd_rel->relsmgr, bufrel, bufHdr->tag.blockNum,
+ (char *) MAKE_PTR(bufHdr->data));
+ }
+
+ /*
+ * it's all ours now.
+ */
+ bufHdr->tag.relId.relId = reln->rd_id;
+ bufHdr->tag.blockNum = blockNum;
+ bufHdr->flags &= ~BM_DIRTY;
+
+ /*
+ * lazy memory allocation. (see MAKE_PTR for why we need to do
+ * MAKE_OFFSET.)
+ */
+ if (bufHdr->data == (SHMEM_OFFSET)0) {
+ char *data = (char *)malloc(BLCKSZ);
+
+ bufHdr->data = MAKE_OFFSET(data);
+ }
+
+ *foundPtr = FALSE;
+ return bufHdr;
+}
+
+/*
+ * WriteLocalBuffer -
+ * writes out a local buffer
+ */
+int
+WriteLocalBuffer(Buffer buffer, bool release)
+{
+ int bufid;
+
+ Assert(BufferIsLocal(buffer));
+
+#ifdef LBDEBUG
+ fprintf(stderr, "LB WRITE %d\n", buffer);
+#endif
+
+ bufid = - (buffer + 1);
+ LocalBufferDescriptors[bufid].flags |= BM_DIRTY;
+
+ if (release) {
+ Assert(LocalRefCount[bufid] > 0);
+ LocalRefCount[bufid]--;
+ }
+
+ return true;
+}
+
+/*
+ * FlushLocalBuffer -
+ * flushes a local buffer
+ */
+int
+FlushLocalBuffer(Buffer buffer)
+{
+ int bufid;
+ Relation bufrel;
+ BufferDesc *bufHdr;
+
+ Assert(BufferIsLocal(buffer));
+
+#ifdef LBDEBUG
+ fprintf(stderr, "LB FLUSH %d\n", buffer);
+#endif
+
+ bufid = - (buffer + 1);
+ bufHdr = &LocalBufferDescriptors[bufid];
+ bufHdr->flags &= ~BM_DIRTY;
+ bufrel = RelationIdCacheGetRelation(bufHdr->tag.relId.relId);
+
+ Assert(bufrel != NULL);
+ smgrflush(bufrel->rd_rel->relsmgr, bufrel, bufHdr->tag.blockNum,
+ (char *) MAKE_PTR(bufHdr->data));
+
+ Assert(LocalRefCount[bufid] > 0);
+ LocalRefCount[bufid]--;
+
+ return true;
+}
+
+/*
+ * InitLocalBuffer -
+ * init the local buffer cache. Since most queries (esp. multi-user ones)
+ * don't involve local buffers, we delay allocating memory for actual the
+ * buffer until we need it.
+ */
+void
+InitLocalBuffer()
+{
+ int i;
+
+ /*
+ * these aren't going away. I'm not gonna use palloc.
+ */
+ LocalBufferDescriptors =
+ (BufferDesc *)malloc(sizeof(BufferDesc) * NLocBuffer);
+ memset(LocalBufferDescriptors, 0, sizeof(BufferDesc) * NLocBuffer);
+ nextFreeLocalBuf = 0;
+
+ for (i = 0; i < NLocBuffer; i++) {
+ BufferDesc *buf = &LocalBufferDescriptors[i];
+
+ /*
+ * negative to indicate local buffer. This is tricky: shared buffers
+ * start with 0. We have to start with -2. (Note that the routine
+ * BufferDescriptorGetBuffer adds 1 to buf_id so our first buffer id
+ * is -1.)
+ */
+ buf->buf_id = - i - 2;
+ }
+
+ LocalRefCount =
+ (long *)malloc(sizeof(long) * NLocBuffer);
+ memset(LocalRefCount, 0, sizeof(long) * NLocBuffer);
+}
+
+/*
+ * LocalBufferSync -
+ * flush all dirty buffers in the local buffer cache. Since the buffer
+ * cache is only used for keeping relations visible during a transaction,
+ * we will not need these buffers again.
+ */
+void
+LocalBufferSync()
+{
+ int i;
+
+ for (i = 0; i < NLocBuffer; i++) {
+ BufferDesc *buf = &LocalBufferDescriptors[i];
+ Relation bufrel;
+
+ if (buf->flags & BM_DIRTY) {
+#ifdef LBDEBUG
+ fprintf(stderr, "LB SYNC %d\n", -i-1);
+#endif
+ bufrel = RelationIdCacheGetRelation(buf->tag.relId.relId);
+
+ Assert(bufrel != NULL);
+
+ smgrwrite(bufrel->rd_rel->relsmgr, bufrel, buf->tag.blockNum,
+ (char *) MAKE_PTR(buf->data));
+
+ buf->tag.relId.relId = InvalidOid;
+ buf->flags &= ~BM_DIRTY;
+ }
+ }
+
+ memset(LocalRefCount, 0, sizeof(long) * NLocBuffer);
+}
+
+void
+ResetLocalBufferPool()
+{
+ int i;
+
+ memset(LocalBufferDescriptors, 0, sizeof(BufferDesc) * NLocBuffer);
+ nextFreeLocalBuf = 0;
+
+ for (i = 0; i < NLocBuffer; i++) {
+ BufferDesc *buf = &LocalBufferDescriptors[i];
+
+ /* just like InitLocalBuffer() */
+ buf->buf_id = - i - 2;
+ }
+
+ memset(LocalRefCount, 0, sizeof(long) * NLocBuffer);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * bufmgr.h--
+ * POSTGRES buffer manager definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: bufmgr.h,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BUFMGR_H
+#define BUFMGR_H
+
+#include "c.h"
+
+#include "machine.h" /* for BLCKSZ */
+#include "utils/rel.h"
+
+#include "storage/buf_internals.h" /* UGLY! -- ay */
+
+/*
+ * the maximum size of a disk block for any possible installation.
+ *
+ * in theory this could be anything, but in practice this is actually
+ * limited to 2^13 bytes because we have limited ItemIdData.lp_off and
+ * ItemIdData.lp_len to 13 bits (see itemid.h).
+ */
+#define MAXBLCKSZ 8192
+
+typedef void *Block;
+
+
+/* special pageno for bget */
+#define P_NEW InvalidBlockNumber /* grow the file to get a new page */
+
+typedef bits16 BufferLock;
+
+/**********************************************************************
+
+ the rest is function defns in the bufmgr that are externally callable
+
+ **********************************************************************/
+
+/*
+ * These routines are beaten on quite heavily, hence the macroization.
+ * See buf_internals.h for a related comment.
+ */
+#define BufferDescriptorGetBuffer(bdesc) ((bdesc)->buf_id + 1)
+
+/*
+ * BufferIsPinned --
+ * True iff the buffer is pinned (and therefore valid)
+ *
+ * Note:
+ * Smenatics are identical to BufferIsValid
+ * XXX - need to remove either one eventually.
+ */
+#define BufferIsPinned BufferIsValid
+
+
+extern int ShowPinTrace;
+
+/*
+ * prototypes for functions in bufmgr.c
+ */
+extern Buffer RelationGetBufferWithBuffer(Relation relation,
+ BlockNumber blockNumber, Buffer buffer);
+extern Buffer ReadBuffer(Relation reln, BlockNumber blockNum);
+extern Buffer ReadBuffer_Debug(char *file, int line, Relation reln,
+ BlockNumber blockNum);
+extern int WriteBuffer(Buffer buffer);
+extern void WriteBuffer_Debug(char *file, int line, Buffer buffer);
+extern void DirtyBufferCopy(Oid dbid, Oid relid, BlockNumber blkno,
+ char *dest);
+extern int WriteNoReleaseBuffer(Buffer buffer);
+extern Buffer ReleaseAndReadBuffer(Buffer buffer, Relation relation,
+ BlockNumber blockNum);
+
+extern void InitBufferPool(IPCKey key);
+extern void PrintBufferUsage(FILE *statfp);
+extern void ResetBufferUsage(void);
+extern void ResetBufferPool(void);
+extern int BufferPoolCheckLeak(void);
+extern void FlushBufferPool(int StableMainMemoryFlag);
+extern bool BufferIsValid(Buffer bufnum);
+extern BlockNumber BufferGetBlockNumber(Buffer buffer);
+extern Relation BufferGetRelation(Buffer buffer);
+extern BlockNumber RelationGetNumberOfBlocks(Relation relation);
+extern Block BufferGetBlock(Buffer buffer);
+extern void ReleaseTmpRelBuffers(Relation tempreldesc);
+extern void DropBuffers(Oid dbid);
+extern void PrintBufferDescs(void);
+extern void PrintPinnedBufs(void);
+extern int BufferShmemSize(void);
+extern void BufferPoolBlowaway(void);
+extern void IncrBufferRefCount(Buffer buffer);
+extern int ReleaseBuffer(Buffer buffer);
+
+extern void IncrBufferRefCount_Debug(char *file, int line, Buffer buffer);
+extern void ReleaseBuffer_Debug(char *file, int line, Buffer buffer);
+extern int ReleaseAndReadBuffer_Debug(char *file,
+ int line,
+ Buffer buffer,
+ Relation relation,
+ BlockNumber blockNum);
+extern void BufferRefCountReset(int *refcountsave);
+extern void BufferRefCountRestore(int *refcountsave);
+
+#endif /* !defined(BufMgrIncluded) */
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * bufpage.h--
+ * Standard POSTGRES buffer page definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: bufpage.h,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BUFPAGE_H
+#define BUFPAGE_H
+
+#include "c.h"
+#include "machine.h" /* for BLCKSZ */
+
+#include "storage/buf.h"
+#include "storage/item.h"
+#include "storage/itemid.h"
+#include "storage/itemptr.h"
+
+/*
+ * a postgres disk page is an abstraction layered on top of a postgres
+ * disk block (which is simply a unit of i/o, see block.h).
+ *
+ * specifically, while a disk block can be unformatted, a postgres
+ * disk page is always a slotted page of the form:
+ *
+ * +----------------+---------------------------------+
+ * | PageHeaderData | linp0 linp1 linp2 ... |
+ * +-----------+----+---------------------------------+
+ * | ... linpN | |
+ * +-----------+--------------------------------------+
+ * | ^ pd_lower |
+ * | |
+ * | v pd_upper |
+ * +-------------+------------------------------------+
+ * | | tupleN ... |
+ * +-------------+------------------+-----------------+
+ * | ... tuple2 tuple1 tuple0 | "special space" |
+ * +--------------------------------+-----------------+
+ * ^ pd_special
+ *
+ * a page is full when nothing can be added between pd_lower and
+ * pd_upper.
+ *
+ * all blocks written out by an access method must be disk pages.
+ *
+ * EXCEPTIONS:
+ *
+ * obviously, a page is not formatted before it is initialized with by
+ * a call to PageInit.
+ *
+ * the contents of the special pg_variable/pg_time/pg_log tables are
+ * raw disk blocks with special formats. these are the only "access
+ * methods" that need not write disk pages.
+ *
+ * NOTES:
+ *
+ * linp0..N form an ItemId array. ItemPointers point into this array
+ * rather than pointing directly to a tuple.
+ *
+ * tuple0..N are added "backwards" on the page. because a tuple's
+ * ItemPointer points to its ItemId entry rather than its actual
+ * byte-offset position, tuples can be physically shuffled on a page
+ * whenever the need arises.
+ *
+ * AM-generic per-page information is kept in the pd_opaque field of
+ * the PageHeaderData. (this is currently only the page size.)
+ * AM-specific per-page data is kept in the area marked "special
+ * space"; each AM has an "opaque" structure defined somewhere that is
+ * stored as the page trailer. an access method should always
+ * initialize its pages with PageInit and then set its own opaque
+ * fields.
+ */
+typedef Pointer Page;
+
+/*
+ * PageIsValid --
+ * True iff page is valid.
+ */
+#define PageIsValid(page) PointerIsValid(page)
+
+
+/*
+ * location (byte offset) within a page.
+ *
+ * note that this is actually limited to 2^13 because we have limited
+ * ItemIdData.lp_off and ItemIdData.lp_len to 13 bits (see itemid.h).
+ */
+typedef uint16 LocationIndex;
+
+
+/*
+ * space management information generic to any page
+ *
+ * od_pagesize - size in bytes.
+ * in reality, we need at least 64B to fit the
+ * page header, opaque space and a minimal tuple;
+ * on the high end, we can only support pages up
+ * to 8KB because lp_off/lp_len are 13 bits.
+ */
+typedef struct OpaqueData {
+ uint16 od_pagesize;
+} OpaqueData;
+
+typedef OpaqueData *Opaque;
+
+
+/*
+ * disk page organization
+ */
+typedef struct PageHeaderData {
+ LocationIndex pd_lower; /* offset to start of free space */
+ LocationIndex pd_upper; /* offset to end of free space */
+ LocationIndex pd_special; /* offset to start of special space */
+ OpaqueData pd_opaque; /* AM-generic information */
+ ItemIdData pd_linp[1]; /* line pointers */
+} PageHeaderData;
+
+typedef PageHeaderData *PageHeader;
+
+typedef enum {
+ ShufflePageManagerMode,
+ OverwritePageManagerMode
+} PageManagerMode;
+
+/* ----------------
+ * misc support macros
+ * ----------------
+ */
+
+/*
+ * XXX this is wrong -- ignores padding/alignment, variable page size,
+ * AM-specific opaque space at the end of the page (as in btrees), ...
+ * however, it at least serves as an upper bound for heap pages.
+ */
+#define MAXTUPLEN (BLCKSZ - sizeof (PageHeaderData))
+
+/* ----------------------------------------------------------------
+ * page support macros
+ * ----------------------------------------------------------------
+ */
+/*
+ * PageIsValid -- This is defined in page.h.
+ */
+
+/*
+ * PageIsUsed --
+ * True iff the page size is used.
+ *
+ * Note:
+ * Assumes page is valid.
+ */
+#define PageIsUsed(page) \
+ (AssertMacro(PageIsValid(page)) ? \
+ ((bool) (((PageHeader) (page))->pd_lower != 0)) : false)
+
+/*
+ * PageIsEmpty --
+ * returns true iff no itemid has been allocated on the page
+ */
+#define PageIsEmpty(page) \
+ (((PageHeader) (page))->pd_lower == \
+ (sizeof(PageHeaderData) - sizeof(ItemIdData)) ? true : false)
+
+/*
+ * PageGetItemId --
+ * Returns an item identifier of a page.
+ */
+#define PageGetItemId(page, offsetNumber) \
+ ((ItemId) (&((PageHeader) (page))->pd_linp[(-1) + (offsetNumber)]))
+
+/* ----------------
+ * macros to access opaque space
+ * ----------------
+ */
+
+/*
+ * PageSizeIsValid --
+ * True iff the page size is valid.
+ *
+ * XXX currently all page sizes are "valid" but we only actually
+ * use BLCKSZ.
+ */
+#define PageSizeIsValid(pageSize) 1
+
+/*
+ * PageGetPageSize --
+ * Returns the page size of a page.
+ *
+ * this can only be called on a formatted page (unlike
+ * BufferGetPageSize, which can be called on an unformatted page).
+ * however, it can be called on a page for which there is no buffer.
+ */
+#define PageGetPageSize(page) \
+ ((Size) ((PageHeader) (page))->pd_opaque.od_pagesize)
+
+/*
+ * PageSetPageSize --
+ * Sets the page size of a page.
+ */
+#define PageSetPageSize(page, size) \
+ ((PageHeader) (page))->pd_opaque.od_pagesize = (size)
+
+/* ----------------
+ * page special data macros
+ * ----------------
+ */
+/*
+ * PageGetSpecialSize --
+ * Returns size of special space on a page.
+ *
+ * Note:
+ * Assumes page is locked.
+ */
+#define PageGetSpecialSize(page) \
+ ((uint16) (PageGetPageSize(page) - ((PageHeader)page)->pd_special))
+
+/*
+ * PageGetSpecialPointer --
+ * Returns pointer to special space on a page.
+ *
+ * Note:
+ * Assumes page is locked.
+ */
+#define PageGetSpecialPointer(page) \
+ (AssertMacro(PageIsValid(page)) ? \
+ (char *) ((char *) (page) + ((PageHeader) (page))->pd_special) \
+ : (char *) 0)
+
+/* ----------------------------------------------------------------
+ * extern declarations
+ * ----------------------------------------------------------------
+ */
+
+extern Size BufferGetPageSize(Buffer buffer);
+extern Page BufferGetPage(Buffer buffer);
+extern void PageInit(Page page, Size pageSize, Size specialSize);
+extern Item PageGetItem(Page page, ItemId itemId);
+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);
+extern OffsetNumber PageGetMaxOffsetNumber(Page page);
+extern void PageRepairFragmentation(Page page);
+extern Size PageGetFreeSpace(Page page);
+extern void PageManagerModeSet(PageManagerMode mode);
+extern void PageIndexTupleDelete(Page page, OffsetNumber offset);
+extern void PageIndexTupleDeleteAdjustLinePointers(PageHeader phdr,
+ char *location, Size size);
+
+
+#endif /* BUFPAGE_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * fd.h--
+ * Virtual file descriptor definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: fd.h,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ * calls:
+ *
+ * File {Close, Read, Write, Seek, Tell, Sync}
+ * {File Name Open, Allocate, Free} File
+ *
+ * These are NOT JUST RENAMINGS OF THE UNIX ROUTINES.
+ * use them for all file activity...
+ *
+ * fd = FilePathOpenFile("foo", O_RDONLY);
+ * File fd;
+ *
+ * use AllocateFile if you need a file descriptor in some other context.
+ * it will make sure that there is a file descriptor free
+ *
+ * use FreeFile to let the virtual file descriptor package know that
+ * there is now a free fd (when you are done with it)
+ *
+ * AllocateFile();
+ * FreeFile();
+ */
+#ifndef FD_H
+#define FD_H
+
+/*
+ * FileOpen uses the standard UNIX open(2) flags.
+ */
+#include /* for O_ on most */
+#ifndef O_RDONLY
+#include /* for O_ on the rest */
+#endif /* O_RDONLY */
+
+/*
+ * FileSeek uses the standard UNIX lseek(2) flags.
+ */
+#ifndef WIN32
+#include /* for SEEK_ on most */
+#else
+#ifndef SEEK_SET
+#include /* for SEEK_ on the rest */
+#endif /* SEEK_SET */
+#endif /* WIN32 */
+
+#include "c.h"
+#include "storage/block.h"
+
+typedef char *FileName;
+
+typedef int File;
+
+/* originally in libpq-fs.h */
+struct pgstat { /* just the fields we need from stat structure */
+ int st_ino;
+ int st_mode;
+ unsigned int st_size;
+ unsigned int st_sizehigh; /* high order bits */
+/* 2^64 == 1.8 x 10^20 bytes */
+ int st_uid;
+ int st_atime_s; /* just the seconds */
+ int st_mtime_s; /* since SysV and the new BSD both have */
+ int st_ctime_s; /* usec fields.. */
+};
+
+/*
+ * prototypes for functions in fd.c
+ */
+extern void FileInvalidate(File file);
+extern File FileNameOpenFile(FileName fileName, int fileFlags, int fileMode);
+extern File PathNameOpenFile(FileName fileName, int fileFlags, int fileMode);
+extern void FileClose(File file);
+extern void FileUnlink(File file);
+extern int FileRead(File file, char *buffer, int amount);
+extern int FileWrite(File file, char *buffer, int amount);
+extern long FileSeek(File file, long offset, int whence);
+extern long FileTell(File file);
+extern int FileTruncate(File file, int offset);
+extern int FileSync(File file);
+extern int FileNameUnlink(char *filename);
+extern void AllocateFile(void);
+extern void FreeFile(void);
+extern void closeAllVfds(void);
+extern void closeOneVfd(void);
+
+#endif /* FD_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for storage/file
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/storage/file/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:55 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= fd.c
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * fd.c--
+ * Virtual file descriptor code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ * $Id: fd.c,v 1.1.1.1 1996/07/09 06:21:55 scrappy Exp $
+ *
+ * NOTES:
+ *
+ * This code manages a cache of 'virtual' file descriptors (VFDs).
+ * The server opens many file descriptors for a variety of reasons,
+ * including base tables, scratch files (e.g., sort and hash spool
+ * files), and random calls to C library routines like system(3); it
+ * is quite easy to exceed system limits on the number of open files a
+ * single process can have. (This is around 256 on many modern
+ * operating systems, but can be as low as 32 on others.)
+ *
+ * VFDs are managed as an LRU pool, with actual OS file descriptors
+ * being opened and closed as needed. Obviously, if a routine is
+ * opened using these interfaces, all subsequent operations must also
+ * be through these interfaces (the File type is not a real file
+ * descriptor).
+ *
+ * For this scheme to work, most (if not all) routines throughout the
+ * server should use these interfaces instead of calling the C library
+ * routines (e.g., open(2) and fopen(3)) themselves. Otherwise, we
+ * may find ourselves short of real file descriptors anyway.
+ *
+ * This file used to contain a bunch of stuff to support RAID levels 0
+ * (jbod), 1 (duplex) and 5 (xor parity). That stuff is all gone
+ * because the parallel query processing code that called it is all
+ * gone. If you really need it you could get it from the original
+ * POSTGRES source.
+ *-------------------------------------------------------------------------
+ */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "c.h"
+#include "miscadmin.h" /* for DataDir */
+#include "utils/palloc.h"
+
+#ifdef PORTNAME_sparc
+/*
+ * the SunOS 4 NOFILE is a lie, because the default limit is *not* the
+ * maximum number of file descriptors you can have open.
+ *
+ * we have to either use this number (the default dtablesize) or
+ * explicitly call setrlimit(RLIMIT_NOFILE, NOFILE).
+ */
+#include
+#undef NOFILE
+#define NOFILE NOFILE_IN_U
+#endif /* PORTNAME_sparc */
+
+/*
+ * Problem: Postgres does a system(ld...) to do dynamic loading. This
+ * will open several extra files in addition to those used by
+ * Postgres. We need to do this hack to guarentee that there are file
+ * descriptors free for ld to use.
+ *
+ * The current solution is to limit the number of files descriptors
+ * that this code will allocated at one time. (it leaves
+ * RESERVE_FOR_LD free).
+ *
+ * (Even though most dynamic loaders now use dlopen(3) or the
+ * equivalent, the OS must still open several files to perform the
+ * dynamic loading. Keep this here.)
+ */
+#define RESERVE_FOR_LD 10
+
+/*
+ * If we are using weird storage managers, we may need to keep real
+ * file descriptors open so that the jukebox server doesn't think we
+ * have gone away (and no longer care about a platter or file that
+ * we've been using). This might be an actual file descriptor for a
+ * local jukebox interface that uses paths, or a socket connection for
+ * a network jukebox server. Since we can't be opening and closing
+ * these descriptors at whim, we must make allowances for them.
+ */
+#ifdef HP_JUKEBOX
+#define RESERVE_FOR_JB 25
+#define MAXFILES ((NOFILE - RESERVE_FOR_LD) - RESERVE_FOR_JB)
+#else /* HP_JUKEBOX */
+#define MAXFILES (NOFILE - RESERVE_FOR_LD)
+#endif /* HP_JUKEBOX */
+
+/* Debugging.... */
+
+#ifdef FDDEBUG
+# define DO_DB(A) A
+#else
+# define DO_DB(A) /* A */
+#endif
+
+#define VFD_CLOSED -1
+
+#include "storage/fd.h"
+#include "utils/elog.h"
+
+#define FileIsNotOpen(file) (VfdCache[file].fd == VFD_CLOSED)
+
+typedef struct vfd {
+ signed short fd;
+ unsigned short fdstate;
+
+#define FD_DIRTY (1 << 0)
+
+ File nextFree;
+ File lruMoreRecently;
+ File lruLessRecently;
+ long seekPos;
+ char *fileName;
+ int fileFlags;
+ int fileMode;
+} Vfd;
+
+/*
+ * Virtual File Descriptor array pointer and size. This grows as
+ * needed.
+ */
+static Vfd *VfdCache;
+static Size SizeVfdCache = 0;
+
+/*
+ * Minimum number of file descriptors known to be free.
+ */
+static int FreeFd = 0;
+
+/*
+ * Number of file descriptors known to be open.
+ */
+static int nfile = 0;
+
+/*
+ * we use the name of the null device in various places, mostly so
+ * that we can open it and find out if we really have any descriptors
+ * available or not.
+ */
+#ifndef WIN32
+static char *Nulldev = "/dev/null";
+static char Sep_char = '/';
+#else
+static char *Nulldev = "NUL";
+static char Sep_char = '\\';
+#endif /* WIN32 */
+
+/*
+ * Private Routines
+ *
+ * Delete - delete a file from the Lru ring
+ * LruDelete - remove a file from the Lru ring and close
+ * Insert - put a file at the front of the Lru ring
+ * LruInsert - put a file at the front of the Lru ring and open
+ * AssertLruRoom - make sure that there is a free fd.
+ *
+ * the Last Recently Used ring is a doubly linked list that begins and
+ * ends on element zero.
+ *
+ * example:
+ *
+ * /--less----\ /---------\
+ * v \ v \
+ * #0 --more---> LeastRecentlyUsed --more-\ \
+ * ^\ | |
+ * \\less--> MostRecentlyUsedFile <---/ |
+ * \more---/ \--less--/
+ *
+ * AllocateVfd - grab a free (or new) file record (from VfdArray)
+ * FreeVfd - free a file record
+ *
+ */
+static void Delete(File file);
+static void LruDelete(File file);
+static void Insert(File file);
+static int LruInsert (File file);
+static void AssertLruRoom(void);
+static File AllocateVfd(void);
+static void FreeVfd(File file);
+
+static int FileAccess(File file);
+static File fileNameOpenFile(FileName fileName, int fileFlags, int fileMode);
+static char *filepath(char *filename);
+
+#if defined(FDDEBUG)
+static void
+_dump_lru()
+{
+ int mru = VfdCache[0].lruLessRecently;
+ Vfd *vfdP = &VfdCache[mru];
+
+ printf("MOST %d ", mru);
+ while (mru != 0)
+ {
+ mru = vfdP->lruLessRecently;
+ vfdP = &VfdCache[mru];
+ printf("%d ", mru);
+ }
+ printf("LEAST\n");
+}
+#endif /* FDDEBUG */
+
+static void
+Delete(File file)
+{
+ Vfd *fileP;
+
+ DO_DB(printf("DEBUG: Delete %d (%s)\n",
+ file, VfdCache[file].fileName));
+ DO_DB(_dump_lru());
+
+ Assert(file != 0);
+
+ fileP = &VfdCache[file];
+
+ VfdCache[fileP->lruLessRecently].lruMoreRecently =
+ VfdCache[file].lruMoreRecently;
+ VfdCache[fileP->lruMoreRecently].lruLessRecently =
+ VfdCache[file].lruLessRecently;
+
+ DO_DB(_dump_lru());
+}
+
+static void
+LruDelete(File file)
+{
+ Vfd *fileP;
+ int returnValue;
+
+ DO_DB(printf("DEBUG: LruDelete %d (%s)\n",
+ file, VfdCache[file].fileName));
+
+ Assert(file != 0);
+
+ fileP = &VfdCache[file];
+
+ /* delete the vfd record from the LRU ring */
+ Delete(file);
+
+ /* save the seek position */
+ fileP->seekPos = lseek(fileP->fd, 0L, SEEK_CUR);
+ Assert( fileP->seekPos != -1);
+
+ /* if we have written to the file, sync it */
+ if (fileP->fdstate & FD_DIRTY) {
+ returnValue = fsync(fileP->fd);
+ Assert(returnValue != -1);
+ fileP->fdstate &= ~FD_DIRTY;
+ }
+
+ /* close the file */
+ returnValue = close(fileP->fd);
+ Assert(returnValue != -1);
+
+ --nfile;
+ fileP->fd = VFD_CLOSED;
+
+ /* note that there is now one more free real file descriptor */
+ FreeFd++;
+}
+
+static void
+Insert(File file)
+{
+ Vfd *vfdP;
+
+ DO_DB(printf("DEBUG: Insert %d (%s)\n",
+ file, VfdCache[file].fileName));
+ DO_DB(_dump_lru());
+
+ vfdP = &VfdCache[file];
+
+ vfdP->lruMoreRecently = 0;
+ vfdP->lruLessRecently = VfdCache[0].lruLessRecently;
+ VfdCache[0].lruLessRecently = file;
+ VfdCache[vfdP->lruLessRecently].lruMoreRecently = file;
+
+ DO_DB(_dump_lru());
+}
+
+static int
+LruInsert (File file)
+{
+ Vfd *vfdP;
+ int returnValue;
+
+ DO_DB(printf("DEBUG: LruInsert %d (%s)\n",
+ file, VfdCache[file].fileName));
+
+ vfdP = &VfdCache[file];
+
+ if (FileIsNotOpen(file)) {
+ int tmpfd;
+
+ /*
+ * Note, we check to see if there's a free file descriptor
+ * before attempting to open a file. One general way to do
+ * this is to try to open the null device which everybody
+ * should be able to open all the time. If this fails, we
+ * assume this is because there's no free file descriptors.
+ */
+ tryAgain:
+ tmpfd = open(Nulldev, O_CREAT|O_RDWR, 0666);
+ if (tmpfd < 0) {
+ FreeFd = 0;
+ errno = 0;
+ AssertLruRoom();
+ goto tryAgain;
+ } else {
+ close(tmpfd);
+ }
+ vfdP->fd = open(vfdP->fileName,vfdP->fileFlags,vfdP->fileMode);
+
+ if (vfdP->fd < 0) {
+ DO_DB(printf("RE_OPEN FAILED: %d\n",
+ errno));
+ return (vfdP->fd);
+ } else {
+ DO_DB(printf("RE_OPEN SUCCESS\n"));
+ ++nfile;
+ }
+
+ /* seek to the right position */
+ if (vfdP->seekPos != 0L) {
+ returnValue =
+ lseek(vfdP->fd, vfdP->seekPos, SEEK_SET);
+ Assert(returnValue != -1);
+ }
+
+ /* init state on open */
+ vfdP->fdstate = 0x0;
+
+ /* note that a file descriptor has been used up */
+ if (FreeFd > 0)
+ FreeFd--;
+ }
+
+ /*
+ * put it at the head of the Lru ring
+ */
+
+ Insert(file);
+
+ return (0);
+}
+
+static void
+AssertLruRoom()
+{
+ DO_DB(printf("DEBUG: AssertLruRoom (FreeFd = %d)\n",
+ FreeFd));
+
+ if (FreeFd <= 0 || nfile >= MAXFILES) {
+ LruDelete(VfdCache[0].lruMoreRecently);
+ }
+}
+
+static File
+AllocateVfd()
+{
+ Index i;
+ File file;
+
+ DO_DB(printf("DEBUG: AllocateVfd\n"));
+
+ if (SizeVfdCache == 0) {
+
+ /* initialize */
+ VfdCache = (Vfd *)malloc(sizeof(Vfd));
+
+ VfdCache->nextFree = 0;
+ VfdCache->lruMoreRecently = 0;
+ VfdCache->lruLessRecently = 0;
+ VfdCache->fd = VFD_CLOSED;
+ VfdCache->fdstate = 0x0;
+
+ SizeVfdCache = 1;
+ }
+
+ if (VfdCache[0].nextFree == 0) {
+
+ /*
+ * The free list is empty so it is time to increase the
+ * size of the array
+ */
+
+ VfdCache =(Vfd *)realloc(VfdCache, sizeof(Vfd)*SizeVfdCache*2);
+ Assert(VfdCache != NULL);
+
+ /*
+ * Set up the free list for the new entries
+ */
+
+ for (i = SizeVfdCache; i < 2*SizeVfdCache; i++) {
+ memset((char *) &(VfdCache[i]), 0, sizeof(VfdCache[0]));
+ VfdCache[i].nextFree = i+1;
+ VfdCache[i].fd = VFD_CLOSED;
+ }
+
+ /*
+ * Element 0 is the first and last element of the free
+ * list
+ */
+
+ VfdCache[0].nextFree = SizeVfdCache;
+ VfdCache[2*SizeVfdCache-1].nextFree = 0;
+
+ /*
+ * Record the new size
+ */
+
+ SizeVfdCache *= 2;
+ }
+ file = VfdCache[0].nextFree;
+
+ VfdCache[0].nextFree = VfdCache[file].nextFree;
+
+ return file;
+}
+
+static void
+FreeVfd(File file)
+{
+ DO_DB(printf("DB: FreeVfd: %d (%s)\n",
+ file, VfdCache[file].fileName));
+
+ VfdCache[file].nextFree = VfdCache[0].nextFree;
+ VfdCache[0].nextFree = file;
+}
+
+static char *
+filepath(char *filename)
+{
+ char *buf;
+ char basename[16];
+ int len;
+
+#ifndef WIN32
+ if (*filename != Sep_char) {
+#else
+ if (!(filename[1] == ':' && filename[2] == Sep_char)) {
+#endif /* WIN32 */
+
+ /* Either /base/ or \base\ */
+ sprintf(basename, "%cbase%c", Sep_char, Sep_char);
+
+ len = strlen(DataDir) + strlen(basename) + strlen(GetDatabaseName())
+ + strlen(filename) + 2;
+ buf = (char*) palloc(len);
+ sprintf(buf, "%s%s%s%c%s",
+ DataDir, basename, GetDatabaseName(), Sep_char, filename);
+ } else {
+ buf = (char *) palloc(strlen(filename) + 1);
+ strcpy(buf, filename);
+ }
+
+ return(buf);
+}
+
+static int
+FileAccess(File file)
+{
+ int returnValue;
+
+ DO_DB(printf("DB: FileAccess %d (%s)\n",
+ file, VfdCache[file].fileName));
+
+ /*
+ * Is the file open? If not, close the least recently used,
+ * then open it and stick it at the head of the used ring
+ */
+
+ if (FileIsNotOpen(file)) {
+
+ AssertLruRoom();
+
+ returnValue = LruInsert(file);
+ if (returnValue != 0)
+ return returnValue;
+
+ } else {
+
+ /*
+ * We now know that the file is open and that it is not the
+ * last one accessed, so we need to more it to the head of
+ * the Lru ring.
+ */
+
+ Delete(file);
+ Insert(file);
+ }
+
+ return (0);
+}
+
+/*
+ * Called when we get a shared invalidation message on some relation.
+ */
+void
+FileInvalidate(File file)
+{
+ if (!FileIsNotOpen(file)) {
+ LruDelete(file);
+ }
+}
+
+/* VARARGS2 */
+static File
+fileNameOpenFile(FileName fileName,
+ int fileFlags,
+ int fileMode)
+{
+ static int osRanOut = 0;
+ File file;
+ Vfd *vfdP;
+ int tmpfd;
+
+ DO_DB(printf("DEBUG: FileNameOpenFile: %s %x %o\n",
+ fileName, fileFlags, fileMode));
+
+ file = AllocateVfd();
+ vfdP = &VfdCache[file];
+
+ if (nfile >= MAXFILES || (FreeFd == 0 && osRanOut)) {
+ AssertLruRoom();
+ }
+
+ tryAgain:
+ tmpfd = open(Nulldev, O_CREAT|O_RDWR, 0666);
+ if (tmpfd < 0) {
+ DO_DB(printf("DB: not enough descs, retry, er= %d\n",
+ errno));
+ errno = 0;
+ FreeFd = 0;
+ osRanOut = 1;
+ AssertLruRoom();
+ goto tryAgain;
+ } else {
+ close(tmpfd);
+ }
+
+#ifdef WIN32
+ fileFlags |= _O_BINARY;
+#endif /* WIN32 */
+ vfdP->fd = open(fileName,fileFlags,fileMode);
+ vfdP->fdstate = 0x0;
+
+ if (vfdP->fd < 0) {
+ FreeVfd(file);
+ return -1;
+ }
+ ++nfile;
+ DO_DB(printf("DB: FNOF success %d\n",
+ vfdP->fd));
+
+ (void)LruInsert(file);
+
+ if (fileName==NULL) {
+ elog(WARN, "fileNameOpenFile: NULL fname");
+ }
+ vfdP->fileName = malloc(strlen(fileName)+1);
+ strcpy(vfdP->fileName,fileName);
+
+ vfdP->fileFlags = fileFlags & ~(O_TRUNC|O_EXCL);
+ vfdP->fileMode = fileMode;
+ vfdP->seekPos = 0;
+
+ return file;
+}
+
+/*
+ * open a file in the database directory ($PGDATA/base/...)
+ */
+File
+FileNameOpenFile(FileName fileName, int fileFlags, int fileMode)
+{
+ File fd;
+ char *fname;
+
+ fname = filepath(fileName);
+ fd = fileNameOpenFile(fname, fileFlags, fileMode);
+ pfree(fname);
+ return(fd);
+}
+
+/*
+ * open a file in an arbitrary directory
+ */
+File
+PathNameOpenFile(FileName fileName, int fileFlags, int fileMode)
+{
+ return(fileNameOpenFile(fileName, fileFlags, fileMode));
+}
+
+void
+FileClose(File file)
+{
+ int returnValue;
+
+ DO_DB(printf("DEBUG: FileClose: %d (%s)\n",
+ file, VfdCache[file].fileName));
+
+ if (!FileIsNotOpen(file)) {
+
+ /* remove the file from the lru ring */
+ Delete(file);
+
+ /* record the new free operating system file descriptor */
+ FreeFd++;
+
+ /* if we did any writes, sync the file before closing */
+ if (VfdCache[file].fdstate & FD_DIRTY) {
+ returnValue = fsync(VfdCache[file].fd);
+ Assert(returnValue != -1);
+ VfdCache[file].fdstate &= ~FD_DIRTY;
+ }
+
+ /* close the file */
+ returnValue = close(VfdCache[file].fd);
+ Assert(returnValue != -1);
+
+ --nfile;
+ VfdCache[file].fd = VFD_CLOSED;
+ }
+ /*
+ * Add the Vfd slot to the free list
+ */
+ FreeVfd(file);
+ /*
+ * Free the filename string
+ */
+ free(VfdCache[file].fileName);
+}
+
+void
+FileUnlink(File file)
+{
+ int returnValue;
+
+ DO_DB(printf("DB: FileClose: %d (%s)\n",
+ file, VfdCache[file].fileName));
+
+ if (!FileIsNotOpen(file)) {
+
+ /* remove the file from the lru ring */
+ Delete(file);
+
+ /* record the new free operating system file descriptor */
+ FreeFd++;
+
+ /* if we did any writes, sync the file before closing */
+ if (VfdCache[file].fdstate & FD_DIRTY) {
+ returnValue = fsync(VfdCache[file].fd);
+ Assert(returnValue != -1);
+ VfdCache[file].fdstate &= ~FD_DIRTY;
+ }
+
+ /* close the file */
+ returnValue = close(VfdCache[file].fd);
+ Assert(returnValue != -1);
+
+ --nfile;
+ VfdCache[file].fd = VFD_CLOSED;
+ }
+ /* add the Vfd slot to the free list */
+ FreeVfd(file);
+
+ /* free the filename string */
+ unlink(VfdCache[file].fileName);
+ free(VfdCache[file].fileName);
+}
+
+int
+FileRead(File file, char *buffer, int amount)
+{
+ int returnCode;
+
+ DO_DB(printf("DEBUG: FileRead: %d (%s) %d 0x%x\n",
+ file, VfdCache[file].fileName, amount, buffer));
+
+ FileAccess(file);
+ returnCode = read(VfdCache[file].fd, buffer, amount);
+ if (returnCode > 0) {
+ VfdCache[file].seekPos += returnCode;
+ }
+
+ return returnCode;
+}
+
+int
+FileWrite(File file, char *buffer, int amount)
+{
+ int returnCode;
+
+ DO_DB(printf("DB: FileWrite: %d (%s) %d 0x%lx\n",
+ file, VfdCache[file].fileName, amount, buffer));
+
+ FileAccess(file);
+ returnCode = write(VfdCache[file].fd, buffer, amount);
+ if (returnCode > 0) { /* changed by Boris with Mao's advice */
+ VfdCache[file].seekPos += returnCode;
+ }
+
+ /* record the write */
+ VfdCache[file].fdstate |= FD_DIRTY;
+
+ return returnCode;
+}
+
+long
+FileSeek(File file, long offset, int whence)
+{
+ int returnCode;
+
+ DO_DB(printf("DEBUG: FileSeek: %d (%s) %d %d\n",
+ file, VfdCache[file].fileName, offset, whence));
+
+ if (FileIsNotOpen(file)) {
+ switch(whence) {
+ case SEEK_SET:
+ VfdCache[file].seekPos = offset;
+ return offset;
+ case SEEK_CUR:
+ VfdCache[file].seekPos = VfdCache[file].seekPos +offset;
+ return VfdCache[file].seekPos;
+ case SEEK_END:
+ FileAccess(file);
+ returnCode = VfdCache[file].seekPos =
+ lseek(VfdCache[file].fd, offset, whence);
+ return returnCode;
+ default:
+ elog(WARN, "FileSeek: invalid whence: %d", whence);
+ break;
+ }
+ } else {
+ returnCode = VfdCache[file].seekPos =
+ lseek(VfdCache[file].fd, offset, whence);
+ return returnCode;
+ }
+ /*NOTREACHED*/
+ return(-1L);
+}
+
+/*
+ * XXX not actually used but here for completeness
+ */
+long
+FileTell(File file)
+{
+ DO_DB(printf("DEBUG: FileTell %d (%s)\n",
+ file, VfdCache[file].fileName));
+ return VfdCache[file].seekPos;
+}
+
+int
+FileTruncate(File file, int offset)
+{
+ int returnCode;
+
+ DO_DB(printf("DEBUG: FileTruncate %d (%s)\n",
+ file, VfdCache[file].fileName));
+
+ (void) FileSync(file);
+ (void) FileAccess(file);
+ returnCode = ftruncate(VfdCache[file].fd, offset);
+ return(returnCode);
+}
+
+int
+FileSync(File file)
+{
+ int returnCode;
+
+ /*
+ * If the file isn't open, then we don't need to sync it; we
+ * always sync files when we close them. Also, if we haven't
+ * done any writes that we haven't already synced, we can ignore
+ * the request.
+ */
+
+ if (VfdCache[file].fd < 0 || !(VfdCache[file].fdstate & FD_DIRTY)) {
+ returnCode = 0;
+ } else {
+ returnCode = fsync(VfdCache[file].fd);
+ VfdCache[file].fdstate &= ~FD_DIRTY;
+ }
+
+ return returnCode;
+}
+
+int
+FileNameUnlink(char *filename)
+{
+ int retval;
+ char *fname;
+
+ fname = filepath(filename);
+ retval = unlink(fname);
+ pfree(fname);
+ return(retval);
+}
+
+/*
+ * if we want to be sure that we have a real file descriptor available
+ * (e.g., we want to know this in psort) we call AllocateFile to force
+ * availability. when we are done we call FreeFile to deallocate the
+ * descriptor.
+ *
+ * allocatedFiles keeps track of how many have been allocated so we
+ * can give a warning if there are too few left.
+ */
+static int allocatedFiles = 0;
+
+void
+AllocateFile()
+{
+ int fd;
+ int fdleft;
+
+ while ((fd = open(Nulldev,O_WRONLY,0)) < 0) {
+ if (errno == EMFILE) {
+ errno = 0;
+ FreeFd = 0;
+ AssertLruRoom();
+ } else {
+ elog(WARN,"Open: %s in %s line %d\n", Nulldev,
+ __FILE__, __LINE__);
+ }
+ }
+ close(fd);
+ ++allocatedFiles;
+ fdleft = MAXFILES - allocatedFiles;
+ if (fdleft < 6) {
+ elog(DEBUG,"warning: few usable file descriptors left (%d)", fdleft);
+ }
+
+ DO_DB(printf("DEBUG: AllocatedFile. FreeFd = %d\n",
+ FreeFd));
+}
+
+/*
+ * XXX What happens if FreeFile() is called without a previous
+ * AllocateFile()?
+ */
+void
+FreeFile()
+{
+ DO_DB(printf("DEBUG: FreeFile. FreeFd now %d\n",
+ FreeFd));
+ FreeFd++;
+ nfile++; /* dangerous */
+ Assert(allocatedFiles > 0);
+ --allocatedFiles;
+}
+
+void
+closeAllVfds()
+{
+ int i;
+ for (i=0; i
+ if (!FileIsNotOpen(i))
+ LruDelete(i);
+ }
+}
+
+void
+closeOneVfd()
+{
+ int tmpfd;
+
+ tmpfd = open(Nulldev, O_CREAT | O_RDWR, 0666);
+ if (tmpfd < 0) {
+ FreeFd = 0;
+ AssertLruRoom();
+ FreeFd = 0;
+ }
+ else
+ close(tmpfd);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * ipc.h--
+ * POSTGRES inter-process communication definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: ipc.h,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+ *
+ * NOTES
+ * This file is very architecture-specific. This stuff should actually
+ * be factored into the port/ directories.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef IPC_H
+#define IPC_H
+
+#include
+#ifndef _IPC_
+#define _IPC_
+#include
+#endif
+
+#include "c.h"
+
+/*
+ * Many architectures have support for user-level spinlocks (i.e., an
+ * atomic test-and-set instruction). However, we have only written
+ * spinlock code for the architectures listed.
+ */
+#if defined(PORTNAME_aix) || \
+ defined(PORTNAME_alpha) || \
+ defined(PORTNAME_hpux) || \
+ defined(PORTNAME_irix5) || \
+ defined(PORTNAME_next) || \
+ defined(PORTNAME_sparc) || \
+ defined(PORTNAME_sparc_solaris) || \
+ (defined(__i386__) && defined(__GNUC__))
+#define HAS_TEST_AND_SET
+#endif
+
+#if defined(HAS_TEST_AND_SET)
+
+#if defined(PORTNAME_next)
+/*
+ * Use Mach mutex routines since these are, in effect, test-and-set
+ * spinlocks.
+ */
+#undef NEVER /* definition in cthreads.h conflicts with parse.h */
+#include
+
+typedef struct mutex slock_t;
+#else /* next */
+#if defined(PORTNAME_aix)
+/*
+ * The AIX C library has the cs(3) builtin for compare-and-set that
+ * operates on ints.
+ */
+typedef unsigned int slock_t;
+#else /* aix */
+#if defined(PORTNAME_alpha)
+#include
+typedef msemaphore slock_t;
+#else /* alpha */
+#if defined(PORTNAME_hpux)
+/*
+ * The PA-RISC "semaphore" for the LDWCX instruction is 4 bytes aligned
+ * to a 16-byte boundary.
+ */
+typedef struct { int sem[4]; } slock_t;
+#else /* hpux */
+#if defined(PORTNAME_irix5)
+typedef abilock_t slock_t;
+#else /* irix5 */
+/*
+ * On all other architectures spinlocks are a single byte.
+ */
+typedef unsigned char slock_t;
+#endif /* irix5 */
+#endif /* hpux */
+#endif /* alpha */
+#endif /* aix */
+#endif /* next */
+
+extern void S_LOCK(slock_t *lock);
+extern void S_UNLOCK(slock_t *lock);
+extern void S_INIT_LOCK(slock_t *lock);
+
+#if defined(PORTNAME_hpux) || defined(PORTNAME_alpha) || defined(PORTNAME_irix5) || defined(PORTNAME_next)
+extern int S_LOCK_FREE(slock_t *lock);
+#else /* PORTNAME_hpux */
+#define S_LOCK_FREE(lock) ((*lock) == 0)
+#endif /* PORTNAME_hpux */
+
+#endif /* HAS_TEST_AND_SET */
+
+/*
+ * On architectures for which we have not implemented spinlocks (or
+ * cannot do so), we use System V semaphores. We also use them for
+ * long locks. For some reason union semun is never defined in the
+ * System V header files so we must do it ourselves.
+ */
+#if defined(sequent) || \
+ defined(PORTNAME_aix) || \
+ defined(PORTNAME_alpha) || \
+ defined(PORTNAME_hpux) || \
+ defined(PORTNAME_sparc_solaris) || \
+ defined(WIN32) || \
+ defined(PORTNAME_ultrix4)
+union semun {
+ int val;
+ struct semid_ds *buf;
+ unsigned short *array;
+};
+#endif
+
+typedef uint16 SystemPortAddress;
+
+/* semaphore definitions */
+
+#define IPCProtection (0600) /* access/modify by user only */
+
+#define IPC_NMAXSEM 25 /* maximum number of semaphores */
+#define IpcSemaphoreDefaultStartValue 255
+#define IpcSharedLock (-1)
+#define IpcExclusiveLock (-255)
+
+#define IpcUnknownStatus (-1)
+#define IpcInvalidArgument (-2)
+#define IpcSemIdExist (-3)
+#define IpcSemIdNotExist (-4)
+
+typedef uint32 IpcSemaphoreKey; /* semaphore key */
+typedef int IpcSemaphoreId;
+
+/* shared memory definitions */
+
+#define IpcMemCreationFailed (-1)
+#define IpcMemIdGetFailed (-2)
+#define IpcMemAttachFailed 0
+
+typedef uint32 IPCKey;
+#define PrivateIPCKey IPC_PRIVATE
+#define DefaultIPCKey 17317
+
+typedef uint32 IpcMemoryKey; /* shared memory key */
+typedef int IpcMemoryId;
+
+
+/* ipc.c */
+extern void exitpg(int code);
+extern void quasi_exitpg(void);
+extern on_exitpg(void (*function)(), caddr_t arg);
+
+extern IpcSemaphoreId IpcSemaphoreCreate(IpcSemaphoreKey semKey,
+ int semNum, int permission, int semStartValue,
+ int removeOnExit, int *status);
+extern void IpcSemaphoreSet(int semId, int semno, int value);
+extern void IpcSemaphoreKill(IpcSemaphoreKey key);
+extern void IpcSemaphoreLock(IpcSemaphoreId semId, int sem, int lock);
+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,
+ int permission);
+extern IpcMemoryId IpcMemoryIdGet(IpcMemoryKey memKey, uint32 size);
+extern void IpcMemoryDetach(int status, char *shmaddr);
+extern char *IpcMemoryAttach(IpcMemoryId memId);
+extern void IpcMemoryKill(IpcMemoryKey memKey);
+extern void CreateAndInitSLockMemory(IPCKey key);
+extern void AttachSLockMemory(IPCKey key);
+
+
+#ifdef HAS_TEST_AND_SET
+
+#define NSLOCKS 2048
+#define NOLOCK 0
+#define SHAREDLOCK 1
+#define EXCLUSIVELOCK 2
+
+typedef enum _LockId_ {
+ BUFMGRLOCKID,
+ LOCKLOCKID,
+ OIDGENLOCKID,
+ SHMEMLOCKID,
+ BINDINGLOCKID,
+ LOCKMGRLOCKID,
+ SINVALLOCKID,
+
+#ifdef MAIN_MEMORY
+ MMCACHELOCKID,
+#endif /* MAIN_MEMORY */
+
+ PROCSTRUCTLOCKID,
+ FIRSTFREELOCKID
+} _LockId_;
+
+#define MAX_SPINS FIRSTFREELOCKID
+
+typedef struct slock {
+ slock_t locklock;
+ unsigned char flag;
+ short nshlocks;
+ slock_t shlock;
+ slock_t exlock;
+ slock_t comlock;
+ struct slock *next;
+} SLock;
+
+extern void ExclusiveLock(int lockid);
+extern void ExclusiveUnlock(int lockid);
+extern bool LockIsFree(int lockid);
+#else /* HAS_TEST_AND_SET */
+
+typedef enum _LockId_ {
+ SHMEMLOCKID,
+ BINDINGLOCKID,
+ BUFMGRLOCKID,
+ LOCKMGRLOCKID,
+ SINVALLOCKID,
+
+#ifdef MAIN_MEMORY
+ MMCACHELOCKID,
+#endif /* MAIN_MEMORY */
+
+ PROCSTRUCTLOCKID,
+ OIDGENLOCKID,
+ FIRSTFREELOCKID
+} _LockId_;
+
+#define MAX_SPINS FIRSTFREELOCKID
+
+#endif /* HAS_TEST_AND_SET */
+
+/*
+ * the following are originally in ipci.h but the prototypes have circular
+ * dependencies and most files include both ipci.h and ipc.h anyway, hence
+ * combined.
+ *
+ */
+
+/*
+ * Note:
+ * These must not hash to DefaultIPCKey or PrivateIPCKey.
+ */
+#define SystemPortAddressGetIPCKey(address) \
+ (28597 * (address) + 17491)
+
+/*
+ * these keys are originally numbered from 1 to 12 consecutively but not
+ * all are used. The unused ones are removed. - ay 4/95.
+ */
+#define IPCKeyGetBufferMemoryKey(key) \
+ ((key == PrivateIPCKey) ? key : 1 + (key))
+
+#define IPCKeyGetSIBufferMemoryBlock(key) \
+ ((key == PrivateIPCKey) ? key : 7 + (key))
+
+#define IPCKeyGetSLockSharedMemoryKey(key) \
+ ((key == PrivateIPCKey) ? key : 10 + (key))
+
+#define IPCKeyGetSpinLockSemaphoreKey(key) \
+ ((key == PrivateIPCKey) ? key : 11 + (key))
+#define IPCKeyGetWaitIOSemaphoreKey(key) \
+ ((key == PrivateIPCKey) ? key : 12 + (key))
+
+/* --------------------------
+ * NOTE: This macro must always give the highest numbered key as every backend
+ * process forked off by the postmaster will be trying to acquire a semaphore
+ * with a unique key value starting at key+14 and incrementing up. Each
+ * backend uses the current key value then increments it by one.
+ * --------------------------
+ */
+#define IPCGetProcessSemaphoreInitKey(key) \
+ ((key == PrivateIPCKey) ? key : 14 + (key))
+
+/* ipci.c */
+extern IPCKey SystemPortAddressCreateIPCKey(SystemPortAddress address);
+extern void CreateSharedMemoryAndSemaphores(IPCKey key);
+extern void AttachSharedMemoryAndSemaphores(IPCKey key);
+
+#endif /* IPC_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for storage/ipc
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/storage/ipc/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:54 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= ipc.c ipci.c s_lock.c shmem.c shmqueue.c sinval.c \
+ sinvaladt.c spin.c
--- /dev/null
+$Header: /cvsroot/pgsql/src/backend/storage/ipc/README,v 1.1.1.1 1996/07/09 06:21:54 scrappy Exp $
+Mon Jul 18 11:09:22 PDT 1988 W.KLAS
+
+Cache invalidation synchronization routines:
+===========================================
+
+The cache synchronization is done using a message queue. Every
+backend can register a message which then has to be read by
+all backends. A message read by all backends is removed from the
+queue automatically. If a message has been lost because the buffer
+was full, all backends that haven't read this message will be
+noticed that they have to reset their cache state. This is done
+at the time when they try to read the message queue.
+
+The message queue is implemented as a shared buffer segment. Actually,
+the queue is a circle to allow fast inserting, reading (invalidate data) and
+maintaining the buffer.
+
+Access to this shared message buffer is synchronized by the lock manager.
+The lock manager treats the buffer as a regular relation and sets
+relation level locks (with mode = LockWait) to block backends while
+another backend is writing or reading the buffer. The identifiers used
+for this special 'relation' are database id = 0 and relation id = 0.
+
+The current implementation prints regular (e)log information
+when a message has been removed from the buffer because the buffer
+is full, and a backend has to reset its cache state. The elog level
+is NOTICE. This can be used to improve teh behavior of backends
+when invalidating or reseting their cache state.
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * ipc.c--
+ * POSTGRES inter-process communication definitions.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipc.c,v 1.1.1.1 1996/07/09 06:21:54 scrappy Exp $
+ *
+ * NOTES
+ *
+ * Currently, semaphores are used (my understanding anyway) in two
+ * different ways:
+ * 1. as mutexes on machines that don't have test-and-set (eg.
+ * mips R3000).
+ * 2. for putting processes to sleep when waiting on a lock
+ * and waking them up when the lock is free.
+ * The number of semaphores in (1) is fixed and those are shared
+ * among all backends. In (2), there is 1 semaphore per process and those
+ * are not shared with anyone else.
+ * -ay 4/95
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include
+#include
+
+/* XXX - the following dependency should be moved into the defaults.mk file */
+#ifndef _IPC_
+#define _IPC_
+#include
+#include
+#include
+#endif
+
+#include "storage/ipc.h"
+#include "utils/memutils.h"
+#include "utils/elog.h"
+
+#if defined(PORTNAME_bsd44)
+int UsePrivateMemory = 1;
+#else
+int UsePrivateMemory = 0;
+#endif
+
+#if defined(PORTNAME_bsdi)
+/* hacka, hacka, hacka (XXX) */
+union semun {
+ int val; /* value for SETVAL */
+ struct semid_ds *buf; /* buffer for IPC_STAT & IPC_SET */
+ ushort *array; /* array for GETALL & SETALL */
+};
+#endif
+
+
+/* ----------------------------------------------------------------
+ * exit() handling stuff
+ * ----------------------------------------------------------------
+ */
+
+#define MAX_ON_EXITS 20
+
+static struct ONEXIT {
+ void (*function)();
+ caddr_t arg;
+} onexit_list[ MAX_ON_EXITS ];
+
+static int onexit_index;
+
+typedef struct _PrivateMemStruct {
+ int id;
+ char *memptr;
+} PrivateMem;
+
+PrivateMem IpcPrivateMem[16];
+
+static int
+PrivateMemoryCreate(IpcMemoryKey memKey,
+ uint32 size)
+{
+ static int memid = 0;
+
+ UsePrivateMemory = 1;
+
+ IpcPrivateMem[memid].id = memid;
+ IpcPrivateMem[memid].memptr = malloc(size);
+ if (IpcPrivateMem[memid].memptr == NULL)
+ elog(WARN, "PrivateMemoryCreate: not enough memory to malloc");
+ memset(IpcPrivateMem[memid].memptr, 0, size); /* XXX PURIFY */
+
+ return (memid++);
+}
+
+static char *
+PrivateMemoryAttach(IpcMemoryId memid)
+{
+ return ( IpcPrivateMem[memid].memptr );
+}
+
+
+/* ----------------------------------------------------------------
+ * exitpg
+ *
+ * this function calls all the callbacks registered
+ * for it (to free resources) and then calls exit.
+ * This should be the only function to call exit().
+ * -cim 2/6/90
+ * ----------------------------------------------------------------
+ */
+static int exitpg_inprogress = 0;
+
+void
+exitpg(int code)
+{
+ int i;
+
+ /* ----------------
+ * if exitpg_inprocess is true, then it means that we
+ * are being invoked from within an on_exit() handler
+ * and so we return immediately to avoid recursion.
+ * ----------------
+ */
+ if (exitpg_inprogress)
+ return;
+
+ exitpg_inprogress = 1;
+
+ /* ----------------
+ * call all the callbacks registered before calling exit().
+ * ----------------
+ */
+ for (i = onexit_index - 1; i >= 0; --i)
+ (*onexit_list[i].function)(code, onexit_list[i].arg);
+
+ exit(code);
+}
+
+/* ------------------
+ * Run all of the on_exitpg routines but don't exit in the end.
+ * This is used by the postmaster to re-initialize shared memory and
+ * semaphores after a backend dies horribly
+ * ------------------
+ */
+void
+quasi_exitpg()
+{
+ int i;
+
+ /* ----------------
+ * if exitpg_inprocess is true, then it means that we
+ * are being invoked from within an on_exit() handler
+ * and so we return immediately to avoid recursion.
+ * ----------------
+ */
+ if (exitpg_inprogress)
+ return;
+
+ exitpg_inprogress = 1;
+
+ /* ----------------
+ * call all the callbacks registered before calling exit().
+ * ----------------
+ */
+ for (i = onexit_index - 1; i >= 0; --i)
+ (*onexit_list[i].function)(0, onexit_list[i].arg);
+
+ onexit_index = 0;
+ exitpg_inprogress = 0;
+}
+
+/* ----------------------------------------------------------------
+ * on_exitpg
+ *
+ * this function adds a callback function to the list of
+ * functions invoked by exitpg(). -cim 2/6/90
+ * ----------------------------------------------------------------
+ */
+int
+on_exitpg(void (*function)(), caddr_t arg)
+{
+ if (onexit_index >= MAX_ON_EXITS)
+ return(-1);
+
+ onexit_list[ onexit_index ].function = function;
+ onexit_list[ onexit_index ].arg = arg;
+
+ ++onexit_index;
+
+ return(0);
+}
+
+/****************************************************************************/
+/* IPCPrivateSemaphoreKill(status, semId) */
+/* */
+/****************************************************************************/
+static void
+IPCPrivateSemaphoreKill(int status,
+ int semId) /* caddr_t */
+{
+ union semun semun;
+ semctl(semId, 0, IPC_RMID, semun);
+}
+
+
+/****************************************************************************/
+/* IPCPrivateMemoryKill(status, shmId) */
+/* */
+/****************************************************************************/
+static void
+IPCPrivateMemoryKill(int status,
+ int shmId) /* caddr_t */
+{
+ if ( UsePrivateMemory ) {
+ /* free ( IpcPrivateMem[shmId].memptr ); */
+ } else {
+ if (shmctl(shmId, IPC_RMID, (struct shmid_ds *) NULL) < 0) {
+ elog(NOTICE, "IPCPrivateMemoryKill: shmctl(%d, %d, 0) failed: %m",
+ shmId, IPC_RMID);
+ }
+ }
+}
+
+
+/****************************************************************************/
+/* IpcSemaphoreCreate(semKey, semNum, permission, semStartValue) */
+/* */
+/* - returns a semaphore identifier: */
+/* */
+/* if key doesn't exist: return a new id, status:= IpcSemIdNotExist */
+/* if key exists: return the old id, status:= IpcSemIdExist */
+/* if semNum > MAX : return # of argument, status:=IpcInvalidArgument */
+/* */
+/****************************************************************************/
+
+/*
+ * Note:
+ * XXX This should be split into two different calls. One should
+ * XXX be used to create a semaphore set. The other to "attach" a
+ * XXX existing set. It should be an error for the semaphore set
+ * XXX to to already exist or for it not to, respectively.
+ *
+ * Currently, the semaphore sets are "attached" and an error
+ * is detected only when a later shared memory attach fails.
+ */
+
+IpcSemaphoreId
+IpcSemaphoreCreate(IpcSemaphoreKey semKey,
+ int semNum,
+ int permission,
+ int semStartValue,
+ int removeOnExit,
+ int *status)
+{
+ int i;
+ int errStatus;
+ int semId;
+ u_short array[IPC_NMAXSEM];
+ union semun semun;
+
+ /* get a semaphore if non-existent */
+ /* check arguments */
+ if (semNum > IPC_NMAXSEM || semNum <= 0) {
+ *status = IpcInvalidArgument;
+ return(2); /* returns the number of the invalid argument */
+ }
+
+ semId = semget(semKey, 0, 0);
+
+ if (semId == -1) {
+ *status = IpcSemIdNotExist; /* there doesn't exist a semaphore */
+#ifdef DEBUG_IPC
+ fprintf(stderr,"calling semget with %d, %d , %d\n",
+ semKey,
+ semNum,
+ IPC_CREAT|permission );
+#endif
+ semId = semget(semKey, semNum, IPC_CREAT|permission);
+
+ if (semId < 0) {
+ perror("semget");
+ exitpg(3);
+ }
+ for (i = 0; i < semNum; i++) {
+ array[i] = semStartValue;
+ }
+ semun.array = array;
+ errStatus = semctl(semId, 0, SETALL, semun);
+ if (errStatus == -1) {
+ perror("semctl");
+ }
+
+ if (removeOnExit)
+ on_exitpg(IPCPrivateSemaphoreKill, (caddr_t)semId);
+
+ } else {
+ /* there is a semaphore id for this key */
+ *status = IpcSemIdExist;
+ }
+
+#ifdef DEBUG_IPC
+ fprintf(stderr,"\nIpcSemaphoreCreate, status %d, returns %d\n",
+ *status,
+ semId );
+ fflush(stdout);
+ fflush(stderr);
+#endif
+ return(semId);
+}
+
+
+/****************************************************************************/
+/* IpcSemaphoreSet() - sets the initial value of the semaphore */
+/* */
+/* note: the xxx_return variables are only used for debugging. */
+/****************************************************************************/
+static int IpcSemaphoreSet_return;
+
+void
+IpcSemaphoreSet(int semId, int semno, int value)
+{
+ int errStatus;
+ union semun semun;
+
+ semun.val = value;
+ errStatus = semctl(semId, semno, SETVAL, semun);
+ IpcSemaphoreSet_return = errStatus;
+
+ if (errStatus == -1)
+ perror("semctl");
+}
+
+/****************************************************************************/
+/* IpcSemaphoreKill(key) - removes a semaphore */
+/* */
+/****************************************************************************/
+void
+IpcSemaphoreKill(IpcSemaphoreKey key)
+{
+ int semId;
+ union semun semun;
+
+ /* kill semaphore if existent */
+
+ semId = semget(key, 0, 0);
+ if (semId != -1)
+ semctl(semId, 0, IPC_RMID, semun);
+}
+
+/****************************************************************************/
+/* IpcSemaphoreLock(semId, sem, lock) - locks a semaphore */
+/* */
+/* note: the xxx_return variables are only used for debugging. */
+/****************************************************************************/
+static int IpcSemaphoreLock_return;
+
+void
+IpcSemaphoreLock(IpcSemaphoreId semId, int sem, int lock)
+{
+ extern int errno;
+ int errStatus;
+ struct sembuf sops;
+
+ sops.sem_op = lock;
+ sops.sem_flg = 0;
+ sops.sem_num = sem;
+
+ /* ----------------
+ * Note: if errStatus is -1 and errno == EINTR then it means we
+ * returned from the operation prematurely because we were
+ * sent a signal. So we try and lock the semaphore again.
+ * I am not certain this is correct, but the semantics aren't
+ * clear it fixes problems with parallel abort synchronization,
+ * namely that after processing an abort signal, the semaphore
+ * call returns with -1 (and errno == EINTR) before it should.
+ * -cim 3/28/90
+ * ----------------
+ */
+ do {
+ errStatus = semop(semId, &sops, 1);
+ } while (errStatus == -1 && errno == EINTR);
+
+ IpcSemaphoreLock_return = errStatus;
+
+ if (errStatus == -1) {
+ perror("semop");
+ exitpg(255);
+ }
+}
+
+/****************************************************************************/
+/* IpcSemaphoreUnlock(semId, sem, lock) - unlocks a semaphore */
+/* */
+/* note: the xxx_return variables are only used for debugging. */
+/****************************************************************************/
+static int IpcSemaphoreUnlock_return;
+
+void
+IpcSemaphoreUnlock(IpcSemaphoreId semId, int sem, int lock)
+{
+ extern int errno;
+ int errStatus;
+ struct sembuf sops;
+
+ sops.sem_op = -lock;
+ sops.sem_flg = 0;
+ sops.sem_num = sem;
+
+
+ /* ----------------
+ * Note: if errStatus is -1 and errno == EINTR then it means we
+ * returned from the operation prematurely because we were
+ * sent a signal. So we try and lock the semaphore again.
+ * I am not certain this is correct, but the semantics aren't
+ * clear it fixes problems with parallel abort synchronization,
+ * namely that after processing an abort signal, the semaphore
+ * call returns with -1 (and errno == EINTR) before it should.
+ * -cim 3/28/90
+ * ----------------
+ */
+ do {
+ errStatus = semop(semId, &sops, 1);
+ } while (errStatus == -1 && errno == EINTR);
+
+ IpcSemaphoreUnlock_return = errStatus;
+
+ if (errStatus == -1) {
+ perror("semop");
+ exitpg(255);
+ }
+}
+
+int
+IpcSemaphoreGetCount(IpcSemaphoreId semId, int sem)
+{
+ int semncnt;
+ union semun dummy; /* for Solaris */
+
+ semncnt = semctl(semId, sem, GETNCNT, dummy);
+ return semncnt;
+}
+
+int
+IpcSemaphoreGetValue(IpcSemaphoreId semId, int sem)
+{
+ int semval;
+ union semun dummy; /* for Solaris */
+
+ semval = semctl(semId, sem, GETVAL, dummy);
+ return semval;
+}
+
+/****************************************************************************/
+/* IpcMemoryCreate(memKey) */
+/* */
+/* - returns the memory identifier, if creation succeeds */
+/* returns IpcMemCreationFailed, if failure */
+/****************************************************************************/
+
+IpcMemoryId
+IpcMemoryCreate(IpcMemoryKey memKey, uint32 size, int permission)
+{
+ IpcMemoryId shmid;
+
+ if (memKey == PrivateIPCKey) {
+ /* private */
+ shmid = PrivateMemoryCreate(memKey, size);
+ }else {
+ shmid = shmget(memKey, size, IPC_CREAT|permission);
+ }
+
+ if (shmid < 0) {
+ fprintf(stderr,"IpcMemoryCreate: memKey=%d , size=%d , permission=%d",
+ memKey, size , permission );
+ perror("IpcMemoryCreate: shmget(..., create, ...) failed");
+ return(IpcMemCreationFailed);
+ }
+
+ /* if (memKey == PrivateIPCKey) */
+ on_exitpg(IPCPrivateMemoryKill, (caddr_t)shmid);
+
+ return(shmid);
+}
+
+/****************************************************************************/
+/* IpcMemoryIdGet(memKey, size) returns the shared memory Id */
+/* or IpcMemIdGetFailed */
+/****************************************************************************/
+IpcMemoryId
+IpcMemoryIdGet(IpcMemoryKey memKey, uint32 size)
+{
+ IpcMemoryId shmid;
+
+ shmid = shmget(memKey, size, 0);
+
+ if (shmid < 0) {
+ fprintf(stderr,"IpcMemoryIdGet: memKey=%d , size=%d , permission=%d",
+ memKey, size , 0 );
+ perror("IpcMemoryIdGet: shmget() failed");
+ return(IpcMemIdGetFailed);
+ }
+
+ return(shmid);
+}
+
+/****************************************************************************/
+/* IpcMemoryDetach(status, shmaddr) removes a shared memory segment */
+/* from a backend address space */
+/* (only called by backends running under the postmaster) */
+/****************************************************************************/
+void
+IpcMemoryDetach(int status, char *shmaddr)
+{
+ if (shmdt(shmaddr) < 0) {
+ elog(NOTICE, "IpcMemoryDetach: shmdt(0x%x): %m", shmaddr);
+ }
+}
+
+/****************************************************************************/
+/* IpcMemoryAttach(memId) returns the adress of shared memory */
+/* or IpcMemAttachFailed */
+/* */
+/* CALL IT: addr = (struct *) IpcMemoryAttach(memId); */
+/* */
+/****************************************************************************/
+char *
+IpcMemoryAttach(IpcMemoryId memId)
+{
+ char *memAddress;
+
+ if (UsePrivateMemory) {
+ memAddress = (char *) PrivateMemoryAttach(memId);
+ } else {
+ memAddress = (char *) shmat(memId, 0, 0);
+ }
+
+ /* if ( *memAddress == -1) { XXX ??? */
+ if ( memAddress == (char *)-1) {
+ perror("IpcMemoryAttach: shmat() failed");
+ return(IpcMemAttachFailed);
+ }
+
+ if (!UsePrivateMemory)
+ on_exitpg(IpcMemoryDetach, (caddr_t) memAddress);
+
+ return((char *) memAddress);
+}
+
+
+/****************************************************************************/
+/* IpcMemoryKill(memKey) removes a shared memory segment */
+/* (only called by the postmaster and standalone backends) */
+/****************************************************************************/
+void
+IpcMemoryKill(IpcMemoryKey memKey)
+{
+ IpcMemoryId shmid;
+
+ if (!UsePrivateMemory && (shmid = shmget(memKey, 0, 0)) >= 0) {
+ if (shmctl(shmid, IPC_RMID, (struct shmid_ds *) NULL) < 0) {
+ elog(NOTICE, "IpcMemoryKill: shmctl(%d, %d, 0) failed: %m",
+ shmid, IPC_RMID);
+ }
+ }
+}
+
+#ifdef HAS_TEST_AND_SET
+/* ------------------
+ * use hardware locks to replace semaphores for sequent machines
+ * to avoid costs of swapping processes and to provide unlimited
+ * supply of locks.
+ * ------------------
+ */
+static SLock *SLockArray = NULL;
+static SLock **FreeSLockPP;
+static int *UnusedSLockIP;
+static slock_t *SLockMemoryLock;
+static IpcMemoryId SLockMemoryId = -1;
+
+struct ipcdummy { /* to get alignment/size right */
+ SLock *free;
+ int unused;
+ slock_t memlock;
+ SLock slocks[NSLOCKS];
+};
+static int SLockMemorySize = sizeof(struct ipcdummy);
+
+void
+CreateAndInitSLockMemory(IPCKey key)
+{
+ int id;
+ SLock *slckP;
+
+ SLockMemoryId = IpcMemoryCreate(key,
+ SLockMemorySize,
+ 0700);
+ AttachSLockMemory(key);
+ *FreeSLockPP = NULL;
+ *UnusedSLockIP = (int)FIRSTFREELOCKID;
+ for (id=0; id<(int)FIRSTFREELOCKID; id++) {
+ slckP = &(SLockArray[id]);
+ S_INIT_LOCK(&(slckP->locklock));
+ slckP->flag = NOLOCK;
+ slckP->nshlocks = 0;
+ S_INIT_LOCK(&(slckP->shlock));
+ S_INIT_LOCK(&(slckP->exlock));
+ S_INIT_LOCK(&(slckP->comlock));
+ slckP->next = NULL;
+ }
+ return;
+}
+
+void
+AttachSLockMemory(IPCKey key)
+{
+ struct ipcdummy *slockM;
+
+ if (SLockMemoryId == -1)
+ SLockMemoryId = IpcMemoryIdGet(key,SLockMemorySize);
+ if (SLockMemoryId == -1)
+ elog(FATAL, "SLockMemory not in shared memory");
+ slockM = (struct ipcdummy *) IpcMemoryAttach(SLockMemoryId);
+ if (slockM == IpcMemAttachFailed)
+ elog(FATAL, "AttachSLockMemory: could not attach segment");
+ FreeSLockPP = (SLock **) &(slockM->free);
+ UnusedSLockIP = (int *) &(slockM->unused);
+ SLockMemoryLock = (slock_t *) &(slockM->memlock);
+ S_INIT_LOCK(SLockMemoryLock);
+ SLockArray = (SLock *) &(slockM->slocks[0]);
+ return;
+}
+
+
+#ifdef LOCKDEBUG
+#define PRINT_LOCK(LOCK) printf("(locklock = %d, flag = %d, nshlocks = %d, \
+shlock = %d, exlock =%d)\n", LOCK->locklock, \
+ LOCK->flag, LOCK->nshlocks, LOCK->shlock, \
+ LOCK->exlock)
+#endif
+
+void
+ExclusiveLock(int lockid)
+{
+ SLock *slckP;
+ slckP = &(SLockArray[lockid]);
+#ifdef LOCKDEBUG
+ printf("ExclusiveLock(%d)\n", lockid);
+ printf("IN: ");
+ PRINT_LOCK(slckP);
+#endif
+ ex_try_again:
+ S_LOCK(&(slckP->locklock));
+ switch (slckP->flag) {
+ case NOLOCK:
+ slckP->flag = EXCLUSIVELOCK;
+ S_LOCK(&(slckP->exlock));
+ S_LOCK(&(slckP->shlock));
+ S_UNLOCK(&(slckP->locklock));
+#ifdef LOCKDEBUG
+ printf("OUT: ");
+ PRINT_LOCK(slckP);
+#endif
+ return;
+ case SHAREDLOCK:
+ case EXCLUSIVELOCK:
+ S_UNLOCK(&(slckP->locklock));
+ S_LOCK(&(slckP->exlock));
+ S_UNLOCK(&(slckP->exlock));
+ goto ex_try_again;
+ }
+}
+
+void
+ExclusiveUnlock(int lockid)
+{
+ SLock *slckP;
+
+ slckP = &(SLockArray[lockid]);
+#ifdef LOCKDEBUG
+ printf("ExclusiveUnlock(%d)\n", lockid);
+ printf("IN: ");
+ PRINT_LOCK(slckP);
+#endif
+ S_LOCK(&(slckP->locklock));
+ /* -------------
+ * give favor to read processes
+ * -------------
+ */
+ slckP->flag = NOLOCK;
+ if (slckP->nshlocks > 0) {
+ while (slckP->nshlocks > 0) {
+ S_UNLOCK(&(slckP->shlock));
+ S_LOCK(&(slckP->comlock));
+ }
+ S_UNLOCK(&(slckP->shlock));
+ }
+ else {
+ S_UNLOCK(&(slckP->shlock));
+ }
+ S_UNLOCK(&(slckP->exlock));
+ S_UNLOCK(&(slckP->locklock));
+#ifdef LOCKDEBUG
+ printf("OUT: ");
+ PRINT_LOCK(slckP);
+#endif
+ return;
+}
+
+bool
+LockIsFree(int lockid)
+{
+ return(SLockArray[lockid].flag == NOLOCK);
+}
+
+#endif /* HAS_TEST_AND_SET */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * ipci.c--
+ * POSTGRES inter-process communication initialization code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipci.c,v 1.1.1.1 1996/07/09 06:21:54 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "c.h"
+
+#include "storage/ipc.h"
+#include "storage/multilev.h"
+#include "utils/elog.h"
+#include "storage/sinval.h"
+#include "storage/bufmgr.h"
+#include "storage/proc.h"
+#include "storage/smgr.h"
+#include "storage/lock.h"
+#include "miscadmin.h" /* for DebugLvl */
+
+/*
+ * SystemPortAddressCreateMemoryKey --
+ * Returns a memory key given a port address.
+ */
+IPCKey
+SystemPortAddressCreateIPCKey(SystemPortAddress address)
+{
+ Assert(address < 32768); /* XXX */
+
+ return (SystemPortAddressGetIPCKey(address));
+}
+
+/*
+ * CreateSharedMemoryAndSemaphores --
+ * Creates and initializes shared memory and semaphores.
+ */
+/**************************************************
+
+ CreateSharedMemoryAndSemaphores
+ is called exactly *ONCE* by the postmaster.
+ It is *NEVER* called by the postgres backend
+
+ 0) destroy any existing semaphores for both buffer
+ and lock managers.
+ 1) create the appropriate *SHARED* memory segments
+ for the two resource managers.
+
+ **************************************************/
+
+void
+CreateSharedMemoryAndSemaphores(IPCKey key)
+{
+ int size;
+
+#ifdef HAS_TEST_AND_SET
+ /* ---------------
+ * create shared memory for slocks
+ * --------------
+ */
+ CreateAndInitSLockMemory(IPCKeyGetSLockSharedMemoryKey(key));
+#endif
+ /* ----------------
+ * kill and create the buffer manager buffer pool (and semaphore)
+ * ----------------
+ */
+ CreateSpinlocks(IPCKeyGetSpinLockSemaphoreKey(key));
+ size = BufferShmemSize() + LockShmemSize();
+
+#ifdef MAIN_MEMORY
+ size += MMShmemSize();
+#endif /* MAIN_MEMORY */
+
+ if (DebugLvl > 1) {
+ fprintf(stderr, "binding ShmemCreate(key=%x, size=%d)\n",
+ IPCKeyGetBufferMemoryKey(key), size);
+ }
+ ShmemCreate(IPCKeyGetBufferMemoryKey(key), size);
+ ShmemBindingTabReset();
+ InitShmem(key, size);
+ InitBufferPool(key);
+
+ /* ----------------
+ * do the lock table stuff
+ * ----------------
+ */
+ InitLocks();
+ InitMultiLevelLockm();
+ if (InitMultiLevelLockm() == INVALID_TABLEID)
+ elog(FATAL, "Couldn't create the lock table");
+
+ /* ----------------
+ * do process table stuff
+ * ----------------
+ */
+ InitProcGlobal(key);
+ on_exitpg(ProcFreeAllSemaphores, 0);
+
+ CreateSharedInvalidationState(key);
+}
+
+
+/*
+ * AttachSharedMemoryAndSemaphores --
+ * Attachs existant shared memory and semaphores.
+ */
+void
+AttachSharedMemoryAndSemaphores(IPCKey key)
+{
+ int size;
+
+ /* ----------------
+ * create rather than attach if using private key
+ * ----------------
+ */
+ if (key == PrivateIPCKey) {
+ CreateSharedMemoryAndSemaphores(key);
+ return;
+ }
+
+#ifdef HAS_TEST_AND_SET
+ /* ----------------
+ * attach the slock shared memory
+ * ----------------
+ */
+ AttachSLockMemory(IPCKeyGetSLockSharedMemoryKey(key));
+#endif
+ /* ----------------
+ * attach the buffer manager buffer pool (and semaphore)
+ * ----------------
+ */
+ size = BufferShmemSize() + LockShmemSize();
+ InitShmem(key, size);
+ InitBufferPool(key);
+
+ /* ----------------
+ * initialize lock table stuff
+ * ----------------
+ */
+ InitLocks();
+ if (InitMultiLevelLockm() == INVALID_TABLEID)
+ elog(FATAL, "Couldn't attach to the lock table");
+
+ AttachSharedInvalidationState(key);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * s_lock.c--
+ * This file contains the implementation (if any) for spinlocks.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/Attic/s_lock.c,v 1.1.1.1 1996/07/09 06:21:54 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ * DESCRIPTION
+ * The following code fragment should be written (in assembly
+ * language) on machines that have a native test-and-set instruction:
+ *
+ * void
+ * S_LOCK(char_address)
+ * char *char_address;
+ * {
+ * while (test_and_set(char_address))
+ * ;
+ * }
+ *
+ * If this is not done, POSTGRES will default to using System V
+ * semaphores (and take a large performance hit -- around 40% of
+ * its time on a DS5000/240 is spent in semop(3)...).
+ *
+ * NOTES
+ * AIX has a test-and-set but the recommended interface is the cs(3)
+ * system call. This provides an 8-instruction (plus system call
+ * overhead) uninterruptible compare-and-set operation. True
+ * spinlocks might be faster but using cs(3) still speeds up the
+ * regression test suite by about 25%. I don't have an assembler
+ * manual for POWER in any case.
+ *
+ */
+#ifdef WIN32
+#include
+#endif /* WIN32 */
+#include "storage/ipc.h"
+
+
+#if defined(HAS_TEST_AND_SET)
+
+#if defined (PORTNAME_next)
+/*
+ * NEXTSTEP (mach)
+ * slock_t is defined as a struct mutex.
+ */
+void
+S_LOCK(slock_t *lock)
+{
+ mutex_lock(lock);
+}
+void
+S_UNLOCK(slock_t *lock)
+{
+ mutex_unlock(lock);
+}
+void
+S_INIT_LOCK(slock_t *lock)
+{
+ mutex_init(lock);
+}
+
+ /* S_LOCK_FREE should return 1 if lock is free; 0 if lock is locked */
+int
+ S_LOCK_FREE(slock_t *lock)
+{
+ /* For Mach, we have to delve inside the entrails of `struct
+mutex'. Ick! */
+ return (lock->lock == 0);
+}
+
+#endif /* PORTNAME_next */
+
+
+
+#if defined(PORTNAME_irix5)
+/*
+ * SGI IRIX 5
+ * slock_t is defined as a struct abilock_t, which has a single unsigned long
+ * member.
+ *
+ * This stuff may be supplemented in the future with Masato Kataoka's MIPS-II
+ * assembly from his NECEWS SVR4 port, but we probably ought to retain this
+ * for the R3000 chips out there.
+ */
+void
+S_LOCK(slock_t *lock)
+{
+ /* spin_lock(lock); */
+ while (!acquire_lock(lock))
+ ;
+}
+
+void
+S_UNLOCK(slock_t *lock)
+{
+ (void)release_lock(lock);
+}
+
+void
+S_INIT_LOCK(slock_t *lock)
+{
+ (void)init_lock(lock);
+}
+
+/* S_LOCK_FREE should return 1 if lock is free; 0 if lock is locked */
+int
+S_LOCK_FREE(slock_t *lock)
+{
+ return(stat_lock(lock)==UNLOCKED);
+}
+
+#endif /* PORTNAME_irix5 */
+
+
+/*
+ * OSF/1 (Alpha AXP)
+ *
+ * Note that slock_t on the Alpha AXP is msemaphore instead of char
+ * (see storage/ipc.h).
+ */
+
+#if defined(PORTNAME_alpha)
+
+void
+S_LOCK(slock_t *lock)
+{
+ while (msem_lock(lock, MSEM_IF_NOWAIT) < 0)
+ ;
+}
+
+void
+S_UNLOCK(slock_t *lock)
+{
+ (void) msem_unlock(lock, 0);
+}
+
+void
+S_INIT_LOCK(slock_t *lock)
+{
+ (void) msem_init(lock, MSEM_UNLOCKED);
+}
+
+int
+S_LOCK_FREE(slock_t *lock)
+{
+ return(lock->msem_state ? 0 : 1);
+}
+
+#endif /* PORTNAME_alpha */
+
+/*
+ * Solaris 2
+ */
+
+#if defined(PORTNAME_sparc_solaris)
+
+/* defined in port/.../tas.s */
+extern int tas(slock_t *lock);
+
+void
+S_LOCK(slock_t *lock)
+{
+ while (tas(lock))
+ ;
+}
+
+void
+S_UNLOCK(slock_t *lock)
+{
+ *lock = 0;
+}
+
+void
+S_INIT_LOCK(slock_t *lock)
+{
+ S_UNLOCK(lock);
+}
+
+#endif /* PORTNAME_sparc_solaris */
+
+/*
+ * AIX (POWER)
+ *
+ * Note that slock_t on POWER/POWER2/PowerPC is int instead of char
+ * (see storage/ipc.h).
+ */
+
+#if defined(PORTNAME_aix)
+
+void
+S_LOCK(slock_t *lock)
+{
+ while (cs((int *) lock, 0, 1))
+ ;
+}
+
+void
+S_UNLOCK(slock_t *lock)
+{
+ *lock = 0;
+}
+
+void
+S_INIT_LOCK(slock_t *lock)
+{
+ S_UNLOCK(lock);
+}
+
+#endif /* PORTNAME_aix */
+
+/*
+ * HP-UX (PA-RISC)
+ *
+ * Note that slock_t on PA-RISC is a structure instead of char
+ * (see storage/ipc.h).
+ */
+
+#if defined(PORTNAME_hpux)
+
+/* defined in port/.../tas.s */
+extern int tas(slock_t *lock);
+
+/*
+* a "set" slock_t has a single word cleared. a "clear" slock_t has
+* all words set to non-zero.
+*/
+static slock_t clear_lock = { -1, -1, -1, -1 };
+
+void
+S_LOCK(slock_t *lock)
+{
+ while (tas(lock))
+ ;
+}
+
+void
+S_UNLOCK(slock_t *lock)
+{
+ *lock = clear_lock; /* struct assignment */
+}
+
+void
+S_INIT_LOCK(slock_t *lock)
+{
+ S_UNLOCK(lock);
+}
+
+int
+S_LOCK_FREE(slock_t *lock)
+{
+ register int *lock_word = (int *) (((long) lock + 15) & ~15);
+
+ return(*lock_word != 0);
+}
+
+#endif /* PORTNAME_hpux */
+
+/*
+ * sun3
+ */
+
+#if (defined(sun) && ! defined(sparc))
+
+void
+S_LOCK(slock_t *lock)
+{
+ while (tas(lock));
+}
+
+void
+S_UNLOCK(slock_t *lock)
+{
+ *lock = 0;
+}
+
+void
+S_INIT_LOCK(slock_t *lock)
+{
+ S_UNLOCK(lock);
+}
+
+static int
+tas_dummy()
+{
+ asm("LLA0:");
+ asm(" .data");
+ asm(" .text");
+ asm("|#PROC# 04");
+ asm(" .globl _tas");
+ asm("_tas:");
+ asm("|#PROLOGUE# 1");
+ asm(" movel sp@(0x4),a0");
+ asm(" tas a0@");
+ asm(" beq LLA1");
+ asm(" moveq #-128,d0");
+ asm(" rts");
+ asm("LLA1:");
+ asm(" moveq #0,d0");
+ asm(" rts");
+ asm(" .data");
+}
+
+#endif
+
+/*
+ * SPARC (SunOS 4)
+ */
+
+#if defined(PORTNAME_sparc)
+
+/* if we're using -ansi w/ gcc, use __asm__ instead of asm */
+#if defined(__STRICT_ANSI__)
+#define asm(x) __asm__(x)
+#endif
+
+static int
+tas_dummy()
+{
+ asm(".seg \"data\"");
+ asm(".seg \"text\"");
+ asm(".global _tas");
+ asm("_tas:");
+
+ /*
+ * Sparc atomic test and set (sparc calls it "atomic load-store")
+ */
+
+ asm("ldstub [%r8], %r8");
+
+ /*
+ * Did test and set actually do the set?
+ */
+
+ asm("tst %r8");
+
+ asm("be,a ReturnZero");
+
+ /*
+ * otherwise, just return.
+ */
+
+ asm("clr %r8");
+ asm("mov 0x1, %r8");
+ asm("ReturnZero:");
+ asm("retl");
+ asm("nop");
+}
+
+void
+S_LOCK(unsigned char *addr)
+{
+ while (tas(addr));
+}
+
+
+/*
+ * addr should be as in the above S_LOCK routine
+ */
+void
+S_UNLOCK(unsigned char *addr)
+{
+ *addr = 0;
+}
+
+void
+S_INIT_LOCK(unsigned char *addr)
+{
+ *addr = 0;
+}
+
+#endif /* PORTNAME_sparc */
+
+/*
+ * Linux and friends
+ */
+
+#if defined(PORTNAME_linux) || defined(PORTNAME_BSD44_derived)
+
+int
+tas(slock_t *m)
+{
+ slock_t res;
+ __asm__("xchgb %0,%1":"=q" (res),"=m" (*m):"0" (0x1));
+ return(res);
+}
+
+void
+S_LOCK(slock_t *lock)
+{
+ while (tas(lock))
+ ;
+}
+
+void
+S_UNLOCK(slock_t *lock)
+{
+ *lock = 0;
+}
+
+void
+S_INIT_LOCK(slock_t *lock)
+{
+ S_UNLOCK(lock);
+}
+
+#endif /* PORTNAME_linux || PORTNAME_BSD44_derived */
+
+
+#endif /* HAS_TEST_AND_SET */
+
+
+#ifdef WIN32
+void
+S_LOCK(HANDLE *lock)
+{
+ int x = 0;
+ x = x / x;
+}
+
+void
+S_UNLOCK(HANDLE *lock)
+{
+ int x = 0;
+ x = x / x;
+}
+
+void
+S_INIT_LOCK(HANDLE *lock)
+{
+ int x = 0;
+ x = x / x;
+}
+#endif /*WIN32*/
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * shmem.c--
+ * create shared memory and initialize shared memory data structures.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmem.c,v 1.1.1.1 1996/07/09 06:21:54 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ * POSTGRES processes share one or more regions of shared memory.
+ * The shared memory is created by a postmaster and is "attached to"
+ * by each of the backends. The routines in this file are used for
+ * allocating and binding to shared memory data structures.
+ *
+ * NOTES:
+ * (a) There are three kinds of shared memory data structures
+ * available to POSTGRES: fixed-size structures, queues and hash
+ * tables. Fixed-size structures contain things like global variables
+ * for a module and should never be allocated after the process
+ * initialization phase. Hash tables have a fixed maximum size, but
+ * their actual size can vary dynamically. When entries are added
+ * to the table, more space is allocated. Queues link data structures
+ * that have been allocated either as fixed size structures or as hash
+ * buckets. Each shared data structure has a string name to identify
+ * it (assigned in the module that declares it).
+ *
+ * (b) During initialization, each module looks for its
+ * shared data structures in a hash table called the "Binding Table".
+ * If the data structure is not present, the caller can allocate
+ * a new one and initialize it. If the data structure is present,
+ * the caller "attaches" to the structure by initializing a pointer
+ * in the local address space.
+ * The binding table has two purposes: first, it gives us
+ * a simple model of how the world looks when a backend process
+ * initializes. If something is present in the binding table,
+ * it is initialized. If it is not, it is uninitialized. Second,
+ * the binding table allows us to allocate shared memory on demand
+ * instead of trying to preallocate structures and hard-wire the
+ * sizes and locations in header files. If you are using a lot
+ * of shared memory in a lot of different places (and changing
+ * things during development), this is important.
+ *
+ * (c) memory allocation model: shared memory can never be
+ * freed, once allocated. Each hash table has its own free list,
+ * so hash buckets can be reused when an item is deleted. However,
+ * if one hash table grows very large and then shrinks, its space
+ * cannot be redistributed to other tables. We could build a simple
+ * hash bucket garbage collector if need be. Right now, it seems
+ * unnecessary.
+ *
+ * See InitSem() in sem.c for an example of how to use the
+ * binding table.
+ *
+ */
+#include
+#include
+#include "postgres.h"
+#include "storage/ipc.h"
+#include "storage/shmem.h"
+#include "storage/spin.h"
+#include "utils/hsearch.h"
+#include "utils/elog.h"
+
+/* shared memory global variables */
+
+unsigned long ShmemBase = 0; /* start and end address of
+ * shared memory
+ */
+static unsigned long ShmemEnd = 0;
+static unsigned long ShmemSize = 0; /* current size (and default) */
+
+SPINLOCK ShmemLock; /* lock for shared memory allocation */
+
+SPINLOCK BindingLock; /* lock for binding table access */
+
+static unsigned long *ShmemFreeStart = NULL; /* pointer to the OFFSET of
+ * first free shared memory
+ */
+static unsigned long *ShmemBindingTabOffset = NULL; /* start of the binding
+ * table (for bootstrap)
+ */
+static int ShmemBootstrap = FALSE; /* flag becomes true when shared mem
+ * is created by POSTMASTER
+ */
+
+static HTAB *BindingTable = NULL;
+
+/* ---------------------
+ * ShmemBindingTabReset() - Resets the binding table to NULL....
+ * useful when the postmaster destroys existing shared memory
+ * and creates all new segments after a backend crash.
+ * ----------------------
+ */
+void
+ShmemBindingTabReset()
+{
+ BindingTable = (HTAB *)NULL;
+}
+
+/*
+ * CreateSharedRegion() --
+ *
+ * This routine is called once by the postmaster to
+ * initialize the shared buffer pool. Assume there is
+ * only one postmaster so no synchronization is necessary
+ * until after this routine completes successfully.
+ *
+ * key is a unique identifier for the shmem region.
+ * size is the size of the region.
+ */
+static IpcMemoryId ShmemId;
+
+void
+ShmemCreate(unsigned int key, unsigned int size)
+{
+ if (size)
+ ShmemSize = size;
+ /* create shared mem region */
+ if ((ShmemId=IpcMemoryCreate(key,ShmemSize,IPCProtection))
+ ==IpcMemCreationFailed) {
+ elog(FATAL,"ShmemCreate: cannot create region");
+ exit(1);
+ }
+
+ /* ShmemBootstrap is true if shared memory has been
+ * created, but not yet initialized. Only the
+ * postmaster/creator-of-all-things should have
+ * this flag set.
+ */
+ ShmemBootstrap = TRUE;
+}
+
+/*
+ * InitShmem() -- map region into process address space
+ * and initialize shared data structures.
+ *
+ */
+int
+InitShmem(unsigned int key, unsigned int size)
+{
+ Pointer sharedRegion;
+ unsigned long currFreeSpace;
+
+ HASHCTL info;
+ int hash_flags;
+ BindingEnt * result,item;
+ bool found;
+ IpcMemoryId shmid;
+
+ /* if zero key, use default memory size */
+ if (size)
+ ShmemSize = size;
+
+ /* default key is 0 */
+
+ /* attach to shared memory region (SysV or BSD OS specific) */
+ if (ShmemBootstrap && key == PrivateIPCKey)
+ /* if we are running backend alone */
+ shmid = ShmemId;
+ else
+ shmid = IpcMemoryIdGet(IPCKeyGetBufferMemoryKey(key), ShmemSize);
+ sharedRegion = IpcMemoryAttach(shmid);
+ if (sharedRegion == NULL) {
+ elog(FATAL,"AttachSharedRegion: couldn't attach to shmem\n");
+ return(FALSE);
+ }
+
+ /* get pointers to the dimensions of shared memory */
+ ShmemBase = (unsigned long) sharedRegion;
+ ShmemEnd = (unsigned long) sharedRegion + ShmemSize;
+ currFreeSpace = 0;
+
+ /* First long in shared memory is the count of available space */
+ ShmemFreeStart = (unsigned long *) ShmemBase;
+ /* next is a shmem pointer to the binding table */
+ ShmemBindingTabOffset = ShmemFreeStart + 1;
+
+ currFreeSpace +=
+ sizeof(ShmemFreeStart) + sizeof(ShmemBindingTabOffset);
+
+ /* bootstrap initialize spin locks so we can start to use the
+ * allocator and binding table.
+ */
+ if (! InitSpinLocks(ShmemBootstrap, IPCKeyGetSpinLockSemaphoreKey(key))) {
+ return(FALSE);
+ }
+
+ /* We have just allocated additional space for two spinlocks.
+ * Now setup the global free space count
+ */
+ if (ShmemBootstrap) {
+ *ShmemFreeStart = currFreeSpace;
+ }
+
+ /* if ShmemFreeStart is NULL, then the allocator won't work */
+ Assert(*ShmemFreeStart);
+
+ /* create OR attach to the shared memory binding table */
+ info.keysize = BTABLE_KEYSIZE;
+ info.datasize = BTABLE_DATASIZE;
+ hash_flags = (HASH_ELEM);
+
+ /* This will acquire the binding table lock, but not release it. */
+ BindingTable = ShmemInitHash("BindingTable",
+ BTABLE_SIZE,BTABLE_SIZE,
+ &info,hash_flags);
+
+ if (! BindingTable) {
+ elog(FATAL,"InitShmem: couldn't initialize Binding Table");
+ return(FALSE);
+ }
+
+ /* Now, check the binding table for an entry to the binding
+ * table. If there is an entry there, someone else created
+ * the table. Otherwise, we did and we have to initialize it.
+ */
+ memset(item.key, 0, BTABLE_KEYSIZE);
+ strncpy(item.key,"BindingTable",BTABLE_KEYSIZE);
+
+ result = (BindingEnt *)
+ hash_search(BindingTable,(char *) &item,HASH_ENTER, &found);
+
+
+ if (! result ) {
+ elog(FATAL,"InitShmem: corrupted binding table");
+ return(FALSE);
+ }
+
+ if (! found) {
+ /* bootstrapping shmem: we have to initialize the
+ * binding table now.
+ */
+
+ Assert(ShmemBootstrap);
+ result->location = MAKE_OFFSET(BindingTable->hctl);
+ *ShmemBindingTabOffset = result->location;
+ result->size = BTABLE_SIZE;
+
+ ShmemBootstrap = FALSE;
+
+ } else {
+ Assert(! ShmemBootstrap);
+ }
+ /* now release the lock acquired in ShmemHashInit */
+ SpinRelease (BindingLock);
+
+ Assert (result->location == MAKE_OFFSET(BindingTable->hctl));
+
+ return(TRUE);
+}
+
+/*
+ * ShmemAlloc -- allocate word-aligned byte string from
+ * shared memory
+ *
+ * Assumes ShmemLock and ShmemFreeStart are initialized.
+ * Returns: real pointer to memory or NULL if we are out
+ * of space. Has to return a real pointer in order
+ * to be compatable with malloc().
+ */
+long *
+ShmemAlloc(unsigned long size)
+{
+ unsigned long tmpFree;
+ long *newSpace;
+
+ /*
+ * ensure space is word aligned.
+ *
+ * Word-alignment is not good enough. We have to be more
+ * conservative: doubles need 8-byte alignment. (We probably only need
+ * this on RISC platforms but this is not a big waste of space.)
+ * - ay 12/94
+ */
+ if (size % sizeof(double))
+ size += sizeof(double) - (size % sizeof(double));
+
+ Assert(*ShmemFreeStart);
+
+ SpinAcquire(ShmemLock);
+
+ tmpFree = *ShmemFreeStart + size;
+ if (tmpFree <= ShmemSize) {
+ newSpace = (long *)MAKE_PTR(*ShmemFreeStart);
+ *ShmemFreeStart += size;
+ } else {
+ newSpace = NULL;
+ }
+
+ SpinRelease(ShmemLock);
+
+ if (! newSpace) {
+ elog(NOTICE,"ShmemAlloc: out of memory ");
+ }
+ return(newSpace);
+}
+
+/*
+ * ShmemIsValid -- test if an offset refers to valid shared memory
+ *
+ * Returns TRUE if the pointer is valid.
+ */
+int
+ShmemIsValid(unsigned long addr)
+{
+ return ((addr=ShmemBase));
+}
+
+/*
+ * ShmemInitHash -- Create/Attach to and initialize
+ * shared memory hash table.
+ *
+ * Notes:
+ *
+ * assume caller is doing some kind of synchronization
+ * so that two people dont try to create/initialize the
+ * table at once. Use SpinAlloc() to create a spinlock
+ * for the structure before creating the structure itself.
+ */
+HTAB *
+ShmemInitHash(char *name, /* table string name for binding */
+ long init_size, /* initial size */
+ long max_size, /* max size of the table */
+ HASHCTL *infoP, /* info about key and bucket size */
+ int hash_flags) /* info about infoP */
+{
+ bool found;
+ long * location;
+
+ /* shared memory hash tables have a fixed max size so that the
+ * control structures don't try to grow. The segbase is for
+ * calculating pointer values. The shared memory allocator
+ * must be specified.
+ */
+ infoP->segbase = (long *) ShmemBase;
+ infoP->alloc = ShmemAlloc;
+ infoP->max_size = max_size;
+ hash_flags |= HASH_SHARED_MEM;
+
+ /* look it up in the binding table */
+ location =
+ ShmemInitStruct(name,my_log2(max_size) + sizeof(HHDR),&found);
+
+ /* binding table is corrupted. Let someone else give the
+ * error message since they have more information
+ */
+ if (location == NULL) {
+ return(0);
+ }
+
+ /* it already exists, attach to it rather than allocate and
+ * initialize new space
+ */
+ if (found) {
+ hash_flags |= HASH_ATTACH;
+ }
+
+ /* these structures were allocated or bound in ShmemInitStruct */
+ /* control information and parameters */
+ infoP->hctl = (long *) location;
+ /* directory for hash lookup */
+ infoP->dir = (long *) (location + sizeof(HHDR));
+
+ return(hash_create(init_size, infoP, hash_flags));;
+}
+
+/*
+ * ShmemPIDLookup -- lookup process data structure using process id
+ *
+ * Returns: TRUE if no error. locationPtr is initialized if PID is
+ * found in the binding table.
+ *
+ * NOTES:
+ * only information about success or failure is the value of
+ * locationPtr.
+ */
+bool
+ShmemPIDLookup(int pid, SHMEM_OFFSET* locationPtr)
+{
+ BindingEnt * result,item;
+ bool found;
+
+ Assert (BindingTable);
+ memset(item.key, 0, BTABLE_KEYSIZE);
+ sprintf(item.key,"PID %d",pid);
+
+ SpinAcquire(BindingLock);
+ result = (BindingEnt *)
+ hash_search(BindingTable,(char *) &item, HASH_ENTER, &found);
+
+ if (! result) {
+
+ SpinRelease(BindingLock);
+ elog(WARN,"ShmemInitPID: BindingTable corrupted");
+ return(FALSE);
+
+ }
+
+ if (found) {
+ *locationPtr = result->location;
+ } else {
+ result->location = *locationPtr;
+ }
+
+ SpinRelease(BindingLock);
+ return (TRUE);
+}
+
+/*
+ * ShmemPIDDestroy -- destroy binding table entry for process
+ * using process id
+ *
+ * Returns: offset of the process struct in shared memory or
+ * INVALID_OFFSET if not found.
+ *
+ * Side Effect: removes the entry from the binding table
+ */
+SHMEM_OFFSET
+ShmemPIDDestroy(int pid)
+{
+ BindingEnt * result,item;
+ bool found;
+ SHMEM_OFFSET location;
+
+ Assert(BindingTable);
+
+ memset(item.key, 0, BTABLE_KEYSIZE);
+ sprintf(item.key,"PID %d",pid);
+
+ SpinAcquire(BindingLock);
+ result = (BindingEnt *)
+ hash_search(BindingTable,(char *) &item, HASH_REMOVE, &found);
+
+ if (found)
+ location = result->location;
+ SpinRelease(BindingLock);
+
+ if (! result) {
+
+ elog(WARN,"ShmemPIDDestroy: PID table corrupted");
+ return(INVALID_OFFSET);
+
+ }
+
+ if (found)
+ return (location);
+ else {
+ return(INVALID_OFFSET);
+ }
+}
+
+/*
+ * ShmemInitStruct -- Create/attach to a structure in shared
+ * memory.
+ *
+ * This is called during initialization to find or allocate
+ * a data structure in shared memory. If no other processes
+ * have created the structure, this routine allocates space
+ * for it. If it exists already, a pointer to the existing
+ * table is returned.
+ *
+ * Returns: real pointer to the object. FoundPtr is TRUE if
+ * the object is already in the binding table (hence, already
+ * initialized).
+ */
+long *
+ShmemInitStruct(char *name, unsigned long size, bool *foundPtr)
+{
+ BindingEnt * result,item;
+ long * structPtr;
+
+ strncpy(item.key,name,BTABLE_KEYSIZE);
+ item.location = BAD_LOCATION;
+
+ SpinAcquire(BindingLock);
+
+ if (! BindingTable) {
+ /* Assert() is a macro now. substitutes inside quotes. */
+ char *strname = "BindingTable";
+
+ /* If the binding table doesnt exist, we fake it.
+ *
+ * If we are creating the first binding table, then let
+ * shmemalloc() allocate the space for a new HTAB. Otherwise,
+ * find the old one and return that. Notice that the
+ * BindingLock is held until the binding table has been completely
+ * initialized.
+ */
+ Assert (! strcmp(name,strname)) ;
+ if (ShmemBootstrap) {
+ /* in POSTMASTER/Single process */
+
+ *foundPtr = FALSE;
+ return((long *)ShmemAlloc(size));
+
+ } else {
+ Assert (ShmemBindingTabOffset);
+
+ *foundPtr = TRUE;
+ return((long *)MAKE_PTR(*ShmemBindingTabOffset));
+ }
+
+
+ } else {
+ /* look it up in the bindint table */
+ result = (BindingEnt *)
+ hash_search(BindingTable,(char *) &item,HASH_ENTER, foundPtr);
+ }
+
+ if (! result) {
+
+ SpinRelease(BindingLock);
+
+ elog(WARN,"ShmemInitStruct: Binding Table corrupted");
+ return(NULL);
+
+ } else if (*foundPtr) {
+ /*
+ * Structure is in the binding table so someone else has allocated
+ * it already. The size better be the same as the size we are
+ * trying to initialize to or there is a name conflict (or worse).
+ */
+ if (result->size != size) {
+ SpinRelease(BindingLock);
+
+ elog(NOTICE,"ShmemInitStruct: BindingTable entry size is wrong");
+ /* let caller print its message too */
+ return(NULL);
+ }
+ structPtr = (long *)MAKE_PTR(result->location);
+ } else {
+
+ /* It isn't in the table yet. allocate and initialize it */
+ structPtr = ShmemAlloc((long)size);
+ if (! structPtr) {
+ /* out of memory */
+ Assert (BindingTable);
+ (void) hash_search(BindingTable,(char *) &item,HASH_REMOVE, foundPtr);
+ SpinRelease(BindingLock);
+ *foundPtr = FALSE;
+
+ elog(NOTICE,"ShmemInitStruct: cannot allocate '%s'",
+ name);
+ return(NULL);
+ }
+ result->size = size;
+ result->location = MAKE_OFFSET(structPtr);
+ }
+ Assert (ShmemIsValid((unsigned long)structPtr));
+
+ SpinRelease(BindingLock);
+ return(structPtr);
+}
+
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * shmqueue.c--
+ * shared memory linked lists
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmqueue.c,v 1.1.1.1 1996/07/09 06:21:54 scrappy Exp $
+ *
+ * NOTES
+ *
+ * Package for managing doubly-linked lists in shared memory.
+ * The only tricky thing is that SHM_QUEUE will usually be a field
+ * in a larger record. SHMQueueGetFirst has to return a pointer
+ * to the record itself instead of a pointer to the SHMQueue field
+ * of the record. It takes an extra pointer and does some extra
+ * pointer arithmetic to do this correctly.
+ *
+ * NOTE: These are set up so they can be turned into macros some day.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* for sprintf() */
+#include "postgres.h"
+#include "storage/shmem.h" /* where the declarations go */
+#include "utils/elog.h"
+
+/*#define SHMQUEUE_DEBUG*/
+#ifdef SHMQUEUE_DEBUG
+#define SHMQUEUE_DEBUG_DEL /* deletions */
+#define SHMQUEUE_DEBUG_HD /* head inserts */
+#define SHMQUEUE_DEBUG_TL /* tail inserts */
+#define SHMQUEUE_DEBUG_ELOG NOTICE
+#endif /* SHMQUEUE_DEBUG */
+
+/*
+ * ShmemQueueInit -- make the head of a new queue point
+ * to itself
+ */
+void
+SHMQueueInit(SHM_QUEUE *queue)
+{
+ Assert(SHM_PTR_VALID(queue));
+ (queue)->prev = (queue)->next = MAKE_OFFSET(queue);
+}
+
+/*
+ * SHMQueueIsDetached -- TRUE if element is not currently
+ * in a queue.
+ */
+bool
+SHMQueueIsDetached(SHM_QUEUE *queue)
+{
+ Assert(SHM_PTR_VALID(queue));
+ return ((queue)->prev == INVALID_OFFSET);
+}
+
+/*
+ * SHMQueueElemInit -- clear an element's links
+ */
+void
+SHMQueueElemInit(SHM_QUEUE *queue)
+{
+ Assert(SHM_PTR_VALID(queue));
+ (queue)->prev = (queue)->next = INVALID_OFFSET;
+}
+
+/*
+ * SHMQueueDelete -- remove an element from the queue and
+ * close the links
+ */
+void
+SHMQueueDelete(SHM_QUEUE *queue)
+{
+ SHM_QUEUE *nextElem = (SHM_QUEUE *) MAKE_PTR((queue)->next);
+ SHM_QUEUE *prevElem = (SHM_QUEUE *) MAKE_PTR((queue)->prev);
+
+ Assert(SHM_PTR_VALID(queue));
+ Assert(SHM_PTR_VALID(nextElem));
+ Assert(SHM_PTR_VALID(prevElem));
+
+#ifdef SHMQUEUE_DEBUG_DEL
+ dumpQ(queue, "in SHMQueueDelete: begin");
+#endif /* SHMQUEUE_DEBUG_DEL */
+
+ prevElem->next = (queue)->next;
+ nextElem->prev = (queue)->prev;
+
+#ifdef SHMQUEUE_DEBUG_DEL
+ dumpQ((SHM_QUEUE *)MAKE_PTR(queue->prev), "in SHMQueueDelete: end");
+#endif /* SHMQUEUE_DEBUG_DEL */
+}
+
+#ifdef SHMQUEUE_DEBUG
+void
+dumpQ(SHM_QUEUE *q, char *s)
+{
+ char elem[16];
+ char buf[1024];
+ SHM_QUEUE *start = q;
+ int count = 0;
+
+ sprintf(buf, "q prevs: %x", MAKE_OFFSET(q));
+ q = (SHM_QUEUE *)MAKE_PTR(q->prev);
+ while (q != start)
+ {
+ sprintf(elem, "--->%x", MAKE_OFFSET(q));
+ strcat(buf, elem);
+ q = (SHM_QUEUE *)MAKE_PTR(q->prev);
+ if (q->prev == MAKE_OFFSET(q))
+ break;
+ if (count++ > 40)
+ {
+ strcat(buf, "BAD PREV QUEUE!!");
+ break;
+ }
+ }
+ sprintf(elem, "--->%x", MAKE_OFFSET(q));
+ strcat(buf, elem);
+ elog(SHMQUEUE_DEBUG_ELOG, "%s: %s", s, buf);
+
+ sprintf(buf, "q nexts: %x", MAKE_OFFSET(q));
+ count = 0;
+ q = (SHM_QUEUE *)MAKE_PTR(q->next);
+ while (q != start)
+ {
+ sprintf(elem, "--->%x", MAKE_OFFSET(q));
+ strcat(buf, elem);
+ q = (SHM_QUEUE *)MAKE_PTR(q->next);
+ if (q->next == MAKE_OFFSET(q))
+ break;
+ if (count++ > 10)
+ {
+ strcat(buf, "BAD NEXT QUEUE!!");
+ break;
+ }
+ }
+ sprintf(elem, "--->%x", MAKE_OFFSET(q));
+ strcat(buf, elem);
+ elog(SHMQUEUE_DEBUG_ELOG, "%s: %s", s, buf);
+}
+#endif /* SHMQUEUE_DEBUG */
+
+/*
+ * SHMQueueInsertHD -- put elem in queue between the queue head
+ * and its "prev" element.
+ */
+void
+SHMQueueInsertHD(SHM_QUEUE *queue, SHM_QUEUE *elem)
+{
+ SHM_QUEUE *prevPtr = (SHM_QUEUE *) MAKE_PTR((queue)->prev);
+ SHMEM_OFFSET elemOffset = MAKE_OFFSET(elem);
+
+ Assert(SHM_PTR_VALID(queue));
+ Assert(SHM_PTR_VALID(elem));
+
+#ifdef SHMQUEUE_DEBUG_HD
+ dumpQ(queue, "in SHMQueueInsertHD: begin");
+#endif /* SHMQUEUE_DEBUG_HD */
+
+ (elem)->next = prevPtr->next;
+ (elem)->prev = queue->prev;
+ (queue)->prev = elemOffset;
+ prevPtr->next = elemOffset;
+
+#ifdef SHMQUEUE_DEBUG_HD
+ dumpQ(queue, "in SHMQueueInsertHD: end");
+#endif /* SHMQUEUE_DEBUG_HD */
+}
+
+void
+SHMQueueInsertTL(SHM_QUEUE *queue, SHM_QUEUE *elem)
+{
+ SHM_QUEUE *nextPtr = (SHM_QUEUE *) MAKE_PTR((queue)->next);
+ SHMEM_OFFSET elemOffset = MAKE_OFFSET(elem);
+
+ Assert(SHM_PTR_VALID(queue));
+ Assert(SHM_PTR_VALID(elem));
+
+#ifdef SHMQUEUE_DEBUG_TL
+ dumpQ(queue, "in SHMQueueInsertTL: begin");
+#endif /* SHMQUEUE_DEBUG_TL */
+
+ (elem)->prev = nextPtr->prev;
+ (elem)->next = queue->next;
+ (queue)->next = elemOffset;
+ nextPtr->prev = elemOffset;
+
+#ifdef SHMQUEUE_DEBUG_TL
+ dumpQ(queue, "in SHMQueueInsertTL: end");
+#endif /* SHMQUEUE_DEBUG_TL */
+}
+
+/*
+ * SHMQueueFirst -- Get the first element from a queue
+ *
+ * First element is queue->next. If SHMQueue is part of
+ * a larger structure, we want to return a pointer to the
+ * whole structure rather than a pointer to its SHMQueue field.
+ * I.E. struct {
+ * int stuff;
+ * SHMQueue elem;
+ * } ELEMType;
+ * when this element is in a queue (queue->next) is struct.elem.
+ * nextQueue allows us to calculate the offset of the SHMQueue
+ * field in the structure.
+ *
+ * call to SHMQueueFirst should take these parameters:
+ *
+ * &(queueHead),&firstElem,&(firstElem->next)
+ *
+ * Note that firstElem may well be uninitialized. if firstElem
+ * is initially K, &(firstElem->next) will be K+ the offset to
+ * next.
+ */
+void
+SHMQueueFirst(SHM_QUEUE *queue, Pointer *nextPtrPtr, SHM_QUEUE *nextQueue)
+{
+ SHM_QUEUE *elemPtr = (SHM_QUEUE *) MAKE_PTR((queue)->next);
+
+ Assert(SHM_PTR_VALID(queue));
+ *nextPtrPtr = (Pointer) (((unsigned long) *nextPtrPtr) +
+ ((unsigned long) elemPtr) - ((unsigned long) nextQueue));
+
+ /*
+ nextPtrPtr a ptr to a structure linked in the queue
+ nextQueue is the SHMQueue field of the structure
+ *nextPtrPtr - nextQueue is 0 minus the offset of the queue
+ field n the record
+ elemPtr + (*nextPtrPtr - nexQueue) is the start of the
+ structure containing elemPtr.
+ */
+}
+
+/*
+ * SHMQueueEmpty -- TRUE if queue head is only element, FALSE otherwise
+ */
+bool
+SHMQueueEmpty(SHM_QUEUE *queue)
+{
+ Assert(SHM_PTR_VALID(queue));
+
+ if (queue->prev == MAKE_OFFSET(queue))
+ {
+ Assert(queue->next = MAKE_OFFSET(queue));
+ return(TRUE);
+ }
+ return(FALSE);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * sinval.c--
+ * POSTGRES shared cache invalidation communication code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/sinval.c,v 1.1.1.1 1996/07/09 06:21:54 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/* #define INVALIDDEBUG 1 */
+
+#include "postgres.h"
+
+#include "storage/sinval.h"
+#include "storage/sinvaladt.h"
+#include "storage/spin.h"
+#include "utils/elog.h"
+
+extern SISeg *shmInvalBuffer;/* the shared buffer segment, set by*/
+ /* SISegmentAttach() */
+extern BackendId MyBackendId;
+extern BackendTag MyBackendTag;
+
+SPINLOCK SInvalLock = (SPINLOCK) NULL;
+
+/****************************************************************************/
+/* CreateSharedInvalidationState(key) Create a buffer segment */
+/* */
+/* should be called only by the POSTMASTER */
+/****************************************************************************/
+void
+CreateSharedInvalidationState(IPCKey key)
+{
+ int status;
+
+ /* REMOVED
+ SISyncKill(IPCKeyGetSIBufferMemorySemaphoreKey(key));
+ SISyncInit(IPCKeyGetSIBufferMemorySemaphoreKey(key));
+ */
+
+ /* SInvalLock gets set in spin.c, during spinlock init */
+ status = SISegmentInit(true, IPCKeyGetSIBufferMemoryBlock(key));
+
+ if (status == -1) {
+ elog(FATAL, "CreateSharedInvalidationState: failed segment init");
+ }
+}
+/****************************************************************************/
+/* AttachSharedInvalidationState(key) Attach a buffer segment */
+/* */
+/* should be called only by the POSTMASTER */
+/****************************************************************************/
+void
+AttachSharedInvalidationState(IPCKey key)
+{
+ int status;
+
+ if (key == PrivateIPCKey) {
+ CreateSharedInvalidationState(key);
+ return;
+ }
+ /* SInvalLock gets set in spin.c, during spinlock init */
+ status = SISegmentInit(false, IPCKeyGetSIBufferMemoryBlock(key));
+
+ if (status == -1) {
+ elog(FATAL, "AttachSharedInvalidationState: failed segment init");
+ }
+}
+
+void
+InitSharedInvalidationState()
+{
+ SpinAcquire(SInvalLock);
+ if (!SIBackendInit(shmInvalBuffer))
+ {
+ SpinRelease(SInvalLock);
+ elog(FATAL, "Backend cache invalidation initialization failed");
+ }
+ SpinRelease(SInvalLock);
+}
+
+/*
+ * RegisterSharedInvalid --
+ * Returns a new local cache invalidation state containing a new entry.
+ *
+ * Note:
+ * Assumes hash index is valid.
+ * Assumes item pointer is valid.
+ */
+/****************************************************************************/
+/* RegisterSharedInvalid(cacheId, hashIndex, pointer) */
+/* */
+/* register a message in the buffer */
+/* should be called by a backend */
+/****************************************************************************/
+void
+RegisterSharedInvalid(int cacheId, /* XXX */
+ Index hashIndex,
+ ItemPointer pointer)
+{
+ SharedInvalidData newInvalid;
+
+ /*
+ * This code has been hacked to accept two types of messages. This might
+ * be treated more generally in the future.
+ *
+ * (1)
+ * cacheId= system cache id
+ * hashIndex= system cache hash index for a (possibly) cached tuple
+ * pointer= pointer of (possibly) cached tuple
+ *
+ * (2)
+ * cacheId= special non-syscache id
+ * hashIndex= object id contained in (possibly) cached relation descriptor
+ * pointer= null
+ */
+
+ newInvalid.cacheId = cacheId;
+ newInvalid.hashIndex = hashIndex;
+
+ if (ItemPointerIsValid(pointer)) {
+ ItemPointerCopy(pointer, &newInvalid.pointerData);
+ } else {
+ ItemPointerSetInvalid(&newInvalid.pointerData);
+ }
+
+ SpinAcquire(SInvalLock);
+ if (!SISetDataEntry(shmInvalBuffer, &newInvalid)) {
+ /* buffer full */
+ /* release a message, mark process cache states to be invalid */
+ SISetProcStateInvalid(shmInvalBuffer);
+
+ if (!SIDelDataEntry(shmInvalBuffer)) {
+ /* inconsistent buffer state -- shd never happen */
+ SpinRelease(SInvalLock);
+ elog(FATAL, "RegisterSharedInvalid: inconsistent buffer state");
+ }
+
+ /* write again */
+ (void) SISetDataEntry(shmInvalBuffer, &newInvalid);
+ }
+ SpinRelease(SInvalLock);
+}
+
+/*
+ * InvalidateSharedInvalid --
+ * Processes all entries in a shared cache invalidation state.
+ */
+/****************************************************************************/
+/* InvalidateSharedInvalid(invalFunction, resetFunction) */
+/* */
+/* invalidate a message in the buffer (read and clean up) */
+/* should be called by a backend */
+/****************************************************************************/
+void
+InvalidateSharedInvalid(void (*invalFunction)(),
+ void (*resetFunction)())
+{
+ SpinAcquire(SInvalLock);
+ SIReadEntryData(shmInvalBuffer, MyBackendId,
+ invalFunction, resetFunction);
+
+ SIDelExpiredDataEntries(shmInvalBuffer);
+ SpinRelease(SInvalLock);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * sinvaladt.c--
+ * POSTGRES shared cache invalidation segment definitions.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/sinvaladt.c,v 1.1.1.1 1996/07/09 06:21:54 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "storage/ipc.h"
+#include "storage/sinvaladt.h"
+#include "storage/lmgr.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+/* ----------------
+ * global variable notes
+ *
+ * SharedInvalidationSemaphore
+ *
+ * shmInvalBuffer
+ * the shared buffer segment, set by SISegmentAttach()
+ *
+ * MyBackendId
+ * might be removed later, used only for
+ * debugging in debug routines (end of file)
+ *
+ * SIDbId
+ * identification of buffer (disappears)
+ *
+ * SIRelId \
+ * SIDummyOid \ identification of buffer
+ * SIXidData /
+ * SIXid /
+ *
+ * XXX This file really needs to be cleaned up. We switched to using
+ * spinlocks to protect critical sections (as opposed to using fake
+ * relations and going through the lock manager) and some of the old
+ * cruft was 'ifdef'ed out, while other parts (now unused) are still
+ * compiled into the system. -mer 5/24/92
+ * ----------------
+ */
+#ifdef HAS_TEST_AND_SET
+int SharedInvalidationLockId;
+#else
+IpcSemaphoreId SharedInvalidationSemaphore;
+#endif
+
+SISeg *shmInvalBuffer;
+extern BackendId MyBackendId;
+
+static void CleanupInvalidationState(int status, SISeg *segInOutP);
+static BackendId SIAssignBackendId(SISeg *segInOutP, BackendTag backendTag);
+static int SIGetNumEntries(SISeg *segP);
+
+/************************************************************************/
+/* SISetActiveProcess(segP, backendId) set the backend status active */
+/* should be called only by the postmaster when creating a backend */
+/************************************************************************/
+/* XXX I suspect that the segP parameter is extraneous. -hirohama */
+static void
+SISetActiveProcess(SISeg *segInOutP, BackendId backendId)
+{
+ /* mark all messages as read */
+
+ /* Assert(segP->procState[backendId - 1].tag == MyBackendTag); */
+
+ segInOutP->procState[backendId - 1].resetState = false;
+ segInOutP->procState[backendId - 1].limit = SIGetNumEntries(segInOutP);
+}
+
+/****************************************************************************/
+/* SIBackendInit() initializes a backend to operate on the buffer */
+/****************************************************************************/
+int
+SIBackendInit(SISeg *segInOutP)
+{
+ LRelId LtCreateRelId();
+ TransactionId LMITransactionIdCopy();
+
+ Assert(MyBackendTag > 0);
+
+ MyBackendId = SIAssignBackendId(segInOutP, MyBackendTag);
+ if (MyBackendId == InvalidBackendTag)
+ return 0;
+
+#ifdef INVALIDDEBUG
+ elog(DEBUG, "SIBackendInit: backend tag %d; backend id %d.",
+ MyBackendTag, MyBackendId);
+#endif /* INVALIDDEBUG */
+
+ SISetActiveProcess(segInOutP, MyBackendId);
+ on_exitpg(CleanupInvalidationState, (caddr_t)segInOutP);
+ return 1;
+}
+
+/* ----------------
+ * SIAssignBackendId
+ * ----------------
+ */
+static BackendId
+SIAssignBackendId(SISeg *segInOutP, BackendTag backendTag)
+{
+ Index index;
+ ProcState *stateP;
+
+ stateP = NULL;
+
+ for (index = 0; index < MaxBackendId; index += 1) {
+ if (segInOutP->procState[index].tag == InvalidBackendTag ||
+ segInOutP->procState[index].tag == backendTag)
+ {
+ stateP = &segInOutP->procState[index];
+ break;
+ }
+
+ if (!PointerIsValid(stateP) ||
+ (segInOutP->procState[index].resetState &&
+ (!stateP->resetState ||
+ stateP->tag < backendTag)) ||
+ (!stateP->resetState &&
+ (segInOutP->procState[index].limit <
+ stateP->limit ||
+ stateP->tag < backendTag)))
+ {
+ stateP = &segInOutP->procState[index];
+ }
+ }
+
+ /* verify that all "procState" entries checked for matching tags */
+
+ for (index += 1; index < MaxBackendId; index += 1) {
+ if (segInOutP->procState[index].tag == backendTag) {
+ elog (FATAL, "SIAssignBackendId: tag %d found twice",
+ backendTag);
+ }
+ }
+
+ if (stateP->tag != InvalidBackendTag) {
+ if (stateP->tag == backendTag) {
+ elog(NOTICE, "SIAssignBackendId: reusing tag %d",
+ backendTag);
+ } else {
+ elog(NOTICE,
+ "SIAssignBackendId: discarding tag %d",
+ stateP->tag);
+ return InvalidBackendTag;
+ }
+ }
+
+ stateP->tag = backendTag;
+
+ return (1 + stateP - &segInOutP->procState[0]);
+}
+
+
+/************************************************************************/
+/* The following function should be called only by the postmaster !! */
+/************************************************************************/
+
+/************************************************************************/
+/* SISetDeadProcess(segP, backendId) set the backend status DEAD */
+/* should be called only by the postmaster when a backend died */
+/************************************************************************/
+static void
+SISetDeadProcess(SISeg *segP, int backendId)
+{
+ /* XXX call me.... */
+
+ segP->procState[backendId - 1].resetState = false;
+ segP->procState[backendId - 1].limit = -1;
+ segP->procState[backendId - 1].tag = InvalidBackendTag;
+}
+
+/*
+ * CleanupInvalidationState --
+ * Note:
+ * This is a temporary hack. ExitBackend should call this instead
+ * of exit (via on_exitpg).
+ */
+static void
+CleanupInvalidationState(int status, /* XXX */
+ SISeg *segInOutP) /* XXX style */
+{
+ Assert(PointerIsValid(segInOutP));
+
+ SISetDeadProcess(segInOutP, MyBackendId);
+}
+
+
+/************************************************************************/
+/* SIComputeSize() - retuns the size of a buffer segment */
+/************************************************************************/
+static SISegOffsets *
+SIComputeSize(int *segSize)
+{
+ int A, B, a, b, totalSize;
+ SISegOffsets *oP;
+
+ A = 0;
+ a = SizeSISeg; /* offset to first data entry */
+ b = SizeOfOneSISegEntry * MAXNUMMESSAGES;
+ B = A + a + b;
+ totalSize = B - A;
+ *segSize = totalSize;
+
+ oP = (SISegOffsets *) palloc(sizeof(SISegOffsets));
+ oP->startSegment = A;
+ oP->offsetToFirstEntry = a; /* relatiove to A */
+ oP->offsetToEndOfSegemnt = totalSize; /* relative to A */
+ return(oP);
+}
+
+
+/************************************************************************/
+/* SISetStartEntrySection(segP, offset) - sets the offset */
+/************************************************************************/
+static void
+SISetStartEntrySection(SISeg *segP, Offset offset)
+{
+ segP->startEntrySection = offset;
+}
+
+/************************************************************************/
+/* SIGetStartEntrySection(segP) - returnss the offset */
+/************************************************************************/
+static Offset
+SIGetStartEntrySection(SISeg *segP)
+{
+ return(segP->startEntrySection);
+}
+
+
+/************************************************************************/
+/* SISetEndEntrySection(segP, offset) - sets the offset */
+/************************************************************************/
+static void
+SISetEndEntrySection(SISeg *segP, Offset offset)
+{
+ segP->endEntrySection = offset;
+}
+
+/************************************************************************/
+/* SISetEndEntryChain(segP, offset) - sets the offset */
+/************************************************************************/
+static void
+SISetEndEntryChain(SISeg *segP, Offset offset)
+{
+ segP->endEntryChain = offset;
+}
+
+/************************************************************************/
+/* SIGetEndEntryChain(segP) - returnss the offset */
+/************************************************************************/
+static Offset
+SIGetEndEntryChain(SISeg *segP)
+{
+ return(segP->endEntryChain);
+}
+
+/************************************************************************/
+/* SISetStartEntryChain(segP, offset) - sets the offset */
+/************************************************************************/
+static void
+SISetStartEntryChain(SISeg *segP, Offset offset)
+{
+ segP->startEntryChain = offset;
+}
+
+/************************************************************************/
+/* SIGetStartEntryChain(segP) - returns the offset */
+/************************************************************************/
+static Offset
+SIGetStartEntryChain(SISeg *segP)
+{
+ return(segP->startEntryChain);
+}
+
+/************************************************************************/
+/* SISetNumEntries(segP, num) sets the current nuber of entries */
+/************************************************************************/
+static bool
+SISetNumEntries(SISeg *segP, int num)
+{
+ if ( num <= MAXNUMMESSAGES) {
+ segP->numEntries = num;
+ return(true);
+ } else {
+ return(false); /* table full */
+ }
+}
+
+/************************************************************************/
+/* SIGetNumEntries(segP) - returns the current nuber of entries */
+/************************************************************************/
+static int
+SIGetNumEntries(SISeg *segP)
+{
+ return(segP->numEntries);
+}
+
+
+/************************************************************************/
+/* SISetMaxNumEntries(segP, num) sets the maximal number of entries */
+/************************************************************************/
+static bool
+SISetMaxNumEntries(SISeg *segP, int num)
+{
+ if ( num <= MAXNUMMESSAGES) {
+ segP->maxNumEntries = num;
+ return(true);
+ } else {
+ return(false); /* wrong number */
+ }
+}
+
+
+/************************************************************************/
+/* SIGetProcStateLimit(segP, i) returns the limit of read messages */
+/************************************************************************/
+static int
+SIGetProcStateLimit(SISeg *segP, int i)
+{
+ return(segP->procState[i].limit);
+}
+
+/************************************************************************/
+/* SIIncNumEntries(segP, num) increments the current nuber of entries */
+/************************************************************************/
+static bool
+SIIncNumEntries(SISeg *segP, int num)
+{
+ if ((segP->numEntries + num) <= MAXNUMMESSAGES) {
+ segP->numEntries = segP->numEntries + num;
+ return(true);
+ } else {
+ return(false); /* table full */
+ }
+}
+
+/************************************************************************/
+/* SIDecNumEntries(segP, num) decrements the current nuber of entries */
+/************************************************************************/
+static bool
+SIDecNumEntries(SISeg *segP, int num)
+{
+ if ((segP->numEntries - num) >= 0) {
+ segP->numEntries = segP->numEntries - num;
+ return(true);
+ } else {
+ return(false); /* not enough entries in table */
+ }
+}
+
+/************************************************************************/
+/* SISetStartFreeSpace(segP, offset) - sets the offset */
+/************************************************************************/
+static void
+SISetStartFreeSpace(SISeg *segP, Offset offset)
+{
+ segP->startFreeSpace = offset;
+}
+
+/************************************************************************/
+/* SIGetStartFreeSpace(segP) - returns the offset */
+/************************************************************************/
+static Offset
+SIGetStartFreeSpace(SISeg *segP)
+{
+ return(segP->startFreeSpace);
+}
+
+
+
+/************************************************************************/
+/* SIGetFirstDataEntry(segP) returns first data entry */
+/************************************************************************/
+static SISegEntry *
+SIGetFirstDataEntry(SISeg *segP)
+{
+ SISegEntry *eP;
+ Offset startChain;
+
+ startChain = SIGetStartEntryChain(segP);
+
+ if (startChain == InvalidOffset)
+ return(NULL);
+
+ eP = (SISegEntry *) ((Pointer) segP +
+ SIGetStartEntrySection(segP) +
+ startChain );
+ return(eP);
+}
+
+
+/************************************************************************/
+/* SIGetLastDataEntry(segP) returns last data entry in the chain */
+/************************************************************************/
+static SISegEntry *
+SIGetLastDataEntry(SISeg *segP)
+{
+ SISegEntry *eP;
+ Offset endChain;
+
+ endChain = SIGetEndEntryChain(segP);
+
+ if (endChain == InvalidOffset)
+ return(NULL);
+
+ eP = (SISegEntry *) ((Pointer) segP +
+ SIGetStartEntrySection(segP) +
+ endChain );
+ return(eP);
+}
+
+/************************************************************************/
+/* SIGetNextDataEntry(segP, offset) returns next data entry */
+/************************************************************************/
+static SISegEntry *
+SIGetNextDataEntry(SISeg *segP, Offset offset)
+{
+ SISegEntry *eP;
+
+ if (offset == InvalidOffset)
+ return(NULL);
+
+ eP = (SISegEntry *) ((Pointer) segP +
+ SIGetStartEntrySection(segP) +
+ offset);
+ return(eP);
+}
+
+
+/************************************************************************/
+/* SIGetNthDataEntry(segP, n) returns the n-th data entry in chain */
+/************************************************************************/
+static SISegEntry *
+SIGetNthDataEntry(SISeg *segP,
+ int n) /* must range from 1 to MaxMessages */
+{
+ SISegEntry *eP;
+ int i;
+
+ if (n <= 0) return(NULL);
+
+ eP = SIGetFirstDataEntry(segP);
+ for (i = 1; i < n; i++) {
+ /* skip one and get the next */
+ eP = SIGetNextDataEntry(segP, eP->next);
+ }
+
+ return(eP);
+}
+
+/************************************************************************/
+/* SIEntryOffset(segP, entryP) returns the offset for an pointer */
+/************************************************************************/
+static Offset
+SIEntryOffset(SISeg *segP, SISegEntry *entryP)
+{
+ /* relative to B !! */
+ return ((Offset) ((Pointer) entryP -
+ (Pointer) segP -
+ SIGetStartEntrySection(segP) ));
+}
+
+
+/************************************************************************/
+/* SISetDataEntry(segP, data) - sets a message in the segemnt */
+/************************************************************************/
+bool
+SISetDataEntry(SISeg *segP, SharedInvalidData *data)
+{
+ Offset offsetToNewData;
+ SISegEntry *eP, *lastP;
+ bool SISegFull();
+ Offset SIEntryOffset();
+ Offset SIGetStartFreeSpace();
+ SISegEntry *SIGetFirstDataEntry();
+ SISegEntry *SIGetNextDataEntry();
+ SISegEntry *SIGetLastDataEntry();
+
+ if (!SIIncNumEntries(segP, 1))
+ return(false); /* no space */
+
+ /* get a free entry */
+ offsetToNewData = SIGetStartFreeSpace(segP);
+ eP = SIGetNextDataEntry(segP, offsetToNewData); /* it's a free one */
+ SISetStartFreeSpace(segP, eP->next);
+ /* fill it up */
+ eP->entryData = *data;
+ eP->isfree = false;
+ eP->next = InvalidOffset;
+
+ /* handle insertion point at the end of the chain !!*/
+ lastP = SIGetLastDataEntry(segP);
+ if (lastP == NULL) {
+ /* there is no chain, insert the first entry */
+ SISetStartEntryChain(segP, SIEntryOffset(segP, eP));
+ } else {
+ /* there is a last entry in the chain */
+ lastP->next = SIEntryOffset(segP, eP);
+ }
+ SISetEndEntryChain(segP, SIEntryOffset(segP, eP));
+ return(true);
+}
+
+
+/************************************************************************/
+/* SIDecProcLimit(segP, num) decrements all process limits */
+/************************************************************************/
+static void
+SIDecProcLimit(SISeg *segP, int num)
+{
+ int i;
+ for (i=0; i < MaxBackendId; i++) {
+ /* decrement only, if there is a limit > 0 */
+ if (segP->procState[i].limit > 0) {
+ segP->procState[i].limit = segP->procState[i].limit - num;
+ if (segP->procState[i].limit < 0) {
+ /* limit was not high enough, reset to zero */
+ /* negative means it's a dead backend */
+ segP->procState[i].limit = 0;
+ }
+ }
+ }
+}
+
+
+/************************************************************************/
+/* SIDelDataEntry(segP) - free the FIRST entry */
+/************************************************************************/
+bool
+SIDelDataEntry(SISeg *segP)
+{
+ SISegEntry *e1P;
+ SISegEntry *SIGetFirstDataEntry();
+
+ if (!SIDecNumEntries(segP, 1)) {
+ /* no entries in buffer */
+ return(false);
+ }
+
+ e1P = SIGetFirstDataEntry(segP);
+ SISetStartEntryChain(segP, e1P->next);
+ if (SIGetStartEntryChain(segP) == InvalidOffset) {
+ /* it was the last entry */
+ SISetEndEntryChain(segP, InvalidOffset);
+ }
+ /* free the entry */
+ e1P->isfree = true;
+ e1P->next = SIGetStartFreeSpace(segP);
+ SISetStartFreeSpace(segP, SIEntryOffset(segP, e1P));
+ SIDecProcLimit(segP, 1);
+ return(true);
+}
+
+
+
+/************************************************************************/
+/* SISetProcStateInvalid(segP) checks and marks a backends state as */
+/* invalid */
+/************************************************************************/
+void
+SISetProcStateInvalid(SISeg *segP)
+{
+ int i;
+
+ for (i=0; i < MaxBackendId; i++) {
+ if (segP->procState[i].limit == 0) {
+ /* backend i didn't read any message */
+ segP->procState[i].resetState = true;
+ /*XXX signal backend that it has to reset its internal cache ? */
+ }
+ }
+}
+
+/************************************************************************/
+/* SIReadEntryData(segP, backendId, function) */
+/* - marks messages to be read by id */
+/* and executes function */
+/************************************************************************/
+void
+SIReadEntryData(SISeg *segP,
+ int backendId,
+ void (*invalFunction)(),
+ void (*resetFunction)())
+{
+ int i = 0;
+ SISegEntry *data;
+
+ Assert(segP->procState[backendId - 1].tag == MyBackendTag);
+
+ if (!segP->procState[backendId - 1].resetState) {
+ /* invalidate data, but only those, you have not seen yet !!*/
+ /* therefore skip read messages */
+ data = SIGetNthDataEntry(segP,
+ SIGetProcStateLimit(segP, backendId - 1) + 1);
+ while (data != NULL) {
+ i++;
+ segP->procState[backendId - 1].limit++; /* one more message read */
+ invalFunction(data->entryData.cacheId,
+ data->entryData.hashIndex,
+ &data->entryData.pointerData);
+ data = SIGetNextDataEntry(segP, data->next);
+ }
+ /* SIDelExpiredDataEntries(segP); */
+ } else {
+ /*backend must not read messages, its own state has to be reset */
+ elog(NOTICE, "SIMarkEntryData: cache state reset");
+ resetFunction(); /* XXXX call it here, parameters? */
+
+ /* new valid state--mark all messages "read" */
+ segP->procState[backendId - 1].resetState = false;
+ segP->procState[backendId - 1].limit = SIGetNumEntries(segP);
+ }
+ /* check whether we can remove dead messages */
+ if (i > MAXNUMMESSAGES) {
+ elog(FATAL, "SIReadEntryData: Invalid segment state");
+ }
+}
+
+/************************************************************************/
+/* SIDelExpiredDataEntries (segP) - removes irrelevant messages */
+/************************************************************************/
+void
+SIDelExpiredDataEntries(SISeg *segP)
+{
+ int min, i, h;
+
+ min = 9999999;
+ for (i = 0; i < MaxBackendId; i++) {
+ h = SIGetProcStateLimit(segP, i);
+ if (h >= 0) { /* backend active */
+ if (h < min ) min = h;
+ }
+ }
+ if (min != 9999999) {
+ /* we can remove min messages */
+ for (i = 1; i <= min; i++) {
+ /* this adjusts also the state limits!*/
+ if (!SIDelDataEntry(segP)) {
+ elog(FATAL, "SIDelExpiredDataEntries: Invalid segment state");
+ }
+ }
+ }
+}
+
+
+
+/************************************************************************/
+/* SISegInit(segP) - initializes the segment */
+/************************************************************************/
+static void
+SISegInit(SISeg *segP)
+{
+ SISegOffsets *oP;
+ int segSize, i;
+ SISegEntry *eP;
+
+ oP = SIComputeSize(&segSize);
+ /* set sempahore ids in the segment */
+ /* XXX */
+ SISetStartEntrySection(segP, oP->offsetToFirstEntry);
+ SISetEndEntrySection(segP, oP->offsetToEndOfSegemnt);
+ SISetStartFreeSpace(segP, 0);
+ SISetStartEntryChain(segP, InvalidOffset);
+ SISetEndEntryChain(segP, InvalidOffset);
+ (void) SISetNumEntries(segP, 0);
+ (void) SISetMaxNumEntries(segP, MAXNUMMESSAGES);
+ for (i = 0; i < MaxBackendId; i++) {
+ segP->procState[i].limit = -1; /* no backend active !!*/
+ segP->procState[i].resetState = false;
+ segP->procState[i].tag = InvalidBackendTag;
+ }
+ /* construct a chain of free entries */
+ for (i = 1; i < MAXNUMMESSAGES; i++) {
+ eP = (SISegEntry *) ((Pointer) segP +
+ SIGetStartEntrySection(segP) +
+ (i - 1) * sizeof(SISegEntry));
+ eP->isfree = true;
+ eP->next = i * sizeof(SISegEntry); /* relative to B */
+ }
+ /* handle the last free entry separate */
+ eP = (SISegEntry *) ((Pointer) segP +
+ SIGetStartEntrySection(segP) +
+ (MAXNUMMESSAGES - 1) * sizeof(SISegEntry));
+ eP->isfree = true;
+ eP->next = InvalidOffset; /* it's the end of the chain !! */
+ /*
+ * Be tidy
+ */
+ pfree(oP);
+
+}
+
+
+
+/************************************************************************/
+/* SISegmentKill(key) - kill any segment */
+/************************************************************************/
+static void
+SISegmentKill(int key) /* the corresponding key for the segment */
+{
+ IpcMemoryKill(key);
+}
+
+
+/************************************************************************/
+/* SISegmentGet(key, size) - get a shared segment of size */
+/* returns a segment id */
+/************************************************************************/
+static IpcMemoryId
+SISegmentGet(int key, /* the corresponding key for the segment */
+ int size, /* size of segment in bytes */
+ bool create)
+{
+ IpcMemoryId shmid;
+
+ if (create) {
+ shmid = IpcMemoryCreate(key, size, IPCProtection);
+ } else {
+ shmid = IpcMemoryIdGet(key, size);
+ }
+ return(shmid);
+}
+
+/************************************************************************/
+/* SISegmentAttach(shmid) - attach a shared segment with id shmid */
+/************************************************************************/
+static void
+SISegmentAttach(IpcMemoryId shmid)
+{
+ shmInvalBuffer = (struct SISeg *) IpcMemoryAttach(shmid);
+ if (shmInvalBuffer == IpcMemAttachFailed) {
+ /* XXX use validity function */
+ elog(NOTICE, "SISegmentAttach: Could not attach segment");
+ elog(FATAL, "SISegmentAttach: %m");
+ }
+}
+
+
+/************************************************************************/
+/* SISegmentInit(killExistingSegment, key) initialize segment */
+/************************************************************************/
+int
+SISegmentInit(bool killExistingSegment, IPCKey key)
+{
+ SISegOffsets *oP;
+ int segSize;
+ IpcMemoryId shmId;
+ bool create;
+
+ if (killExistingSegment) {
+ /* Kill existing segment */
+ /* set semaphore */
+ SISegmentKill(key);
+
+ /* Get a shared segment */
+
+ oP = SIComputeSize(&segSize);
+ /*
+ * Be tidy
+ */
+ pfree(oP);
+
+ create = true;
+ shmId = SISegmentGet(key,segSize, create);
+ if (shmId < 0) {
+ perror("SISegmentGet: failed");
+ return(-1); /* an error */
+ }
+
+ /* Attach the shared cache invalidation segment */
+ /* sets the global variable shmInvalBuffer */
+ SISegmentAttach(shmId);
+
+ /* Init shared memory table */
+ SISegInit(shmInvalBuffer);
+ } else {
+ /* use an existing segment */
+ create = false;
+ shmId = SISegmentGet(key, 0, create);
+ if (shmId < 0) {
+ perror("SISegmentGet: getting an existent segment failed");
+ return(-1); /* an error */
+ }
+ /* Attach the shared cache invalidation segment */
+ SISegmentAttach(shmId);
+ }
+ return(1);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * spin.c--
+ * routines for managing spin locks
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/Attic/spin.c,v 1.1.1.1 1996/07/09 06:21:55 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ * POSTGRES has two kinds of locks: semaphores (which put the
+ * process to sleep) and spinlocks (which are supposed to be
+ * short term locks). Currently both are implemented as SysV
+ * semaphores, but presumably this can change if we move to
+ * a machine with a test-and-set (TAS) instruction. Its probably
+ * a good idea to think about (and allocate) short term and long
+ * term semaphores separately anyway.
+ *
+ * NOTE: These routines are not supposed to be widely used in Postgres.
+ * They are preserved solely for the purpose of porting Mark Sullivan's
+ * buffer manager to Postgres.
+ */
+#include
+#include "postgres.h"
+#include "storage/ipc.h"
+#include "storage/shmem.h"
+#include "storage/spin.h"
+#include "storage/proc.h"
+#include "utils/elog.h"
+
+/* globals used in this file */
+IpcSemaphoreId SpinLockId;
+
+#ifdef HAS_TEST_AND_SET
+/* real spin lock implementations */
+
+bool
+CreateSpinlocks(IPCKey key)
+{
+ /* the spin lock shared memory must have been created by now */
+ return(TRUE);
+}
+
+bool
+AttachSpinLocks(IPCKey key)
+{
+ /* the spin lock shared memory must have been attached by now */
+ return(TRUE);
+}
+
+bool
+InitSpinLocks(int init, IPCKey key)
+{
+ extern SPINLOCK ShmemLock;
+ extern SPINLOCK BindingLock;
+ extern SPINLOCK BufMgrLock;
+ extern SPINLOCK LockMgrLock;
+ extern SPINLOCK ProcStructLock;
+ extern SPINLOCK SInvalLock;
+ extern SPINLOCK OidGenLockId;
+
+#ifdef MAIN_MEMORY
+ extern SPINLOCK MMCacheLock;
+#endif /* SONY_JUKEBOX */
+
+ /* These six spinlocks have fixed location is shmem */
+ ShmemLock = (SPINLOCK) SHMEMLOCKID;
+ BindingLock = (SPINLOCK) BINDINGLOCKID;
+ BufMgrLock = (SPINLOCK) BUFMGRLOCKID;
+ LockMgrLock = (SPINLOCK) LOCKMGRLOCKID;
+ ProcStructLock = (SPINLOCK) PROCSTRUCTLOCKID;
+ SInvalLock = (SPINLOCK) SINVALLOCKID;
+ OidGenLockId = (SPINLOCK) OIDGENLOCKID;
+
+#ifdef MAIN_MEMORY
+ MMCacheLock = (SPINLOCK) MMCACHELOCKID;
+#endif /* MAIN_MEMORY */
+
+ return(TRUE);
+}
+
+void
+SpinAcquire(SPINLOCK lock)
+{
+ ExclusiveLock(lock);
+ PROC_INCR_SLOCK(lock);
+}
+
+void
+SpinRelease(SPINLOCK lock)
+{
+ PROC_DECR_SLOCK(lock);
+ ExclusiveUnlock(lock);
+}
+
+bool
+SpinIsLocked(SPINLOCK lock)
+{
+ return(!LockIsFree(lock));
+}
+
+#else /* HAS_TEST_AND_SET */
+/* Spinlocks are implemented using SysV semaphores */
+
+
+/*
+ * SpinAcquire -- try to grab a spinlock
+ *
+ * FAILS if the semaphore is corrupted.
+ */
+void
+SpinAcquire(SPINLOCK lock)
+{
+ IpcSemaphoreLock(SpinLockId, lock, IpcExclusiveLock);
+ PROC_INCR_SLOCK(lock);
+}
+
+/*
+ * SpinRelease -- release a spin lock
+ *
+ * FAILS if the semaphore is corrupted
+ */
+void
+SpinRelease(SPINLOCK lock)
+{
+ Assert(SpinIsLocked(lock))
+ PROC_DECR_SLOCK(lock);
+ IpcSemaphoreUnlock(SpinLockId, lock, IpcExclusiveLock);
+}
+
+bool
+SpinIsLocked(SPINLOCK lock)
+{
+ int semval;
+
+ semval = IpcSemaphoreGetValue(SpinLockId, lock);
+ return(semval < IpcSemaphoreDefaultStartValue);
+}
+
+/*
+ * CreateSpinlocks -- Create a sysV semaphore array for
+ * the spinlocks
+ *
+ */
+bool
+CreateSpinlocks(IPCKey key)
+{
+
+ int status;
+ IpcSemaphoreId semid;
+ semid = IpcSemaphoreCreate(key, MAX_SPINS, IPCProtection,
+ IpcSemaphoreDefaultStartValue, 1, &status);
+ if (status == IpcSemIdExist) {
+ IpcSemaphoreKill(key);
+ elog(NOTICE,"Destroying old spinlock semaphore");
+ semid = IpcSemaphoreCreate(key, MAX_SPINS, IPCProtection,
+ IpcSemaphoreDefaultStartValue, 1, &status);
+ }
+
+ if (semid >= 0) {
+ SpinLockId = semid;
+ return(TRUE);
+ }
+ /* cannot create spinlocks */
+ elog(FATAL,"CreateSpinlocks: cannot create spin locks");
+ return(FALSE);
+}
+
+/*
+ * Attach to existing spinlock set
+ */
+bool
+AttachSpinLocks(IPCKey key)
+{
+ IpcSemaphoreId id;
+
+ id = semget (key, MAX_SPINS, 0);
+ if (id < 0) {
+ if (errno == EEXIST) {
+ /* key is the name of someone else's semaphore */
+ elog (FATAL,"AttachSpinlocks: SPIN_KEY belongs to someone else");
+ }
+ /* cannot create spinlocks */
+ elog(FATAL,"AttachSpinlocks: cannot create spin locks");
+ return(FALSE);
+ }
+ SpinLockId = id;
+ return(TRUE);
+}
+
+/*
+ * InitSpinLocks -- Spinlock bootstrapping
+ *
+ * We need several spinlocks for bootstrapping:
+ * BindingLock (for the shmem binding table) and
+ * ShmemLock (for the shmem allocator), BufMgrLock (for buffer
+ * pool exclusive access), LockMgrLock (for the lock table), and
+ * ProcStructLock (a spin lock for the shared process structure).
+ * If there's a Sony WORM drive attached, we also have a spinlock
+ * (SJCacheLock) for it. Same story for the main memory storage mgr.
+ *
+ */
+bool
+InitSpinLocks(int init, IPCKey key)
+{
+ extern SPINLOCK ShmemLock;
+ extern SPINLOCK BindingLock;
+ extern SPINLOCK BufMgrLock;
+ extern SPINLOCK LockMgrLock;
+ extern SPINLOCK ProcStructLock;
+ extern SPINLOCK SInvalLock;
+ extern SPINLOCK OidGenLockId;
+
+#ifdef MAIN_MEMORY
+ extern SPINLOCK MMCacheLock;
+#endif /* MAIN_MEMORY */
+
+ if (!init || key != IPC_PRIVATE) {
+ /* if bootstrap and key is IPC_PRIVATE, it means that we are running
+ * backend by itself. no need to attach spinlocks
+ */
+ if (! AttachSpinLocks(key)) {
+ elog(FATAL,"InitSpinLocks: couldnt attach spin locks");
+ return(FALSE);
+ }
+ }
+
+ /* These five (or six) spinlocks have fixed location is shmem */
+ ShmemLock = (SPINLOCK) SHMEMLOCKID;
+ BindingLock = (SPINLOCK) BINDINGLOCKID;
+ BufMgrLock = (SPINLOCK) BUFMGRLOCKID;
+ LockMgrLock = (SPINLOCK) LOCKMGRLOCKID;
+ ProcStructLock = (SPINLOCK) PROCSTRUCTLOCKID;
+ SInvalLock = (SPINLOCK) SINVALLOCKID;
+ OidGenLockId = (SPINLOCK) OIDGENLOCKID;
+
+#ifdef MAIN_MEMORY
+ MMCacheLock = (SPINLOCK) MMCACHELOCKID;
+#endif /* MAIN_MEMORY */
+
+ return(TRUE);
+}
+#endif /* HAS_TEST_AND_SET */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * item.h--
+ * POSTGRES disk item definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: item.h,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ITEM_H
+#define ITEM_H
+
+#include "c.h"
+
+typedef Pointer Item;
+
+#endif /* ITEM_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * itemid.h--
+ * Standard POSTGRES buffer page item identifier definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: itemid.h,v 1.1.1.1 1996/07/09 06:21:52 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ITEMID_H
+#define ITEMID_H
+
+typedef uint16 ItemOffset;
+typedef uint16 ItemLength;
+
+typedef bits16 ItemIdFlags;
+
+
+
+typedef struct ItemIdData { /* line pointers */
+ unsigned lp_off:13, /* offset to find tup */
+ /* can be reduced by 2 if necc. */
+ lp_flags:6, /* flags on tuple */
+ lp_len:13; /* length of tuple */
+} ItemIdData;
+
+typedef struct ItemIdData *ItemId;
+
+#ifndef LP_USED
+#define LP_USED 0x01 /* this line pointer is being used */
+#endif
+
+/* ----------------
+ * support macros
+ * ----------------
+ */
+/*
+ * ItemIdGetLength
+ */
+#define ItemIdGetLength(itemId) \
+ ((itemId)->lp_len)
+
+/*
+ * ItemIdGetOffset
+ */
+#define ItemIdGetOffset(itemId) \
+ ((itemId)->lp_off)
+
+/*
+ * ItemIdGetFlags
+ */
+#define ItemIdGetFlags(itemId) \
+ ((itemId)->lp_flags)
+
+/*
+ * ItemIdIsValid --
+ * True iff disk item identifier is valid.
+ */
+#define ItemIdIsValid(itemId) PointerIsValid(itemId)
+
+/*
+ * ItemIdIsUsed --
+ * True iff disk item identifier is in use.
+ *
+ * Note:
+ * Assumes disk item identifier is valid.
+ */
+#define ItemIdIsUsed(itemId) \
+ (AssertMacro(ItemIdIsValid(itemId)) ? \
+ (bool) (((itemId)->lp_flags & LP_USED) != 0) : false)
+
+#endif /* ITEMID_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * itempos.h--
+ * Standard POSTGRES buffer page long item subposition definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: itempos.h,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ITEMPOS_H
+#define ITEMPOS_H
+
+#include "c.h"
+#include "storage/buf.h"
+#include "storage/itemid.h"
+
+typedef struct ItemSubpositionData {
+ Buffer op_db;
+ ItemId op_lpp;
+ char *op_cp; /* XXX */
+ uint32 op_len;
+} ItemSubpositionData;
+
+typedef ItemSubpositionData *ItemSubposition;
+
+/*
+ * PNOBREAK(OBJP, LEN)
+ * struct objpos *OBJP;
+ * unsigned LEN;
+ */
+#define PNOBREAK(OBJP, LEN) ((OBJP)->op_len >= LEN)
+
+/*
+ * PSKIP(OBJP, LEN)
+ * struct objpos *OBJP;
+ * unsigned LEN;
+ */
+#define PSKIP(OBJP, LEN)\
+ { (OBJP)->op_cp += (LEN); (OBJP)->op_len -= (LEN); }
+
+#endif /* ITEMPOS_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * itemptr.h--
+ * POSTGRES disk item pointer definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: itemptr.h,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ITEMPTR_H
+#define ITEMPTR_H
+
+#include "c.h"
+#include "storage/block.h"
+#include "storage/off.h"
+#include "storage/itemid.h"
+
+/*
+ * ItemPointer:
+ *
+ * this is a pointer to an item on another disk page in the same file.
+ * blkid tells us which block, posid tells us which entry in the linp
+ * (ItemIdData) array we want.
+ */
+typedef struct ItemPointerData {
+ BlockIdData ip_blkid;
+ OffsetNumber ip_posid;
+} ItemPointerData;
+
+typedef ItemPointerData *ItemPointer;
+
+/* ----------------
+ * support macros
+ * ----------------
+ */
+
+/*
+ * ItemPointerIsValid --
+ * True iff the disk item pointer is not NULL.
+ */
+#define ItemPointerIsValid(pointer) \
+ ((bool) (PointerIsValid(pointer) && ((pointer)->ip_posid != 0)))
+
+/*
+ * ItemPointerGetBlockNumber --
+ * Returns the block number of a disk item pointer.
+ */
+#define ItemPointerGetBlockNumber(pointer) \
+ (AssertMacro(ItemPointerIsValid(pointer)) ? \
+ BlockIdGetBlockNumber(&(pointer)->ip_blkid) : (BlockNumber) 0)
+
+/*
+ * ItemPointerGetOffsetNumber --
+ * Returns the offset number of a disk item pointer.
+ */
+#define ItemPointerGetOffsetNumber(pointer) \
+ (AssertMacro(ItemPointerIsValid(pointer)) ? \
+ (pointer)->ip_posid : \
+ InvalidOffsetNumber)
+
+/*
+ * ItemPointerSet --
+ * Sets a disk item pointer to the specified block and offset.
+ */
+#define ItemPointerSet(pointer, blockNumber, offNum) \
+ Assert(PointerIsValid(pointer)); \
+ BlockIdSet(&((pointer)->ip_blkid), blockNumber); \
+ (pointer)->ip_posid = offNum
+
+/*
+ * ItemPointerSetBlockNumber --
+ * Sets a disk item pointer to the specified block.
+ */
+#define ItemPointerSetBlockNumber(pointer, blockNumber) \
+ Assert(PointerIsValid(pointer)); \
+ BlockIdSet(&((pointer)->ip_blkid), blockNumber)
+
+/*
+ * ItemPointerSetOffsetNumber --
+ * Sets a disk item pointer to the specified offset.
+ */
+#define ItemPointerSetOffsetNumber(pointer, offsetNumber) \
+ AssertMacro(PointerIsValid(pointer)); \
+ (pointer)->ip_posid = (offsetNumber)
+
+/*
+ * ItemPointerCopy --
+ * Copies the contents of one disk item pointer to another.
+ */
+#define ItemPointerCopy(fromPointer, toPointer) \
+ Assert(PointerIsValid(toPointer)); \
+ Assert(PointerIsValid(fromPointer)); \
+ *(toPointer) = *(fromPointer)
+
+/*
+ * ItemPointerSetInvalid --
+ * Sets a disk item pointer to be invalid.
+ */
+#define ItemPointerSetInvalid(pointer) \
+ Assert(PointerIsValid(pointer)); \
+ BlockIdSet(&((pointer)->ip_blkid), InvalidBlockNumber); \
+ (pointer)->ip_posid = InvalidOffsetNumber
+
+/* ----------------
+ * externs
+ * ----------------
+ */
+
+extern bool ItemPointerEquals(ItemPointer pointer1, ItemPointer pointer2);
+
+#endif /* ITEMPTR_H */
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * large_object.h--
+ * file of info for Postgres large objects. POSTGRES 4.2 supports
+ * zillions of large objects (internal, external, jaquith, inversion).
+ * Now we only support inversion.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: large_object.h,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef LARGE_OBJECT_H
+#define LARGE_OBJECT_H
+
+#include "c.h"
+#include "utils/rel.h"
+#include "access/relscan.h"
+
+/*
+ * This structure will eventually have lots more stuff associated with it.
+ */
+typedef struct LargeObjectDesc
+{
+ Relation heap_r; /* heap relation */
+ Relation index_r; /* index relation on seqno attribute */
+ IndexScanDesc iscan; /* index scan we're using */
+ TupleDesc hdesc; /* heap relation tuple desc */
+ TupleDesc idesc; /* index relation tuple desc */
+ uint32 lowbyte; /* low byte on the current page */
+ uint32 highbyte; /* high byte on the current page */
+ uint32 offset; /* current seek pointer */
+ ItemPointerData htid; /* tid of current heap tuple */
+
+#define IFS_RDLOCK (1 << 0)
+#define IFS_WRLOCK (1 << 1)
+#define IFS_ATEOF (1 << 2)
+
+ u_long flags; /* locking info, etc */
+} LargeObjectDesc;
+
+/*
+ * Function definitions...
+ */
+
+/* inversion stuff in inv_api.c */
+extern LargeObjectDesc *inv_create(int flags);
+extern LargeObjectDesc *inv_open(Oid lobjId, int flags);
+extern void inv_close(LargeObjectDesc *obj_desc);
+extern int inv_destroy(Oid lobjId);
+extern int inv_stat(LargeObjectDesc *obj_desc, struct pgstat *stbuf);
+extern int inv_seek(LargeObjectDesc *obj_desc, int offset, int whence);
+extern int inv_tell(LargeObjectDesc *obj_desc);
+extern int inv_read(LargeObjectDesc *obj_desc, char *buf, int nbytes);
+extern int inv_write(LargeObjectDesc *obj_desc, char *buf, int nbytes);
+
+#endif /* LARGE_OBJECT_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for storage/large_object
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/storage/large_object/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:55 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= inv_api.c
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * inv_api.c--
+ * routines for manipulating inversion fs large objects. This file
+ * contains the user-level large object application interface routines.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.1.1.1 1996/07/09 06:21:55 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* for sprintf() */
+#include
+#include "c.h"
+#include "libpq/libpq-fs.h"
+#include "access/genam.h"
+#include "access/heapam.h"
+#include "access/relscan.h"
+#include "access/tupdesc.h"
+#include "access/xact.h"
+#include "access/nbtree.h"
+#include "access/tupdesc.h"
+#include "catalog/index.h" /* for index_create() */
+#include "catalog/catalog.h" /* for newoid() */
+#include "catalog/pg_am.h" /* for BTREE_AM_OID */
+#include "catalog/pg_opclass.h" /* for INT4_OPS_OID */
+#include "catalog/pg_proc.h" /* for INT4GE_PROC_OID */
+#include "storage/itemptr.h"
+#include "storage/bufpage.h"
+#include "storage/bufmgr.h"
+#include "utils/rel.h"
+#include "utils/palloc.h"
+#include "storage/large_object.h"
+#include "utils/elog.h"
+#include "utils/syscache.h"
+#include "utils/builtins.h" /* for namestrcpy() */
+#include "catalog/heap.h"
+#include "nodes/pg_list.h"
+
+/*
+ * Warning, Will Robinson... In order to pack data into an inversion
+ * file as densely as possible, we violate the class abstraction here.
+ * When we're appending a new tuple to the end of the table, we check
+ * the last page to see how much data we can put on it. If it's more
+ * than IMINBLK, we write enough to fill the page. This limits external
+ * fragmentation. In no case can we write more than IMAXBLK, since
+ * the 8K postgres page size less overhead leaves only this much space
+ * for data.
+ */
+
+#define IFREESPC(p) (PageGetFreeSpace(p) - sizeof(HeapTupleData) - sizeof(struct varlena) - sizeof(int32))
+#define IMAXBLK 8092
+#define IMINBLK 512
+
+/* non-export function prototypes */
+static HeapTuple inv_fetchtup();
+static HeapTuple inv_newtuple();
+static int inv_wrnew(LargeObjectDesc *obj_desc, char *buf, int nbytes);
+static int inv_wrold(LargeObjectDesc *obj_desc, char *dbuf, int nbytes,
+ HeapTuple htup, Buffer buffer);
+static void inv_indextup(LargeObjectDesc *obj_desc, HeapTuple htup);
+static int _inv_getsize(Relation hreln, TupleDesc hdesc, Relation ireln);
+
+/*
+ * inv_create -- create a new large object.
+ *
+ * Arguments:
+ * flags -- storage manager to use, archive mode, etc.
+ *
+ * Returns:
+ * large object descriptor, appropriately filled in.
+ */
+LargeObjectDesc *
+inv_create(int flags)
+{
+ int file_oid;
+ LargeObjectDesc *retval;
+ Relation r;
+ Relation indr;
+ int smgr;
+ char archchar;
+ TupleDesc tupdesc;
+ AttrNumber attNums[1];
+ Oid classObjectId[1];
+ char objname[NAMEDATALEN];
+ char indname[NAMEDATALEN];
+
+ /* parse flags */
+ smgr = flags & INV_SMGRMASK;
+ if (flags & INV_ARCHIVE)
+ archchar = 'h';
+ else
+ archchar = 'n';
+
+ /* add one here since the pg_class tuple created
+ will have the next oid and we want to have the relation name
+ to correspond to the tuple OID */
+ file_oid = newoid()+1;
+
+ /* come up with some table names */
+ sprintf(objname, "Xinv%d", file_oid);
+ sprintf(indname, "Xinx%d", file_oid);
+
+ if (SearchSysCacheTuple(RELNAME, PointerGetDatum(objname),
+ 0,0,0) != NULL) {
+ elog(WARN,
+ "internal error: %s already exists -- cannot create large obj",
+ objname);
+ }
+ if (SearchSysCacheTuple(RELNAME, PointerGetDatum(indname),
+ 0,0,0) != NULL) {
+ elog(WARN,
+ "internal error: %s already exists -- cannot create large obj",
+ indname);
+ }
+
+ /* this is pretty painful... want a tuple descriptor */
+ tupdesc = CreateTemplateTupleDesc(2);
+ (void) TupleDescInitEntry(tupdesc, (AttrNumber) 1,
+ "olastbye",
+ "int4",
+ 0, false);
+ (void) TupleDescInitEntry(tupdesc, (AttrNumber) 2,
+ "odata",
+ "bytea",
+ 0, false);
+ /*
+ * First create the table to hold the inversion large object. It
+ * will be located on whatever storage manager the user requested.
+ */
+
+ (void) heap_create(objname,
+ objname,
+ (int) archchar, smgr,
+ tupdesc);
+
+ /* make the relation visible in this transaction */
+ CommandCounterIncrement();
+ r = heap_openr(objname);
+
+ if (!RelationIsValid(r)) {
+ elog(WARN, "cannot create large object on %s under inversion",
+ smgrout(smgr));
+ }
+
+ /*
+ * Now create a btree index on the relation's olastbyte attribute to
+ * make seeks go faster. The hardwired constants are embarassing
+ * to me, and are symptomatic of the pressure under which this code
+ * was written.
+ *
+ * ok, mao, let's put in some symbolic constants - jolly
+ */
+
+ attNums[0] = 1;
+ classObjectId[0] = INT4_OPS_OID;
+ index_create(objname, indname, NULL, BTREE_AM_OID,
+ 1, &attNums[0], &classObjectId[0],
+ 0, (Datum) NULL, NULL);
+
+ /* make the index visible in this transaction */
+ CommandCounterIncrement();
+ indr = index_openr(indname);
+
+ if (!RelationIsValid(indr)) {
+ elog(WARN, "cannot create index for large obj on %s under inversion",
+ smgrout(smgr));
+ }
+
+ retval = (LargeObjectDesc *) palloc(sizeof(LargeObjectDesc));
+
+ retval->heap_r = r;
+ retval->index_r = indr;
+ retval->iscan = (IndexScanDesc) NULL;
+ retval->hdesc = RelationGetTupleDescriptor(r);
+ retval->idesc = RelationGetTupleDescriptor(indr);
+ retval->offset = retval->lowbyte =
+ retval->highbyte = 0;
+ ItemPointerSetInvalid(&(retval->htid));
+
+ if (flags & INV_WRITE) {
+ RelationSetLockForWrite(r);
+ retval->flags = IFS_WRLOCK|IFS_RDLOCK;
+ } else if (flags & INV_READ) {
+ RelationSetLockForRead(r);
+ retval->flags = IFS_RDLOCK;
+ }
+ retval->flags |= IFS_ATEOF;
+
+ return(retval);
+}
+
+LargeObjectDesc *
+inv_open(Oid lobjId, int flags)
+{
+ LargeObjectDesc *retval;
+ Relation r;
+ char *indname;
+ Relation indrel;
+
+ r = heap_open(lobjId);
+
+ if (!RelationIsValid(r))
+ return ((LargeObjectDesc *) NULL);
+
+ indname = pstrdup((r->rd_rel->relname).data);
+
+ /*
+ * hack hack hack... we know that the fourth character of the relation
+ * name is a 'v', and that the fourth character of the index name is an
+ * 'x', and that they're otherwise identical.
+ */
+ indname[3] = 'x';
+ indrel = index_openr(indname);
+
+ if (!RelationIsValid(indrel))
+ return ((LargeObjectDesc *) NULL);
+
+ retval = (LargeObjectDesc *) palloc(sizeof(LargeObjectDesc));
+
+ retval->heap_r = r;
+ retval->index_r = indrel;
+ retval->iscan = (IndexScanDesc) NULL;
+ retval->hdesc = RelationGetTupleDescriptor(r);
+ retval->idesc = RelationGetTupleDescriptor(indrel);
+ retval->offset = retval->lowbyte = retval->highbyte = 0;
+ ItemPointerSetInvalid(&(retval->htid));
+
+ if (flags & INV_WRITE) {
+ RelationSetLockForWrite(r);
+ retval->flags = IFS_WRLOCK|IFS_RDLOCK;
+ } else if (flags & INV_READ) {
+ RelationSetLockForRead(r);
+ retval->flags = IFS_RDLOCK;
+ }
+
+ return(retval);
+}
+
+/*
+ * Closes an existing large object descriptor.
+ */
+void
+inv_close(LargeObjectDesc *obj_desc)
+{
+ Assert(PointerIsValid(obj_desc));
+
+ if (obj_desc->iscan != (IndexScanDesc) NULL)
+ index_endscan(obj_desc->iscan);
+
+ heap_close(obj_desc->heap_r);
+ index_close(obj_desc->index_r);
+
+ pfree(obj_desc);
+}
+
+/*
+ * Destroys an existing large object, and frees its associated pointers.
+ *
+ * returns -1 if failed
+ */
+int
+inv_destroy(Oid lobjId)
+{
+ Relation r;
+
+ r = (Relation) RelationIdGetRelation(lobjId);
+ if (!RelationIsValid(r) || r->rd_rel->relkind == RELKIND_INDEX)
+ return -1;
+
+ heap_destroy(r->rd_rel->relname.data);
+ return 1;
+}
+
+/*
+ * inv_stat() -- do a stat on an inversion file.
+ *
+ * For the time being, this is an insanely expensive operation. In
+ * order to find the size of the file, we seek to the last block in
+ * it and compute the size from that. We scan pg_class to determine
+ * the file's owner and create time. We don't maintain mod time or
+ * access time, yet.
+ *
+ * These fields aren't stored in a table anywhere because they're
+ * updated so frequently, and postgres only appends tuples at the
+ * end of relations. Once clustering works, we should fix this.
+ */
+int
+inv_stat(LargeObjectDesc *obj_desc, struct pgstat *stbuf)
+{
+ Assert(PointerIsValid(obj_desc));
+ Assert(stbuf != NULL);
+
+ /* need read lock for stat */
+ if (!(obj_desc->flags & IFS_RDLOCK)) {
+ RelationSetLockForRead(obj_desc->heap_r);
+ obj_desc->flags |= IFS_RDLOCK;
+ }
+
+ stbuf->st_ino = obj_desc->heap_r->rd_id;
+#if 1
+ stbuf->st_mode = (S_IFREG | 0666); /* IFREG|rw-rw-rw- */
+#else
+ stbuf->st_mode = 100666; /* IFREG|rw-rw-rw- */
+#endif
+ stbuf->st_size = _inv_getsize(obj_desc->heap_r,
+ obj_desc->hdesc,
+ obj_desc->index_r);
+
+ stbuf->st_uid = obj_desc->heap_r->rd_rel->relowner;
+
+ /* we have no good way of computing access times right now */
+ stbuf->st_atime_s = stbuf->st_mtime_s = stbuf->st_ctime_s = 0;
+
+ return (0);
+}
+
+int
+inv_seek(LargeObjectDesc *obj_desc, int offset, int whence)
+{
+ int oldOffset;
+ Datum d;
+ ScanKeyData skey;
+
+ Assert(PointerIsValid(obj_desc));
+
+ if (whence == SEEK_CUR) {
+ offset += obj_desc->offset; /* calculate absolute position */
+ return (inv_seek(obj_desc, offset, SEEK_SET));
+ }
+
+ /*
+ * if you seek past the end (offset > 0) I have
+ * no clue what happens :-( B.L. 9/1/93
+ */
+ if (whence == SEEK_END) {
+ /* need read lock for getsize */
+ if (!(obj_desc->flags & IFS_RDLOCK)) {
+ RelationSetLockForRead(obj_desc->heap_r);
+ obj_desc->flags |= IFS_RDLOCK;
+ }
+ offset += _inv_getsize(obj_desc->heap_r,
+ obj_desc->hdesc,
+ obj_desc->index_r );
+ return (inv_seek(obj_desc, offset, SEEK_SET));
+ }
+
+ /*
+ * Whenever we do a seek, we turn off the EOF flag bit to force
+ * ourselves to check for real on the next read.
+ */
+
+ obj_desc->flags &= ~IFS_ATEOF;
+ oldOffset = obj_desc->offset;
+ obj_desc->offset = offset;
+
+ /* try to avoid doing any work, if we can manage it */
+ if (offset >= obj_desc->lowbyte
+ && offset <= obj_desc->highbyte
+ && oldOffset <= obj_desc->highbyte
+ && obj_desc->iscan != (IndexScanDesc) NULL)
+ return (offset);
+
+ /*
+ * To do a seek on an inversion file, we start an index scan that
+ * will bring us to the right place. Each tuple in an inversion file
+ * stores the offset of the last byte that appears on it, and we have
+ * an index on this.
+ */
+
+
+ /* right now, just assume that the operation is SEEK_SET */
+ if (obj_desc->iscan != (IndexScanDesc) NULL) {
+ d = Int32GetDatum(offset);
+ btmovescan(obj_desc->iscan, d);
+ } else {
+
+ ScanKeyEntryInitialize(&skey, 0x0, 1, INT4GE_PROC_OID,
+ Int32GetDatum(offset));
+
+ obj_desc->iscan = index_beginscan(obj_desc->index_r,
+ (bool) 0, (uint16) 1,
+ &skey);
+ }
+
+ return (offset);
+}
+
+int
+inv_tell(LargeObjectDesc *obj_desc)
+{
+ Assert(PointerIsValid(obj_desc));
+
+ return (obj_desc->offset);
+}
+
+int
+inv_read(LargeObjectDesc *obj_desc, char *buf, int nbytes)
+{
+ HeapTuple htup;
+ Buffer b;
+ int nread;
+ int off;
+ int ncopy;
+ Datum d;
+ struct varlena *fsblock;
+ bool isNull;
+
+ Assert(PointerIsValid(obj_desc));
+ Assert(buf != NULL);
+
+ /* if we're already at EOF, we don't need to do any work here */
+ if (obj_desc->flags & IFS_ATEOF)
+ return (0);
+
+ /* make sure we obey two-phase locking */
+ if (!(obj_desc->flags & IFS_RDLOCK)) {
+ RelationSetLockForRead(obj_desc->heap_r);
+ obj_desc->flags |= IFS_RDLOCK;
+ }
+
+ nread = 0;
+
+ /* fetch a block at a time */
+ while (nread < nbytes) {
+
+ /* fetch an inversion file system block */
+ htup = inv_fetchtup(obj_desc, &b);
+
+ if (!HeapTupleIsValid(htup)) {
+ obj_desc->flags |= IFS_ATEOF;
+ break;
+ }
+
+ /* copy the data from this block into the buffer */
+ d = (Datum) heap_getattr(htup, b, 2, obj_desc->hdesc, &isNull);
+ fsblock = (struct varlena *) DatumGetPointer(d);
+
+ off = obj_desc->offset - obj_desc->lowbyte;
+ ncopy = obj_desc->highbyte - obj_desc->offset + 1;
+ if (ncopy > (nbytes - nread))
+ ncopy = (nbytes - nread);
+ memmove(buf, &(fsblock->vl_dat[off]), ncopy);
+
+ /* be a good citizen */
+ ReleaseBuffer(b);
+
+ /* move pointers past the amount we just read */
+ buf += ncopy;
+ nread += ncopy;
+ obj_desc->offset += ncopy;
+ }
+
+ /* that's it */
+ return (nread);
+}
+
+int
+inv_write(LargeObjectDesc *obj_desc, char *buf, int nbytes)
+{
+ HeapTuple htup;
+ Buffer b;
+ int nwritten;
+ int tuplen;
+
+ Assert(PointerIsValid(obj_desc));
+ Assert(buf != NULL);
+
+ /*
+ * Make sure we obey two-phase locking. A write lock entitles you
+ * to read the relation, as well.
+ */
+
+ if (!(obj_desc->flags & IFS_WRLOCK)) {
+ RelationSetLockForRead(obj_desc->heap_r);
+ obj_desc->flags |= (IFS_WRLOCK|IFS_RDLOCK);
+ }
+
+ nwritten = 0;
+
+ /* write a block at a time */
+ while (nwritten < nbytes) {
+
+ /*
+ * Fetch the current inversion file system block. If the
+ * class storing the inversion file is empty, we don't want
+ * to do an index lookup, since index lookups choke on empty
+ * files (should be fixed someday).
+ */
+
+ if ((obj_desc->flags & IFS_ATEOF)
+ || obj_desc->heap_r->rd_nblocks == 0)
+ htup = (HeapTuple) NULL;
+ else
+ htup = inv_fetchtup(obj_desc, &b);
+
+ /* either append or replace a block, as required */
+ if (!HeapTupleIsValid(htup)) {
+ tuplen = inv_wrnew(obj_desc, buf, nbytes - nwritten);
+ } else {
+ if (obj_desc->offset > obj_desc->highbyte)
+ tuplen = inv_wrnew(obj_desc, buf, nbytes - nwritten);
+ else
+ tuplen = inv_wrold(obj_desc, buf, nbytes - nwritten, htup, b);
+ }
+
+ /* move pointers past the amount we just wrote */
+ buf += tuplen;
+ nwritten += tuplen;
+ obj_desc->offset += tuplen;
+ }
+
+ /* that's it */
+ return (nwritten);
+}
+
+/*
+ * inv_fetchtup -- Fetch an inversion file system block.
+ *
+ * This routine finds the file system block containing the offset
+ * recorded in the obj_desc structure. Later, we need to think about
+ * the effects of non-functional updates (can you rewrite the same
+ * block twice in a single transaction?), but for now, we won't bother.
+ *
+ * Parameters:
+ * obj_desc -- the object descriptor.
+ * bufP -- pointer to a buffer in the buffer cache; caller
+ * must free this.
+ *
+ * Returns:
+ * A heap tuple containing the desired block, or NULL if no
+ * such tuple exists.
+ */
+static HeapTuple
+inv_fetchtup(LargeObjectDesc *obj_desc, Buffer *bufP)
+{
+ HeapTuple htup;
+ RetrieveIndexResult res;
+ Datum d;
+ int firstbyte, lastbyte;
+ struct varlena *fsblock;
+ bool isNull;
+
+ /*
+ * If we've exhausted the current block, we need to get the next one.
+ * When we support time travel and non-functional updates, we will
+ * need to loop over the blocks, rather than just have an 'if', in
+ * order to find the one we're really interested in.
+ */
+
+ if (obj_desc->offset > obj_desc->highbyte
+ || obj_desc->offset < obj_desc->lowbyte
+ || !ItemPointerIsValid(&(obj_desc->htid))) {
+
+ /* initialize scan key if not done */
+ if (obj_desc->iscan==(IndexScanDesc)NULL) {
+ ScanKeyData skey;
+
+ ScanKeyEntryInitialize(&skey, 0x0, 1, INT4GE_PROC_OID,
+ Int32GetDatum(0));
+ obj_desc->iscan =
+ index_beginscan(obj_desc->index_r,
+ (bool) 0, (uint16) 1,
+ &skey);
+ }
+
+ do {
+ res = index_getnext(obj_desc->iscan, ForwardScanDirection);
+
+ if (res == (RetrieveIndexResult) NULL) {
+ ItemPointerSetInvalid(&(obj_desc->htid));
+ return ((HeapTuple) NULL);
+ }
+
+ /*
+ * For time travel, we need to use the actual time qual here,
+ * rather that NowTimeQual. We currently have no way to pass
+ * a time qual in.
+ */
+
+ htup = heap_fetch(obj_desc->heap_r, NowTimeQual,
+ &(res->heap_iptr), bufP);
+
+ } while (htup == (HeapTuple) NULL);
+
+ /* remember this tid -- we may need it for later reads/writes */
+ ItemPointerCopy(&(res->heap_iptr), &(obj_desc->htid));
+
+ } else {
+ htup = heap_fetch(obj_desc->heap_r, NowTimeQual,
+ &(obj_desc->htid), bufP);
+ }
+
+ /*
+ * By here, we have the heap tuple we're interested in. We cache
+ * the upper and lower bounds for this block in the object descriptor
+ * and return the tuple.
+ */
+
+ d = (Datum)heap_getattr(htup, *bufP, 1, obj_desc->hdesc, &isNull);
+ lastbyte = (int32) DatumGetInt32(d);
+ d = (Datum)heap_getattr(htup, *bufP, 2, obj_desc->hdesc, &isNull);
+ fsblock = (struct varlena *) DatumGetPointer(d);
+
+ /* order of + and - is important -- these are unsigned quantites near 0 */
+ firstbyte = (lastbyte + 1 + sizeof(fsblock->vl_len)) - fsblock->vl_len;
+
+ obj_desc->lowbyte = firstbyte;
+ obj_desc->highbyte = lastbyte;
+
+ /* done */
+ return (htup);
+}
+
+/*
+ * inv_wrnew() -- append a new filesystem block tuple to the inversion
+ * file.
+ *
+ * In response to an inv_write, we append one or more file system
+ * blocks to the class containing the large object. We violate the
+ * class abstraction here in order to pack things as densely as we
+ * are able. We examine the last page in the relation, and write
+ * just enough to fill it, assuming that it has above a certain
+ * threshold of space available. If the space available is less than
+ * the threshold, we allocate a new page by writing a big tuple.
+ *
+ * By the time we get here, we know all the parameters passed in
+ * are valid, and that we hold the appropriate lock on the heap
+ * relation.
+ *
+ * Parameters:
+ * obj_desc: large object descriptor for which to append block.
+ * buf: buffer containing data to write.
+ * nbytes: amount to write
+ *
+ * Returns:
+ * number of bytes actually written to the new tuple.
+ */
+static int
+inv_wrnew(LargeObjectDesc *obj_desc, char *buf, int nbytes)
+{
+ Relation hr;
+ HeapTuple ntup;
+ Buffer buffer;
+ Page page;
+ int nblocks;
+ int nwritten;
+
+ hr = obj_desc->heap_r;
+
+ /*
+ * Get the last block in the relation. If there's no data in the
+ * relation at all, then we just get a new block. Otherwise, we
+ * check the last block to see whether it has room to accept some
+ * or all of the data that the user wants to write. If it doesn't,
+ * then we allocate a new block.
+ */
+
+ nblocks = RelationGetNumberOfBlocks(hr);
+
+ if (nblocks > 0)
+ buffer = ReadBuffer(hr, nblocks - 1);
+ else
+ buffer = ReadBuffer(hr, P_NEW);
+
+ page = BufferGetPage(buffer);
+
+ /*
+ * If the last page is too small to hold all the data, and it's too
+ * small to hold IMINBLK, then we allocate a new page. If it will
+ * hold at least IMINBLK, but less than all the data requested, then
+ * we write IMINBLK here. The caller is responsible for noticing that
+ * less than the requested number of bytes were written, and calling
+ * this routine again.
+ */
+
+ nwritten = IFREESPC(page);
+ if (nwritten < nbytes) {
+ if (nwritten < IMINBLK) {
+ ReleaseBuffer(buffer);
+ buffer = ReadBuffer(hr, P_NEW);
+ page = BufferGetPage(buffer);
+ PageInit(page, BufferGetPageSize(buffer), 0);
+ if (nbytes > IMAXBLK)
+ nwritten = IMAXBLK;
+ else
+ nwritten = nbytes;
+ }
+ } else {
+ nwritten = nbytes;
+ }
+
+ /*
+ * Insert a new file system block tuple, index it, and write it out.
+ */
+
+ ntup = inv_newtuple(obj_desc, buffer, page, buf, nwritten);
+ inv_indextup(obj_desc, ntup);
+
+ /* new tuple is inserted */
+ WriteBuffer(buffer);
+
+ return (nwritten);
+}
+
+static int
+inv_wrold(LargeObjectDesc *obj_desc,
+ char *dbuf,
+ int nbytes,
+ HeapTuple htup,
+ Buffer buffer)
+{
+ Relation hr;
+ HeapTuple ntup;
+ Buffer newbuf;
+ Page page;
+ Page newpage;
+ int tupbytes;
+ Datum d;
+ struct varlena *fsblock;
+ int nwritten, nblocks, freespc;
+ bool isNull;
+ int keep_offset;
+
+ /*
+ * Since we're using a no-overwrite storage manager, the way we
+ * overwrite blocks is to mark the old block invalid and append
+ * a new block. First mark the old block invalid. This violates
+ * the tuple abstraction.
+ */
+
+ TransactionIdStore(GetCurrentTransactionId(), &(htup->t_xmax));
+ htup->t_cmax = GetCurrentCommandId();
+
+ /*
+ * If we're overwriting the entire block, we're lucky. All we need
+ * to do is to insert a new block.
+ */
+
+ if (obj_desc->offset == obj_desc->lowbyte
+ && obj_desc->lowbyte + nbytes >= obj_desc->highbyte) {
+ WriteBuffer(buffer);
+ return (inv_wrnew(obj_desc, dbuf, nbytes));
+ }
+
+ /*
+ * By here, we need to overwrite part of the data in the current
+ * tuple. In order to reduce the degree to which we fragment blocks,
+ * we guarantee that no block will be broken up due to an overwrite.
+ * This means that we need to allocate a tuple on a new page, if
+ * there's not room for the replacement on this one.
+ */
+
+ newbuf = buffer;
+ page = BufferGetPage(buffer);
+ newpage = BufferGetPage(newbuf);
+ hr = obj_desc->heap_r;
+ freespc = IFREESPC(page);
+ d = (Datum)heap_getattr(htup, buffer, 2, obj_desc->hdesc, &isNull);
+ fsblock = (struct varlena *) DatumGetPointer(d);
+ tupbytes = fsblock->vl_len - sizeof(fsblock->vl_len);
+
+ if (freespc < tupbytes) {
+
+ /*
+ * First see if there's enough space on the last page of the
+ * table to put this tuple.
+ */
+
+ nblocks = RelationGetNumberOfBlocks(hr);
+
+ if (nblocks > 0)
+ newbuf = ReadBuffer(hr, nblocks - 1);
+ else
+ newbuf = ReadBuffer(hr, P_NEW);
+
+ newpage = BufferGetPage(newbuf);
+ freespc = IFREESPC(newpage);
+
+ /*
+ * If there's no room on the last page, allocate a new last
+ * page for the table, and put it there.
+ */
+
+ if (freespc < tupbytes) {
+ ReleaseBuffer(newbuf);
+ newbuf = ReadBuffer(hr, P_NEW);
+ newpage = BufferGetPage(newbuf);
+ PageInit(newpage, BufferGetPageSize(newbuf), 0);
+ }
+ }
+
+ nwritten = nbytes;
+ if (nwritten > obj_desc->highbyte - obj_desc->offset + 1)
+ nwritten = obj_desc->highbyte - obj_desc->offset + 1;
+ memmove(VARDATA(fsblock)+ (obj_desc->offset - obj_desc->lowbyte),
+ dbuf,nwritten);
+ /* we are rewriting the entire old block, therefore
+ we reset offset to the lowbyte of the original block
+ before jumping into inv_newtuple() */
+ keep_offset = obj_desc->offset;
+ obj_desc->offset = obj_desc->lowbyte;
+ ntup = inv_newtuple(obj_desc, newbuf, newpage, VARDATA(fsblock),
+ tupbytes);
+ /* after we are done, we restore to the true offset */
+ obj_desc->offset = keep_offset;
+
+ /*
+ * By here, we have a page (newpage) that's guaranteed to have
+ * enough space on it to put the new tuple. Call inv_newtuple
+ * to do the work. Passing NULL as a buffer to inv_newtuple()
+ * keeps it from copying any data into the new tuple. When it
+ * returns, the tuple is ready to receive data from the old
+ * tuple and the user's data buffer.
+ */
+/*
+ ntup = inv_newtuple(obj_desc, newbuf, newpage, (char *) NULL, tupbytes);
+ dptr = ((char *) ntup) + ntup->t_hoff - sizeof(ntup->t_bits) + sizeof(int4)
+ + sizeof(fsblock->vl_len);
+
+ if (obj_desc->offset > obj_desc->lowbyte) {
+ memmove(dptr,
+ &(fsblock->vl_dat[0]),
+ obj_desc->offset - obj_desc->lowbyte);
+ dptr += obj_desc->offset - obj_desc->lowbyte;
+ }
+
+
+ nwritten = nbytes;
+ if (nwritten > obj_desc->highbyte - obj_desc->offset + 1)
+ nwritten = obj_desc->highbyte - obj_desc->offset + 1;
+
+ memmove(dptr, dbuf, nwritten);
+ dptr += nwritten;
+
+ if (obj_desc->offset + nwritten < obj_desc->highbyte + 1) {
+*/
+/*
+ loc = (obj_desc->highbyte - obj_desc->offset)
+ + nwritten;
+ sz = obj_desc->highbyte - (obj_desc->lowbyte + loc);
+
+ what's going on here?? - jolly
+*/
+/*
+ sz = (obj_desc->highbyte + 1) - (obj_desc->offset + nwritten);
+ memmove(&(fsblock->vl_dat[0]), dptr, sz);
+ }
+*/
+
+
+ /* index the new tuple */
+ inv_indextup(obj_desc, ntup);
+
+ /* move the scandesc forward so we don't reread the newly inserted
+ tuple on the next index scan */
+ if (obj_desc->iscan)
+ index_getnext(obj_desc->iscan, ForwardScanDirection);
+
+ /*
+ * Okay, by here, a tuple for the new block is correctly placed,
+ * indexed, and filled. Write the changed pages out.
+ */
+
+ WriteBuffer(buffer);
+ if (newbuf != buffer)
+ WriteBuffer(newbuf);
+
+ /* done */
+ return (nwritten);
+}
+
+static HeapTuple
+inv_newtuple(LargeObjectDesc *obj_desc,
+ Buffer buffer,
+ Page page,
+ char *dbuf,
+ int nwrite)
+{
+ HeapTuple ntup;
+ PageHeader ph;
+ int tupsize;
+ int hoff;
+ Offset lower;
+ Offset upper;
+ ItemId itemId;
+ OffsetNumber off;
+ OffsetNumber limit;
+ char *attptr;
+
+ /* compute tuple size -- no nulls */
+ hoff = sizeof(HeapTupleData) - sizeof(ntup->t_bits);
+
+ /* add in olastbyte, varlena.vl_len, varlena.vl_dat */
+ tupsize = hoff + (2 * sizeof(int32)) + nwrite;
+ tupsize = LONGALIGN(tupsize);
+
+ /*
+ * Allocate the tuple on the page, violating the page abstraction.
+ * This code was swiped from PageAddItem().
+ */
+
+ ph = (PageHeader) page;
+ limit = OffsetNumberNext(PageGetMaxOffsetNumber(page));
+
+ /* look for "recyclable" (unused & deallocated) ItemId */
+ for (off = FirstOffsetNumber; off < limit; off = OffsetNumberNext(off)) {
+ itemId = &ph->pd_linp[off - 1];
+ if ((((*itemId).lp_flags & LP_USED) == 0) &&
+ ((*itemId).lp_len == 0))
+ break;
+ }
+
+ if (off > limit)
+ lower = (Offset) (((char *) (&ph->pd_linp[off])) - ((char *) page));
+ else if (off == limit)
+ lower = ph->pd_lower + sizeof (ItemIdData);
+ else
+ lower = ph->pd_lower;
+
+ upper = ph->pd_upper - tupsize;
+
+ itemId = &ph->pd_linp[off - 1];
+ (*itemId).lp_off = upper;
+ (*itemId).lp_len = tupsize;
+ (*itemId).lp_flags = LP_USED;
+ ph->pd_lower = lower;
+ ph->pd_upper = upper;
+
+ ntup = (HeapTuple) ((char *) page + upper);
+
+ /*
+ * Tuple is now allocated on the page. Next, fill in the tuple
+ * header. This block of code violates the tuple abstraction.
+ */
+
+ ntup->t_len = tupsize;
+ ItemPointerSet(&(ntup->t_ctid), BufferGetBlockNumber(buffer), off);
+ ItemPointerSetInvalid(&(ntup->t_chain));
+ LastOidProcessed = ntup->t_oid = newoid();
+ TransactionIdStore(GetCurrentTransactionId(), &(ntup->t_xmin));
+ ntup->t_cmin = GetCurrentCommandId();
+ StoreInvalidTransactionId(&(ntup->t_xmax));
+ ntup->t_cmax = 0;
+ ntup->t_tmin = INVALID_ABSTIME;
+ ntup->t_tmax = CURRENT_ABSTIME;
+ ntup->t_natts = 2;
+ ntup->t_hoff = hoff;
+ ntup->t_vtype = 0;
+ ntup->t_infomask = 0x0;
+
+ /* if a NULL is passed in, avoid the calculations below */
+ if (dbuf == NULL)
+ return ntup;
+
+ /*
+ * Finally, copy the user's data buffer into the tuple. This violates
+ * the tuple and class abstractions.
+ */
+
+ attptr = ((char *) ntup) + hoff;
+ *((int32 *) attptr) = obj_desc->offset + nwrite - 1;
+ attptr += sizeof(int32);
+
+ /*
+ ** mer fixed disk layout of varlenas to get rid of the need for this.
+ **
+ ** *((int32 *) attptr) = nwrite + sizeof(int32);
+ ** attptr += sizeof(int32);
+ */
+
+ *((int32 *) attptr) = nwrite + sizeof(int32);
+ attptr += sizeof(int32);
+
+ /*
+ * If a data buffer was passed in, then copy the data from the buffer
+ * to the tuple. Some callers (eg, inv_wrold()) may not pass in a
+ * buffer, since they have to copy part of the old tuple data and
+ * part of the user's new data into the new tuple.
+ */
+
+ if (dbuf != (char *) NULL)
+ memmove(attptr, dbuf, nwrite);
+
+ /* keep track of boundary of current tuple */
+ obj_desc->lowbyte = obj_desc->offset;
+ obj_desc->highbyte = obj_desc->offset + nwrite - 1;
+
+ /* new tuple is filled -- return it */
+ return (ntup);
+}
+
+static void
+inv_indextup(LargeObjectDesc *obj_desc, HeapTuple htup)
+{
+ IndexTuple itup;
+ InsertIndexResult res;
+ Datum v[1];
+ char n[1];
+
+ n[0] = ' ';
+ v[0] = Int32GetDatum(obj_desc->highbyte);
+ itup = index_formtuple(obj_desc->idesc, &v[0], &n[0]);
+ memmove((char *)&(itup->t_tid),
+ (char *)&(htup->t_ctid),
+ sizeof(ItemPointerData));
+ res = index_insert(obj_desc->index_r, itup);
+
+ if (res)
+ pfree(res);
+
+ pfree(itup);
+}
+
+/*
+static void
+DumpPage(Page page, int blkno)
+{
+ ItemId lp;
+ HeapTuple tup;
+ int flags, i, nline;
+ ItemPointerData pointerData;
+
+ printf("\t[subblock=%d]:lower=%d:upper=%d:special=%d\n", 0,
+ ((PageHeader)page)->pd_lower, ((PageHeader)page)->pd_upper,
+ ((PageHeader)page)->pd_special);
+
+ printf("\t:MaxOffsetNumber=%d\n",
+ (int16) PageGetMaxOffsetNumber(page));
+
+ nline = (int16) PageGetMaxOffsetNumber(page);
+
+{
+ int i;
+ char *cp;
+
+ i = PageGetSpecialSize(page);
+ cp = PageGetSpecialPointer(page);
+
+ printf("\t:SpecialData=");
+
+ while (i > 0) {
+ printf(" 0x%02x", *cp);
+ cp += 1;
+ i -= 1;
+ }
+ printf("\n");
+}
+ for (i = 0; i < nline; i++) {
+ lp = ((PageHeader)page)->pd_linp + i;
+ flags = (*lp).lp_flags;
+ ItemPointerSet(&pointerData, blkno, 1 + i);
+ printf("%s:off=%d:flags=0x%x:len=%d",
+ ItemPointerFormExternal(&pointerData), (*lp).lp_off,
+ flags, (*lp).lp_len);
+
+ if (flags & LP_USED) {
+ HeapTupleData htdata;
+
+ printf(":USED");
+
+ memmove((char *) &htdata,
+ (char *) &((char *)page)[(*lp).lp_off],
+ sizeof(htdata));
+
+ tup = &htdata;
+
+ printf("\n\t:ctid=%s:oid=%d",
+ ItemPointerFormExternal(&tup->t_ctid),
+ tup->t_oid);
+ printf(":natts=%d:thoff=%d:vtype=`%c' (0x%02x):",
+ tup->t_natts,
+ tup->t_hoff, tup->t_vtype, tup->t_vtype);
+
+ printf("\n\t:tmin=%d:cmin=%u:",
+ tup->t_tmin, tup->t_cmin);
+
+ printf("xmin=%u:", tup->t_xmin);
+
+ printf("\n\t:tmax=%d:cmax=%u:",
+ tup->t_tmax, tup->t_cmax);
+
+ printf("xmax=%u:", tup->t_xmax);
+
+ printf("\n\t:chain=%s:\n",
+ ItemPointerFormExternal(&tup->t_chain));
+ } else
+ putchar('\n');
+ }
+}
+
+static char*
+ItemPointerFormExternal(ItemPointer pointer)
+{
+ static char itemPointerString[32];
+
+ if (!ItemPointerIsValid(pointer)) {
+ memmove(itemPointerString, "<-,-,->", sizeof "<-,-,->");
+ } else {
+ sprintf(itemPointerString, "<%u,%u>",
+ ItemPointerGetBlockNumber(pointer),
+ ItemPointerGetOffsetNumber(pointer));
+ }
+
+ return (itemPointerString);
+}
+*/
+
+static int
+_inv_getsize(Relation hreln, TupleDesc hdesc, Relation ireln)
+{
+ IndexScanDesc iscan;
+ RetrieveIndexResult res;
+ Buffer buf;
+ HeapTuple htup;
+ Datum d;
+ long size;
+ bool isNull;
+
+ /* scan backwards from end */
+ iscan = index_beginscan(ireln, (bool) 1, 0, (ScanKey) NULL);
+
+ buf = InvalidBuffer;
+
+ do {
+ res = index_getnext(iscan, BackwardScanDirection);
+
+ /*
+ * If there are no more index tuples, then the relation is empty,
+ * so the file's size is zero.
+ */
+
+ if (res == (RetrieveIndexResult) NULL) {
+ index_endscan(iscan);
+ return (0);
+ }
+
+ /*
+ * For time travel, we need to use the actual time qual here,
+ * rather that NowTimeQual. We currently have no way to pass
+ * a time qual in.
+ */
+
+ if (buf != InvalidBuffer)
+ (void) ReleaseBuffer(buf);
+
+ htup = heap_fetch(hreln, NowTimeQual, &(res->heap_iptr), &buf);
+
+ } while (!HeapTupleIsValid(htup));
+
+ /* don't need the index scan anymore */
+ index_endscan(iscan);
+
+ /* get olastbyte attribute */
+ d = (Datum) heap_getattr(htup, buf, 1, hdesc, &isNull);
+ size = DatumGetInt32(d) + 1;
+
+ /* wei hates it if you forget to do this */
+ ReleaseBuffer(buf);
+
+ return (size);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * lmgr.h--
+ * POSTGRES lock manager definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: lmgr.h,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef LMGR_H
+#define LMGR_H
+
+#include "postgres.h"
+
+#include "storage/itemptr.h"
+#include "storage/lock.h"
+#include "utils/rel.h"
+
+/*
+ * This was moved from pladt.h for the new lock manager. Want to obsolete
+ * all of the old code.
+ */
+typedef struct LRelId {
+ Oid relId; /* a relation identifier */
+ Oid dbId; /* a database identifier */
+} LRelId;
+
+typedef struct LockInfoData {
+ bool initialized;
+ LRelId lRelId;
+ TransactionId transactionIdData;
+ uint16 flags;
+} LockInfoData;
+typedef LockInfoData *LockInfo;
+
+#define LockInfoIsValid(linfo) \
+ ((PointerIsValid(linfo)) && ((LockInfo) linfo)->initialized)
+
+
+extern LRelId RelationGetLRelId(Relation relation);
+extern Oid LRelIdGetDatabaseId(LRelId lRelId);
+extern Oid LRelIdGetRelationId(LRelId lRelId);
+extern bool DatabaseIdIsMyDatabaseId(Oid databaseId);
+extern bool LRelIdContainsMyDatabaseId(LRelId lRelId);
+extern void RelationInitLockInfo(Relation relation);
+extern void RelationDiscardLockInfo(Relation relation);
+extern void RelationSetLockForDescriptorOpen(Relation relation);
+extern void RelationSetLockForRead(Relation relation);
+extern void RelationUnsetLockForRead(Relation relation);
+extern void RelationSetLockForWrite(Relation relation);
+extern void RelationUnsetLockForWrite(Relation relation);
+extern void RelationSetLockForTupleRead(Relation relation,
+ ItemPointer itemPointer);
+
+/* used in vaccum.c */
+extern void RelationSetLockForWritePage(Relation relation,
+ ItemPointer itemPointer);
+
+/* used in nbtpage.c, hashpage.c */
+extern void RelationSetSingleWLockPage(Relation relation,
+ ItemPointer itemPointer);
+extern void RelationUnsetSingleWLockPage(Relation relation,
+ ItemPointer itemPointer);
+extern void RelationSetSingleRLockPage(Relation relation,
+ ItemPointer itemPointer);
+extern void RelationUnsetSingleRLockPage(Relation relation,
+ ItemPointer itemPointer);
+extern void RelationSetRIntentLock(Relation relation);
+extern void RelationUnsetRIntentLock(Relation relation);
+extern void RelationSetWIntentLock(Relation relation);
+extern void RelationUnsetWIntentLock(Relation relation);
+extern void RelationSetLockForExtend(Relation relation);
+extern void RelationUnsetLockForExtend(Relation relation);
+extern void LRelIdAssign(LRelId *lRelId, Oid dbId, Oid relId);
+
+/* single.c */
+extern bool SingleLockReln(LockInfo linfo, LOCKT lockt, int action);
+extern bool SingleLockPage(LockInfo linfo, ItemPointer tidPtr,
+ LOCKT lockt, int action);
+
+#endif /* LMGR_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for storage/lmgr
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/storage/lmgr/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:55 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= lmgr.c lock.c multi.c proc.c single.c
--- /dev/null
+$Header: /cvsroot/pgsql/src/backend/storage/lmgr/README,v 1.1.1.1 1996/07/09 06:21:55 scrappy Exp $
+
+This file is an attempt to save me (and future code maintainers) some
+time and a lot of headaches. The existing lock manager code at the time
+of this writing (June 16 1992) can best be described as confusing. The
+complexity seems inherent in lock manager functionality, but variable
+names chosen in the current implementation really confuse me everytime
+I have to track down a bug. Also, what gets done where and by whom isn't
+always clear....
+
+Starting with the data structures the lock manager relies upon...
+
+(NOTE - these will undoubtedly change over time and it is likely
+that this file won't always be updated along with the structs.)
+
+The lock manager's LOCK:
+
+tag -
+ The key fields that are used for hashing locks in the shared memory
+ lock hash table. This is kept as a separate struct to ensure that we
+ always zero out the correct number of bytes. This is a problem as
+ part of the tag is an itempointer which is 6 bytes and causes 2
+ additional bytes to be added as padding.
+
+ tag.relId -
+ Uniquely identifies the relation that the lock corresponds to.
+
+ tag.dbId -
+ Uniquely identifies the database in which the relation lives. If
+ this is a shared system relation (e.g. pg_user) the dbId should be
+ set to 0.
+
+ tag.tupleId -
+ Uniquely identifies the block/page within the relation and the
+ tuple within the block. If we are setting a table level lock
+ both the blockId and tupleId (in an item pointer this is called
+ the position) are set to invalid, if it is a page level lock the
+ blockId is valid, while the tuleId is still invalid. Finally if
+ this is a tuple level lock (we currently never do this) then both
+ the blockId and tupleId are set to valid specifications. This is
+ how we get the appearance of a multi-level lock table while using
+ only a single table (see Gray's paper on 2 phase locking if
+ you are puzzled about how multi-level lock tables work).
+
+mask -
+ This field indicates what types of locks are currently held in the
+ given lock. It is used (against the lock table's conflict table)
+ to determine if the new lock request will conflict with existing
+ lock types held. Conficts are determined by bitwise AND operations
+ between the mask and the conflict table entry for the given lock type
+ to be set. The current representation is that each bit (1 through 5)
+ is set when that lock type (WRITE, READ, WRITE INTENT, READ INTENT, EXTEND)
+ has been acquired for the lock.
+
+waitProcs -
+ This is a shared memory queue of all process structures corresponding to
+ a backend that is waiting (sleeping) until another backend releases this
+ lock. The process structure holds the information needed to determine
+ if it should be woken up when this lock is released. If, for example,
+ we are releasing a read lock and the process is sleeping trying to acquire
+ a read lock then there is no point in waking it since the lock being
+ released isn't what caused it to sleep in the first place. There will
+ be more on this below (when I get to releasing locks and waking sleeping
+ process routines).
+
+nHolding -
+ Keeps a count of how many times this lock has been attempted to be
+ acquired. The count includes attempts by processes which were put
+ to sleep due to conflicts. It also counts the same backend twice
+ if, for example, a backend process first acquires a read and then
+ acquires a write.
+
+holders -
+ Keeps a count of how many locks of each type have been attempted. Only
+ elements 1 through MAX_LOCK_TYPES are used as they correspond to the lock
+ type defined constants (WRITE through EXTEND). Summing the values of
+ holders should come out equal to nHolding.
+
+nActive -
+ Keeps a count of how many times this lock has been succesfully acquired.
+ This count does not include attempts that were rejected due to conflicts,
+ but can count the same backend twice (e.g. a read then a write -- since
+ its the same transaction this won't cause a conflict)
+
+activeHolders -
+ Keeps a count of how locks of each type are currently held. Once again
+ only elements 1 through MAX_LOCK_TYPES are used (0 is not). Also, like
+ holders, summing the values of activeHolders should total to the value
+ of nActive.
+
+
+This is all I had the stomach for right now..... I will get back to this
+someday. -mer 17 June 1992 12:00 am
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * lmgr.c--
+ * POSTGRES lock manager code
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.1.1.1 1996/07/09 06:21:56 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/* #define LOCKDEBUGALL 1 */
+/* #define LOCKDEBUG 1 */
+
+#ifdef LOCKDEBUGALL
+#define LOCKDEBUG 1
+#endif /* LOCKDEBUGALL */
+
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "access/htup.h"
+#include "access/relscan.h"
+#include "access/skey.h"
+#include "utils/tqual.h"
+#include "access/xact.h"
+
+#include "storage/block.h"
+#include "storage/buf.h"
+#include "storage/itemptr.h"
+#include "storage/bufpage.h"
+#include "storage/multilev.h"
+#include "storage/lmgr.h"
+
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/rel.h"
+
+#include "catalog/catname.h"
+#include "catalog/catalog.h"
+#include "catalog/pg_class.h"
+
+#include "nodes/memnodes.h"
+#include "storage/bufmgr.h"
+#include "access/transam.h" /* for AmiTransactionId */
+
+/* ----------------
+ *
+ * ----------------
+ */
+#define MaxRetries 4 /* XXX about 1/4 minute--a hack */
+
+#define IntentReadRelationLock 0x0100
+#define ReadRelationLock 0x0200
+#define IntentWriteRelationLock 0x0400
+#define WriteRelationLock 0x0800
+#define IntentReadPageLock 0x1000
+#define ReadTupleLock 0x2000
+
+#define TupleLevelLockCountMask 0x000f
+
+#define TupleLevelLockLimit 10
+
+extern Oid MyDatabaseId;
+
+static LRelId VariableRelationLRelId = {
+ RelOid_pg_variable,
+ InvalidOid
+};
+
+/* ----------------
+ * RelationGetLRelId
+ * ----------------
+ */
+#ifdef LOCKDEBUG
+#define LOCKDEBUG_10 \
+elog(NOTICE, "RelationGetLRelId(%s) invalid lockInfo", \
+ RelationGetRelationName(relation));
+#else
+#define LOCKDEBUG_10
+#endif /* LOCKDEBUG */
+
+/*
+ * RelationGetLRelId --
+ * Returns "lock" relation identifier for a relation.
+ */
+LRelId
+RelationGetLRelId(Relation relation)
+{
+ LockInfo linfo;
+
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ Assert(RelationIsValid(relation));
+ linfo = (LockInfo) relation->lockInfo;
+
+ /* ----------------
+ * initialize lock info if necessary
+ * ----------------
+ */
+ if (! LockInfoIsValid(linfo)) {
+ LOCKDEBUG_10;
+ RelationInitLockInfo(relation);
+ linfo = (LockInfo) relation->lockInfo;
+ }
+
+ /* ----------------
+ * XXX hack to prevent problems during
+ * VARIABLE relation initialization
+ * ----------------
+ */
+ if (strcmp(RelationGetRelationName(relation)->data,
+ VariableRelationName) == 0) {
+ return (VariableRelationLRelId);
+ }
+
+ return (linfo->lRelId);
+}
+
+/*
+ * LRelIdGetDatabaseId --
+ * Returns database identifier for a "lock" relation identifier.
+ */
+/* ----------------
+ * LRelIdGetDatabaseId
+ *
+ * Note: The argument may not be correct, if it is not used soon
+ * after it is created.
+ * ----------------
+ */
+Oid
+LRelIdGetDatabaseId(LRelId lRelId)
+{
+ return (lRelId.dbId);
+}
+
+
+/*
+ * LRelIdGetRelationId --
+ * Returns relation identifier for a "lock" relation identifier.
+ */
+Oid
+LRelIdGetRelationId(LRelId lRelId)
+{
+ return (lRelId.relId);
+}
+
+/*
+ * DatabaseIdIsMyDatabaseId --
+ * True iff database object identifier is valid in my present database.
+ */
+bool
+DatabaseIdIsMyDatabaseId(Oid databaseId)
+{
+ return (bool)
+ (!OidIsValid(databaseId) || databaseId == MyDatabaseId);
+}
+
+/*
+ * LRelIdContainsMyDatabaseId --
+ * True iff "lock" relation identifier is valid in my present database.
+ */
+bool
+LRelIdContainsMyDatabaseId(LRelId lRelId)
+{
+ return (bool)
+ (!OidIsValid(lRelId.dbId) || lRelId.dbId == MyDatabaseId);
+}
+
+/*
+ * RelationInitLockInfo --
+ * Initializes the lock information in a relation descriptor.
+ */
+/* ----------------
+ * RelationInitLockInfo
+ *
+ * XXX processingVariable is a hack to prevent problems during
+ * VARIABLE relation initialization.
+ * ----------------
+ */
+void
+RelationInitLockInfo(Relation relation)
+{
+ LockInfo info;
+ char *relname;
+ Oid relationid;
+ bool processingVariable;
+ extern Oid MyDatabaseId; /* XXX use include */
+ extern GlobalMemory CacheCxt;
+
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ Assert(RelationIsValid(relation));
+ Assert(OidIsValid(RelationGetRelationId(relation)));
+
+ /* ----------------
+ * get information from relation descriptor
+ * ----------------
+ */
+ info = (LockInfo) relation->lockInfo;
+ relname = (char *) RelationGetRelationName(relation);
+ relationid = RelationGetRelationId(relation);
+ processingVariable = (strcmp(relname, VariableRelationName) == 0);
+
+ /* ----------------
+ * create a new lockinfo if not already done
+ * ----------------
+ */
+ if (! PointerIsValid(info))
+ {
+ MemoryContext oldcxt;
+
+ oldcxt = MemoryContextSwitchTo((MemoryContext)CacheCxt);
+ info = (LockInfo)palloc(sizeof(LockInfoData));
+ MemoryContextSwitchTo(oldcxt);
+ }
+ else if (processingVariable) {
+ if (IsTransactionState()) {
+ TransactionIdStore(GetCurrentTransactionId(),
+ &info->transactionIdData);
+ }
+ info->flags = 0x0;
+ return; /* prevent an infinite loop--still true? */
+ }
+ else if (info->initialized)
+ {
+ /* ------------
+ * If we've already initialized we're done.
+ * ------------
+ */
+ return;
+ }
+
+ /* ----------------
+ * initialize lockinfo.dbId and .relId appropriately
+ * ----------------
+ */
+ if (IsSharedSystemRelationName(relname))
+ LRelIdAssign(&info->lRelId, InvalidOid, relationid);
+ else
+ LRelIdAssign(&info->lRelId, MyDatabaseId, relationid);
+
+ /* ----------------
+ * store the transaction id in the lockInfo field
+ * ----------------
+ */
+ if (processingVariable)
+ TransactionIdStore(AmiTransactionId,
+ &info->transactionIdData);
+ else if (IsTransactionState())
+ TransactionIdStore(GetCurrentTransactionId(),
+ &info->transactionIdData);
+ else
+ StoreInvalidTransactionId(&(info->transactionIdData));
+
+ /* ----------------
+ * initialize rest of lockinfo
+ * ----------------
+ */
+ info->flags = 0x0;
+ info->initialized = (bool)true;
+ relation->lockInfo = (Pointer) info;
+}
+
+/* ----------------
+ * RelationDiscardLockInfo
+ * ----------------
+ */
+#ifdef LOCKDEBUG
+#define LOCKDEBUG_20 \
+elog(DEBUG, "DiscardLockInfo: NULL relation->lockInfo")
+#else
+#define LOCKDEBUG_20
+#endif /* LOCKDEBUG */
+
+/*
+ * RelationDiscardLockInfo --
+ * Discards the lock information in a relation descriptor.
+ */
+void
+RelationDiscardLockInfo(Relation relation)
+{
+ if (! LockInfoIsValid(relation->lockInfo)) {
+ LOCKDEBUG_20;
+ return;
+ }
+
+ pfree(relation->lockInfo);
+ relation->lockInfo = NULL;
+}
+
+/*
+ * RelationSetLockForDescriptorOpen --
+ * Sets read locks for a relation descriptor.
+ */
+#ifdef LOCKDEBUGALL
+#define LOCKDEBUGALL_30 \
+elog(DEBUG, "RelationSetLockForDescriptorOpen(%s[%d,%d]) called", \
+ RelationGetRelationName(relation), lRelId.dbId, lRelId.relId)
+#else
+#define LOCKDEBUGALL_30
+#endif /* LOCKDEBUGALL*/
+
+void
+RelationSetLockForDescriptorOpen(Relation relation)
+{
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled())
+ return;
+
+ LOCKDEBUGALL_30;
+
+ /* ----------------
+ * read lock catalog tuples which compose the relation descriptor
+ * XXX race condition? XXX For now, do nothing.
+ * ----------------
+ */
+}
+
+/* ----------------
+ * RelationSetLockForRead
+ * ----------------
+ */
+#ifdef LOCKDEBUG
+#define LOCKDEBUG_40 \
+elog(DEBUG, "RelationSetLockForRead(%s[%d,%d]) called", \
+ RelationGetRelationName(relation), lRelId.dbId, lRelId.relId)
+#else
+#define LOCKDEBUG_40
+#endif /* LOCKDEBUG*/
+
+/*
+ * RelationSetLockForRead --
+ * Sets relation level read lock.
+ */
+void
+RelationSetLockForRead(Relation relation)
+{
+ LockInfo linfo;
+
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled())
+ return;
+
+ LOCKDEBUG_40;
+
+ /* ----------------
+ * If we don't have lock info on the reln just go ahead and
+ * lock it without trying to short circuit the lock manager.
+ * ----------------
+ */
+ if (!LockInfoIsValid(relation->lockInfo))
+ {
+ RelationInitLockInfo(relation);
+ linfo = (LockInfo) relation->lockInfo;
+ linfo->flags |= ReadRelationLock;
+ MultiLockReln(linfo, READ_LOCK);
+ return;
+ }
+ else
+ linfo = (LockInfo) relation->lockInfo;
+
+ MultiLockReln(linfo, READ_LOCK);
+}
+
+/* ----------------
+ * RelationUnsetLockForRead
+ * ----------------
+ */
+#ifdef LOCKDEBUG
+#define LOCKDEBUG_50 \
+elog(DEBUG, "RelationUnsetLockForRead(%s[%d,%d]) called", \
+ RelationGetRelationName(relation), lRelId.dbId, lRelId.relId)
+#else
+#define LOCKDEBUG_50
+#endif /* LOCKDEBUG*/
+
+/*
+ * RelationUnsetLockForRead --
+ * Unsets relation level read lock.
+ */
+void
+RelationUnsetLockForRead(Relation relation)
+{
+ LockInfo linfo;
+
+ /* ----------------
+ * sanity check
+ * ----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled())
+ return;
+
+ linfo = (LockInfo) relation->lockInfo;
+
+ /* ----------------
+ * If we don't have lock info on the reln just go ahead and
+ * release it.
+ * ----------------
+ */
+ if (!LockInfoIsValid(linfo))
+ {
+ elog(WARN,
+ "Releasing a lock on %s with invalid lock information",
+ RelationGetRelationName(relation));
+ }
+
+ MultiReleaseReln(linfo, READ_LOCK);
+}
+
+/* ----------------
+ * RelationSetLockForWrite(relation)
+ * ----------------
+ */
+#ifdef LOCKDEBUG
+#define LOCKDEBUG_60 \
+elog(DEBUG, "RelationSetLockForWrite(%s[%d,%d]) called", \
+ RelationGetRelationName(relation), lRelId.dbId, lRelId.relId)
+#else
+#define LOCKDEBUG_60
+#endif /* LOCKDEBUG*/
+
+/*
+ * RelationSetLockForWrite --
+ * Sets relation level write lock.
+ */
+void
+RelationSetLockForWrite(Relation relation)
+{
+ LockInfo linfo;
+
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled())
+ return;
+
+ LOCKDEBUG_60;
+
+ /* ----------------
+ * If we don't have lock info on the reln just go ahead and
+ * lock it without trying to short circuit the lock manager.
+ * ----------------
+ */
+ if (!LockInfoIsValid(relation->lockInfo))
+ {
+ RelationInitLockInfo(relation);
+ linfo = (LockInfo) relation->lockInfo;
+ linfo->flags |= WriteRelationLock;
+ MultiLockReln(linfo, WRITE_LOCK);
+ return;
+ }
+ else
+ linfo = (LockInfo) relation->lockInfo;
+
+ MultiLockReln(linfo, WRITE_LOCK);
+}
+
+/* ----------------
+ * RelationUnsetLockForWrite
+ * ----------------
+ */
+#ifdef LOCKDEBUG
+#define LOCKDEBUG_70 \
+elog(DEBUG, "RelationUnsetLockForWrite(%s[%d,%d]) called", \
+ RelationGetRelationName(relation), lRelId.dbId, lRelId.relId);
+#else
+#define LOCKDEBUG_70
+#endif /* LOCKDEBUG */
+
+/*
+ * RelationUnsetLockForWrite --
+ * Unsets relation level write lock.
+ */
+void
+RelationUnsetLockForWrite(Relation relation)
+{
+ LockInfo linfo;
+
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled()) {
+ return;
+ }
+
+ linfo = (LockInfo) relation->lockInfo;
+
+ if (!LockInfoIsValid(linfo))
+ {
+ elog(WARN,
+ "Releasing a lock on %s with invalid lock information",
+ RelationGetRelationName(relation));
+ }
+
+ MultiReleaseReln(linfo, WRITE_LOCK);
+}
+
+/* ----------------
+ * RelationSetLockForTupleRead
+ * ----------------
+ */
+#ifdef LOCKDEBUG
+#define LOCKDEBUG_80 \
+elog(DEBUG, "RelationSetLockForTupleRead(%s[%d,%d], 0x%x) called", \
+ RelationGetRelationName(relation), lRelId.dbId, lRelId.relId, \
+ itemPointer)
+#define LOCKDEBUG_81 \
+ elog(DEBUG, "RelationSetLockForTupleRead() escalating");
+#else
+#define LOCKDEBUG_80
+#define LOCKDEBUG_81
+#endif /* LOCKDEBUG */
+
+/*
+ * RelationSetLockForTupleRead --
+ * Sets tuple level read lock.
+ */
+void
+RelationSetLockForTupleRead(Relation relation, ItemPointer itemPointer)
+{
+ LockInfo linfo;
+ TransactionId curXact;
+
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled())
+ return;
+
+ LOCKDEBUG_80;
+
+ /* ---------------------
+ * If our lock info is invalid don't bother trying to short circuit
+ * the lock manager.
+ * ---------------------
+ */
+ if (!LockInfoIsValid(relation->lockInfo))
+ {
+ RelationInitLockInfo(relation);
+ linfo = (LockInfo) relation->lockInfo;
+ linfo->flags |=
+ IntentReadRelationLock |
+ IntentReadPageLock |
+ ReadTupleLock;
+ MultiLockTuple(linfo, itemPointer, READ_LOCK);
+ return;
+ }
+ else
+ linfo = (LockInfo) relation->lockInfo;
+
+ /* ----------------
+ * no need to set a lower granularity lock
+ * ----------------
+ */
+ curXact = GetCurrentTransactionId();
+ if ((linfo->flags & ReadRelationLock) &&
+ TransactionIdEquals(curXact, linfo->transactionIdData))
+ {
+ return;
+ }
+
+ /* ----------------
+ * If we don't already have a tuple lock this transaction
+ * ----------------
+ */
+ if (!( (linfo->flags & ReadTupleLock) &&
+ TransactionIdEquals(curXact, linfo->transactionIdData) )) {
+
+ linfo->flags |=
+ IntentReadRelationLock |
+ IntentReadPageLock |
+ ReadTupleLock;
+
+ /* clear count */
+ linfo->flags &= ~TupleLevelLockCountMask;
+
+ } else {
+ if (TupleLevelLockLimit == (TupleLevelLockCountMask &
+ linfo->flags)) {
+ LOCKDEBUG_81;
+
+ /* escalate */
+ MultiLockReln(linfo, READ_LOCK);
+
+ /* clear count */
+ linfo->flags &= ~TupleLevelLockCountMask;
+ return;
+ }
+
+ /* increment count */
+ linfo->flags =
+ (linfo->flags & ~TupleLevelLockCountMask) |
+ (1 + (TupleLevelLockCountMask & linfo->flags));
+ }
+
+ TransactionIdStore(curXact, &linfo->transactionIdData);
+
+ /* ----------------
+ * Lock the tuple.
+ * ----------------
+ */
+ MultiLockTuple(linfo, itemPointer, READ_LOCK);
+}
+
+/* ----------------
+ * RelationSetLockForReadPage
+ * ----------------
+ */
+#ifdef LOCKDEBUG
+#define LOCKDEBUG_90 \
+elog(DEBUG, "RelationSetLockForReadPage(%s[%d,%d], @%d) called", \
+ RelationGetRelationName(relation), lRelId.dbId, lRelId.relId, page);
+#else
+#define LOCKDEBUG_90
+#endif /* LOCKDEBUG*/
+
+/* ----------------
+ * RelationSetLockForWritePage
+ * ----------------
+ */
+#ifdef LOCKDEBUG
+#define LOCKDEBUG_100 \
+elog(DEBUG, "RelationSetLockForWritePage(%s[%d,%d], @%d) called", \
+ RelationGetRelationName(relation), lRelId.dbId, lRelId.relId, page);
+#else
+#define LOCKDEBUG_100
+#endif /* LOCKDEBUG */
+
+/*
+ * RelationSetLockForWritePage --
+ * Sets write lock on a page.
+ */
+void
+RelationSetLockForWritePage(Relation relation,
+ ItemPointer itemPointer)
+{
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled())
+ return;
+
+ /* ---------------
+ * Make sure linfo is initialized
+ * ---------------
+ */
+ if (!LockInfoIsValid(relation->lockInfo))
+ RelationInitLockInfo(relation);
+
+ /* ----------------
+ * attempt to set lock
+ * ----------------
+ */
+ MultiLockPage((LockInfo) relation->lockInfo, itemPointer, WRITE_LOCK);
+}
+
+/* ----------------
+ * RelationUnsetLockForReadPage
+ * ----------------
+ */
+#ifdef LOCKDEBUG
+#define LOCKDEBUG_110 \
+elog(DEBUG, "RelationUnsetLockForReadPage(%s[%d,%d], @%d) called", \
+ RelationGetRelationName(relation), lRelId.dbId, lRelId.relId, page)
+#else
+#define LOCKDEBUG_110
+#endif /* LOCKDEBUG */
+
+/* ----------------
+ * RelationUnsetLockForWritePage
+ * ----------------
+ */
+#ifdef LOCKDEBUG
+#define LOCKDEBUG_120 \
+elog(DEBUG, "RelationUnsetLockForWritePage(%s[%d,%d], @%d) called", \
+ RelationGetRelationName(relation), lRelId.dbId, lRelId.relId, page)
+#else
+#define LOCKDEBUG_120
+#endif /* LOCKDEBUG */
+
+/*
+ * Set a single level write page lock. Assumes that you already
+ * have a write intent lock on the relation.
+ */
+void
+RelationSetSingleWLockPage(Relation relation,
+ ItemPointer itemPointer)
+{
+
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled())
+ return;
+
+ if (!LockInfoIsValid(relation->lockInfo))
+ RelationInitLockInfo(relation);
+
+ SingleLockPage((LockInfo)relation->lockInfo, itemPointer, WRITE_LOCK, !UNLOCK);
+}
+
+/*
+ * Unset a single level write page lock
+ */
+void
+RelationUnsetSingleWLockPage(Relation relation,
+ ItemPointer itemPointer)
+{
+
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled())
+ return;
+
+ if (!LockInfoIsValid(relation->lockInfo))
+ elog(WARN,
+ "Releasing a lock on %s with invalid lock information",
+ RelationGetRelationName(relation));
+
+ SingleLockPage((LockInfo)relation->lockInfo, itemPointer, WRITE_LOCK, UNLOCK);
+}
+
+/*
+ * Set a single level read page lock. Assumes you already have a read
+ * intent lock set on the relation.
+ */
+void
+RelationSetSingleRLockPage(Relation relation,
+ ItemPointer itemPointer)
+{
+
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled())
+ return;
+
+ if (!LockInfoIsValid(relation->lockInfo))
+ RelationInitLockInfo(relation);
+
+ SingleLockPage((LockInfo)relation->lockInfo, itemPointer, READ_LOCK, !UNLOCK);
+}
+
+/*
+ * Unset a single level read page lock.
+ */
+void
+RelationUnsetSingleRLockPage(Relation relation,
+ ItemPointer itemPointer)
+{
+
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled())
+ return;
+
+ if (!LockInfoIsValid(relation->lockInfo))
+ elog(WARN,
+ "Releasing a lock on %s with invalid lock information",
+ RelationGetRelationName(relation));
+
+ SingleLockPage((LockInfo)relation->lockInfo, itemPointer, READ_LOCK, UNLOCK);
+}
+
+/*
+ * Set a read intent lock on a relation.
+ *
+ * Usually these are set in a multi-level table when you acquiring a
+ * page level lock. i.e. To acquire a lock on a page you first acquire
+ * an intent lock on the entire relation. Acquiring an intent lock along
+ * allows one to use the single level locking routines later. Good for
+ * index scans that do a lot of page level locking.
+ */
+void
+RelationSetRIntentLock(Relation relation)
+{
+ /* -----------------
+ * Sanity check
+ * -----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled())
+ return;
+
+ if (!LockInfoIsValid(relation->lockInfo))
+ RelationInitLockInfo(relation);
+
+ SingleLockReln((LockInfo)relation->lockInfo, READ_LOCK+INTENT, !UNLOCK);
+}
+
+/*
+ * Unset a read intent lock on a relation
+ */
+void
+RelationUnsetRIntentLock(Relation relation)
+{
+ /* -----------------
+ * Sanity check
+ * -----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled())
+ return;
+
+ if (!LockInfoIsValid(relation->lockInfo))
+ RelationInitLockInfo(relation);
+
+ SingleLockReln((LockInfo)relation->lockInfo, READ_LOCK+INTENT, UNLOCK);
+}
+
+/*
+ * Set a write intent lock on a relation. For a more complete explanation
+ * see RelationSetRIntentLock()
+ */
+void
+RelationSetWIntentLock(Relation relation)
+{
+ /* -----------------
+ * Sanity check
+ * -----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled())
+ return;
+
+ if (!LockInfoIsValid(relation->lockInfo))
+ RelationInitLockInfo(relation);
+
+ SingleLockReln((LockInfo)relation->lockInfo, WRITE_LOCK+INTENT, !UNLOCK);
+}
+
+/*
+ * Unset a write intent lock.
+ */
+void
+RelationUnsetWIntentLock(Relation relation)
+{
+ /* -----------------
+ * Sanity check
+ * -----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled())
+ return;
+
+ if (!LockInfoIsValid(relation->lockInfo))
+ RelationInitLockInfo(relation);
+
+ SingleLockReln((LockInfo)relation->lockInfo, WRITE_LOCK+INTENT, UNLOCK);
+}
+
+/*
+ * Extend locks are used primarily in tertiary storage devices such as
+ * a WORM disk jukebox. Sometimes need exclusive access to extend a
+ * file by a block.
+ */
+void
+RelationSetLockForExtend(Relation relation)
+{
+ /* -----------------
+ * Sanity check
+ * -----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled())
+ return;
+
+ if (!LockInfoIsValid(relation->lockInfo))
+ RelationInitLockInfo(relation);
+
+ MultiLockReln((LockInfo) relation->lockInfo, EXTEND_LOCK);
+}
+
+void
+RelationUnsetLockForExtend(Relation relation)
+{
+ /* -----------------
+ * Sanity check
+ * -----------------
+ */
+ Assert(RelationIsValid(relation));
+ if (LockingDisabled())
+ return;
+
+ if (!LockInfoIsValid(relation->lockInfo))
+ RelationInitLockInfo(relation);
+
+ MultiReleaseReln((LockInfo) relation->lockInfo, EXTEND_LOCK);
+}
+
+/*
+ * Create an LRelid --- Why not just pass in a pointer to the storage?
+ */
+void
+LRelIdAssign(LRelId *lRelId, Oid dbId, Oid relId)
+{
+ lRelId->dbId = dbId;
+ lRelId->relId = relId;
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * lock.c--
+ * simple lock acquisition
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.1.1.1 1996/07/09 06:21:56 scrappy Exp $
+ *
+ * NOTES
+ * Outside modules can create a lock table and acquire/release
+ * locks. A lock table is a shared memory hash table. When
+ * a process tries to acquire a lock of a type that conflicts
+ * with existing locks, it is put to sleep using the routines
+ * in storage/lmgr/proc.c.
+ *
+ * Interface:
+ *
+ * LockAcquire(), LockRelease(), LockTabInit().
+ *
+ * LockReplace() is called only within this module and by the
+ * lkchain module. It releases a lock without looking
+ * the lock up in the lock table.
+ *
+ * NOTE: This module is used to define new lock tables. The
+ * multi-level lock table (multi.c) used by the heap
+ * access methods calls these routines. See multi.c for
+ * examples showing how to use this interface.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* for sprintf() */
+#include "storage/shmem.h"
+#include "storage/spin.h"
+#include "storage/proc.h"
+#include "storage/lock.h"
+#include "utils/hsearch.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "access/xact.h"
+
+/*#define LOCK_MGR_DEBUG*/
+
+#ifndef LOCK_MGR_DEBUG
+
+#define LOCK_PRINT(where,tag,type)
+#define LOCK_DUMP(where,lock,type)
+#define XID_PRINT(where,xidentP)
+
+#else /* LOCK_MGR_DEBUG */
+
+#define LOCK_PRINT(where,tag,type)\
+ elog(NOTICE, "%s: rel (%d) dbid (%d) tid (%d,%d) type (%d)\n",where, \
+ tag->relId, tag->dbId, \
+ ( (tag->tupleId.ip_blkid.data[0] >= 0) ? \
+ BlockIdGetBlockNumber(&tag->tupleId.ip_blkid) : -1 ), \
+ tag->tupleId.ip_posid, \
+ type);
+
+#define LOCK_DUMP(where,lock,type)\
+ elog(NOTICE, "%s: rel (%d) dbid (%d) tid (%d,%d) nHolding (%d) holders (%d,%d,%d,%d,%d) type (%d)\n",where, \
+ lock->tag.relId, lock->tag.dbId, \
+ ((lock->tag.tupleId.ip_blkid.data[0] >= 0) ? \
+ BlockIdGetBlockNumber(&lock->tag.tupleId.ip_blkid) : -1 ), \
+ lock->tag.tupleId.ip_posid, \
+ lock->nHolding,\
+ lock->holders[1],\
+ lock->holders[2],\
+ lock->holders[3],\
+ lock->holders[4],\
+ lock->holders[5],\
+ type);
+
+#define XID_PRINT(where,xidentP)\
+ elog(NOTICE,\
+ "%s:xid (%d) pid (%d) lock (%x) nHolding (%d) holders (%d,%d,%d,%d,%d)",\
+ where,\
+ xidentP->tag.xid,\
+ xidentP->tag.pid,\
+ xidentP->tag.lock,\
+ xidentP->nHolding,\
+ xidentP->holders[1],\
+ xidentP->holders[2],\
+ xidentP->holders[3],\
+ xidentP->holders[4],\
+ xidentP->holders[5]);
+
+#endif /* LOCK_MGR_DEBUG */
+
+SPINLOCK LockMgrLock; /* in Shmem or created in CreateSpinlocks() */
+
+/* This is to simplify/speed up some bit arithmetic */
+
+static MASK BITS_OFF[MAX_LOCKTYPES];
+static MASK BITS_ON[MAX_LOCKTYPES];
+
+/* -----------------
+ * XXX Want to move this to this file
+ * -----------------
+ */
+static bool LockingIsDisabled;
+
+/* ------------------
+ * from storage/ipc/shmem.c
+ * ------------------
+ */
+extern HTAB *ShmemInitHash();
+
+/* -------------------
+ * map from tableId to the lock table structure
+ * -------------------
+ */
+static LOCKTAB *AllTables[MAX_TABLES];
+
+/* -------------------
+ * no zero-th table
+ * -------------------
+ */
+static int NumTables = 1;
+
+/* -------------------
+ * InitLocks -- Init the lock module. Create a private data
+ * structure for constructing conflict masks.
+ * -------------------
+ */
+void
+InitLocks()
+{
+ int i;
+ int bit;
+
+ bit = 1;
+ /* -------------------
+ * remember 0th locktype is invalid
+ * -------------------
+ */
+ for (i=0;i
+ {
+ BITS_ON[i] = bit;
+ BITS_OFF[i] = ~bit;
+ }
+}
+
+/* -------------------
+ * LockDisable -- sets LockingIsDisabled flag to TRUE or FALSE.
+ * ------------------
+ */
+void
+LockDisable(int status)
+{
+ LockingIsDisabled = status;
+}
+
+
+/*
+ * LockTypeInit -- initialize the lock table's lock type
+ * structures
+ *
+ * Notes: just copying. Should only be called once.
+ */
+static void
+LockTypeInit(LOCKTAB *ltable,
+ MASK *conflictsP,
+ int *prioP,
+ int ntypes)
+{
+ int i;
+
+ ltable->ctl->nLockTypes = ntypes;
+ ntypes++;
+ for (i=0;i
+ {
+ ltable->ctl->conflictTab[i] = *conflictsP;
+ ltable->ctl->prio[i] = *prioP;
+ }
+}
+
+/*
+ * LockTabInit -- initialize a lock table structure
+ *
+ * Notes:
+ * (a) a lock table has four separate entries in the binding
+ * table. This is because every shared hash table and spinlock
+ * has its name stored in the binding table at its creation. It
+ * is wasteful, in this case, but not much space is involved.
+ *
+ */
+LockTableId
+LockTabInit(char *tabName,
+ MASK *conflictsP,
+ int *prioP,
+ int ntypes)
+{
+ LOCKTAB *ltable;
+ char *shmemName;
+ HASHCTL info;
+ int hash_flags;
+ bool found;
+ int status = TRUE;
+
+ if (ntypes > MAX_LOCKTYPES)
+ {
+ elog(NOTICE,"LockTabInit: too many lock types %d greater than %d",
+ ntypes,MAX_LOCKTYPES);
+ return(INVALID_TABLEID);
+ }
+
+ if (NumTables > MAX_TABLES)
+ {
+ elog(NOTICE,
+ "LockTabInit: system limit of MAX_TABLES (%d) lock tables",
+ MAX_TABLES);
+ return(INVALID_TABLEID);
+ }
+
+ /* allocate a string for the binding table lookup */
+ shmemName = (char *) palloc((unsigned)(strlen(tabName)+32));
+ if (! shmemName)
+ {
+ elog(NOTICE,"LockTabInit: couldn't malloc string %s \n",tabName);
+ return(INVALID_TABLEID);
+ }
+
+ /* each lock table has a non-shared header */
+ ltable = (LOCKTAB *) palloc((unsigned) sizeof(LOCKTAB));
+ if (! ltable)
+ {
+ elog(NOTICE,"LockTabInit: couldn't malloc lock table %s\n",tabName);
+ (void) pfree (shmemName);
+ return(INVALID_TABLEID);
+ }
+
+ /* ------------------------
+ * find/acquire the spinlock for the table
+ * ------------------------
+ */
+ SpinAcquire(LockMgrLock);
+
+
+ /* -----------------------
+ * allocate a control structure from shared memory or attach to it
+ * if it already exists.
+ * -----------------------
+ */
+ sprintf(shmemName,"%s (ctl)",tabName);
+ ltable->ctl = (LOCKCTL *)
+ ShmemInitStruct(shmemName,(unsigned)sizeof(LOCKCTL),&found);
+
+ if (! ltable->ctl)
+ {
+ elog(FATAL,"LockTabInit: couldn't initialize %s",tabName);
+ status = FALSE;
+ }
+
+ /* ----------------
+ * we're first - initialize
+ * ----------------
+ */
+ if (! found)
+ {
+ memset(ltable->ctl, 0, sizeof(LOCKCTL));
+ ltable->ctl->masterLock = LockMgrLock;
+ ltable->ctl->tableId = NumTables;
+ }
+
+ /* --------------------
+ * other modules refer to the lock table by a tableId
+ * --------------------
+ */
+ AllTables[NumTables] = ltable;
+ NumTables++;
+ Assert(NumTables <= MAX_TABLES);
+
+ /* ----------------------
+ * allocate a hash table for the lock tags. This is used
+ * to find the different locks.
+ * ----------------------
+ */
+ info.keysize = sizeof(LOCKTAG);
+ info.datasize = sizeof(LOCK);
+ info.hash = tag_hash;
+ hash_flags = (HASH_ELEM | HASH_FUNCTION);
+
+ sprintf(shmemName,"%s (lock hash)",tabName);
+ ltable->lockHash = (HTAB *) ShmemInitHash(shmemName,
+ INIT_TABLE_SIZE,MAX_TABLE_SIZE,
+ &info,hash_flags);
+
+ Assert( ltable->lockHash->hash == tag_hash);
+ if (! ltable->lockHash)
+ {
+ elog(FATAL,"LockTabInit: couldn't initialize %s",tabName);
+ status = FALSE;
+ }
+
+ /* -------------------------
+ * allocate an xid table. When different transactions hold
+ * the same lock, additional information must be saved (locks per tx).
+ * -------------------------
+ */
+ info.keysize = XID_TAGSIZE;
+ info.datasize = sizeof(XIDLookupEnt);
+ info.hash = tag_hash;
+ hash_flags = (HASH_ELEM | HASH_FUNCTION);
+
+ sprintf(shmemName,"%s (xid hash)",tabName);
+ ltable->xidHash = (HTAB *) ShmemInitHash(shmemName,
+ INIT_TABLE_SIZE,MAX_TABLE_SIZE,
+ &info,hash_flags);
+
+ if (! ltable->xidHash)
+ {
+ elog(FATAL,"LockTabInit: couldn't initialize %s",tabName);
+ status = FALSE;
+ }
+
+ /* init ctl data structures */
+ LockTypeInit(ltable, conflictsP, prioP, ntypes);
+
+ SpinRelease(LockMgrLock);
+
+ (void) pfree (shmemName);
+
+ if (status)
+ return(ltable->ctl->tableId);
+ else
+ return(INVALID_TABLEID);
+}
+
+/*
+ * LockTabRename -- allocate another tableId to the same
+ * lock table.
+ *
+ * NOTES: Both the lock module and the lock chain (lchain.c)
+ * module use table id's to distinguish between different
+ * kinds of locks. Short term and long term locks look
+ * the same to the lock table, but are handled differently
+ * by the lock chain manager. This function allows the
+ * client to use different tableIds when acquiring/releasing
+ * short term and long term locks.
+ */
+LockTableId
+LockTabRename(LockTableId tableId)
+{
+ LockTableId newTableId;
+
+ if (NumTables >= MAX_TABLES)
+ {
+ return(INVALID_TABLEID);
+ }
+ if (AllTables[tableId] == INVALID_TABLEID)
+ {
+ return(INVALID_TABLEID);
+ }
+
+ /* other modules refer to the lock table by a tableId */
+ newTableId = NumTables;
+ NumTables++;
+
+ AllTables[newTableId] = AllTables[tableId];
+ return(newTableId);
+}
+
+/*
+ * LockAcquire -- Check for lock conflicts, sleep if conflict found,
+ * set lock if/when no conflicts.
+ *
+ * Returns: TRUE if parameters are correct, FALSE otherwise.
+ *
+ * Side Effects: The lock is always acquired. No way to abort
+ * a lock acquisition other than aborting the transaction.
+ * Lock is recorded in the lkchain.
+ */
+bool
+LockAcquire(LockTableId tableId, LOCKTAG *lockName, LOCKT lockt)
+{
+ XIDLookupEnt *result,item;
+ HTAB *xidTable;
+ bool found;
+ LOCK *lock = NULL;
+ SPINLOCK masterLock;
+ LOCKTAB *ltable;
+ int status;
+ TransactionId myXid;
+
+ Assert (tableId < NumTables);
+ ltable = AllTables[tableId];
+ if (!ltable)
+ {
+ elog(NOTICE,"LockAcquire: bad lock table %d",tableId);
+ return (FALSE);
+ }
+
+ if (LockingIsDisabled)
+ {
+ return(TRUE);
+ }
+
+ LOCK_PRINT("Acquire",lockName,lockt);
+ masterLock = ltable->ctl->masterLock;
+
+ SpinAcquire(masterLock);
+
+ Assert( ltable->lockHash->hash == tag_hash);
+ lock = (LOCK *)hash_search(ltable->lockHash,(Pointer)lockName,HASH_ENTER,&found);
+
+ if (! lock)
+ {
+ SpinRelease(masterLock);
+ elog(FATAL,"LockAcquire: lock table %d is corrupted",tableId);
+ return(FALSE);
+ }
+
+ /* --------------------
+ * if there was nothing else there, complete initialization
+ * --------------------
+ */
+ if (! found)
+ {
+ lock->mask = 0;
+ ProcQueueInit(&(lock->waitProcs));
+ memset((char *)lock->holders, 0, sizeof(int)*MAX_LOCKTYPES);
+ memset((char *)lock->activeHolders, 0, sizeof(int)*MAX_LOCKTYPES);
+ lock->nHolding = 0;
+ lock->nActive = 0;
+
+ Assert(BlockIdEquals(&(lock->tag.tupleId.ip_blkid),
+ &(lockName->tupleId.ip_blkid)));
+
+ }
+
+ /* ------------------
+ * add an element to the lock queue so that we can clear the
+ * locks at end of transaction.
+ * ------------------
+ */
+ xidTable = ltable->xidHash;
+ myXid = GetCurrentTransactionId();
+
+ /* ------------------
+ * Zero out all of the tag bytes (this clears the padding bytes for long
+ * word alignment and ensures hashing consistency).
+ * ------------------
+ */
+ memset(&item, 0, XID_TAGSIZE);
+ TransactionIdStore(myXid, &item.tag.xid);
+ item.tag.lock = MAKE_OFFSET(lock);
+#if 0
+ item.tag.pid = MyPid;
+#endif
+
+ result = (XIDLookupEnt *)hash_search(xidTable, (Pointer)&item, HASH_ENTER, &found);
+ if (!result)
+ {
+ elog(NOTICE,"LockAcquire: xid table corrupted");
+ return(STATUS_ERROR);
+ }
+ if (!found)
+ {
+ XID_PRINT("queueing XidEnt LockAcquire:", result);
+ ProcAddLock(&result->queue);
+ result->nHolding = 0;
+ memset((char *)result->holders, 0, sizeof(int)*MAX_LOCKTYPES);
+ }
+
+ /* ----------------
+ * lock->nholding tells us how many processes have _tried_ to
+ * acquire this lock, Regardless of whether they succeeded or
+ * failed in doing so.
+ * ----------------
+ */
+ lock->nHolding++;
+ lock->holders[lockt]++;
+
+ /* --------------------
+ * If I'm the only one holding a lock, then there
+ * cannot be a conflict. Need to subtract one from the
+ * lock's count since we just bumped the count up by 1
+ * above.
+ * --------------------
+ */
+ if (result->nHolding == lock->nActive)
+ {
+ result->holders[lockt]++;
+ result->nHolding++;
+ GrantLock(lock, lockt);
+ SpinRelease(masterLock);
+ return(TRUE);
+ }
+
+ Assert(result->nHolding <= lock->nActive);
+
+ status = LockResolveConflicts(ltable, lock, lockt, myXid);
+
+ if (status == STATUS_OK)
+ {
+ GrantLock(lock, lockt);
+ }
+ else if (status == STATUS_FOUND)
+ {
+ status = WaitOnLock(ltable, tableId, lock, lockt);
+ XID_PRINT("Someone granted me the lock", result);
+ }
+
+ SpinRelease(masterLock);
+
+ return(status == STATUS_OK);
+}
+
+/* ----------------------------
+ * LockResolveConflicts -- test for lock conflicts
+ *
+ * NOTES:
+ * Here's what makes this complicated: one transaction's
+ * locks don't conflict with one another. When many processes
+ * hold locks, each has to subtract off the other's locks when
+ * determining whether or not any new lock acquired conflicts with
+ * the old ones.
+ *
+ * For example, if I am already holding a WRITE_INTENT lock,
+ * there will not be a conflict with my own READ_LOCK. If I
+ * don't consider the intent lock when checking for conflicts,
+ * I find no conflict.
+ * ----------------------------
+ */
+int
+LockResolveConflicts(LOCKTAB *ltable,
+ LOCK *lock,
+ LOCKT lockt,
+ TransactionId xid)
+{
+ XIDLookupEnt *result,item;
+ int *myHolders;
+ int nLockTypes;
+ HTAB *xidTable;
+ bool found;
+ int bitmask;
+ int i,tmpMask;
+
+ nLockTypes = ltable->ctl->nLockTypes;
+ xidTable = ltable->xidHash;
+
+ /* ---------------------
+ * read my own statistics from the xid table. If there
+ * isn't an entry, then we'll just add one.
+ *
+ * Zero out the tag, this clears the padding bytes for long
+ * word alignment and ensures hashing consistency.
+ * ------------------
+ */
+ memset(&item, 0, XID_TAGSIZE);
+ TransactionIdStore(xid, &item.tag.xid);
+ item.tag.lock = MAKE_OFFSET(lock);
+#if 0
+ item.tag.pid = pid;
+#endif
+
+ if (! (result = (XIDLookupEnt *)
+ hash_search(xidTable, (Pointer)&item, HASH_ENTER, &found)))
+ {
+ elog(NOTICE,"LockResolveConflicts: xid table corrupted");
+ return(STATUS_ERROR);
+ }
+ myHolders = result->holders;
+
+ if (! found)
+ {
+ /* ---------------
+ * we're not holding any type of lock yet. Clear
+ * the lock stats.
+ * ---------------
+ */
+ memset(result->holders, 0, nLockTypes * sizeof(*(lock->holders)));
+ result->nHolding = 0;
+ }
+
+ /* ----------------------------
+ * first check for global conflicts: If no locks conflict
+ * with mine, then I get the lock.
+ *
+ * Checking for conflict: lock->mask represents the types of
+ * currently held locks. conflictTable[lockt] has a bit
+ * set for each type of lock that conflicts with mine. Bitwise
+ * compare tells if there is a conflict.
+ * ----------------------------
+ */
+ if (! (ltable->ctl->conflictTab[lockt] & lock->mask))
+ {
+
+ result->holders[lockt]++;
+ result->nHolding++;
+
+ XID_PRINT("Conflict Resolved: updated xid entry stats", result);
+
+ return(STATUS_OK);
+ }
+
+ /* ------------------------
+ * Rats. Something conflicts. But it could still be my own
+ * lock. We have to construct a conflict mask
+ * that does not reflect our own locks.
+ * ------------------------
+ */
+ bitmask = 0;
+ tmpMask = 2;
+ for (i=1;i<=nLockTypes;i++, tmpMask <<= 1)
+ {
+ if (lock->activeHolders[i] - myHolders[i])
+ {
+ bitmask |= tmpMask;
+ }
+ }
+
+ /* ------------------------
+ * now check again for conflicts. 'bitmask' describes the types
+ * of locks held by other processes. If one of these
+ * conflicts with the kind of lock that I want, there is a
+ * conflict and I have to sleep.
+ * ------------------------
+ */
+ if (! (ltable->ctl->conflictTab[lockt] & bitmask))
+ {
+
+ /* no conflict. Get the lock and go on */
+
+ result->holders[lockt]++;
+ result->nHolding++;
+
+ XID_PRINT("Conflict Resolved: updated xid entry stats", result);
+
+ return(STATUS_OK);
+
+ }
+
+ return(STATUS_FOUND);
+}
+
+int
+WaitOnLock(LOCKTAB *ltable, LockTableId tableId, LOCK *lock, LOCKT lockt)
+{
+ PROC_QUEUE *waitQueue = &(lock->waitProcs);
+
+ int prio = ltable->ctl->prio[lockt];
+
+ /* the waitqueue is ordered by priority. I insert myself
+ * according to the priority of the lock I am acquiring.
+ *
+ * SYNC NOTE: I am assuming that the lock table spinlock
+ * is sufficient synchronization for this queue. That
+ * will not be true if/when people can be deleted from
+ * the queue by a SIGINT or something.
+ */
+ LOCK_DUMP("WaitOnLock: sleeping on lock", lock, lockt);
+ if (ProcSleep(waitQueue,
+ ltable->ctl->masterLock,
+ lockt,
+ prio,
+ lock) != NO_ERROR)
+ {
+ /* -------------------
+ * This could have happend as a result of a deadlock, see HandleDeadLock()
+ * Decrement the lock nHolding and holders fields as we are no longer
+ * waiting on this lock.
+ * -------------------
+ */
+ lock->nHolding--;
+ lock->holders[lockt]--;
+ LOCK_DUMP("WaitOnLock: aborting on lock", lock, lockt);
+ SpinRelease(ltable->ctl->masterLock);
+ elog(WARN,"WaitOnLock: error on wakeup - Aborting this transaction");
+ }
+
+ return(STATUS_OK);
+}
+
+/*
+ * LockRelease -- look up 'lockName' in lock table 'tableId' and
+ * release it.
+ *
+ * Side Effects: if the lock no longer conflicts with the highest
+ * priority waiting process, that process is granted the lock
+ * and awoken. (We have to grant the lock here to avoid a
+ * race between the waking process and any new process to
+ * come along and request the lock).
+ */
+bool
+LockRelease(LockTableId tableId, LOCKTAG *lockName, LOCKT lockt)
+{
+ LOCK *lock = NULL;
+ SPINLOCK masterLock;
+ bool found;
+ LOCKTAB *ltable;
+ XIDLookupEnt *result,item;
+ HTAB *xidTable;
+ bool wakeupNeeded = true;
+
+ Assert (tableId < NumTables);
+ ltable = AllTables[tableId];
+ if (!ltable) {
+ elog(NOTICE, "ltable is null in LockRelease");
+ return (FALSE);
+ }
+
+ if (LockingIsDisabled)
+ {
+ return(TRUE);
+ }
+
+ LOCK_PRINT("Release",lockName,lockt);
+
+ masterLock = ltable->ctl->masterLock;
+ xidTable = ltable->xidHash;
+
+ SpinAcquire(masterLock);
+
+ Assert( ltable->lockHash->hash == tag_hash);
+ lock = (LOCK *)
+ hash_search(ltable->lockHash,(Pointer)lockName,HASH_FIND_SAVE,&found);
+
+ /* let the caller print its own error message, too.
+ * Do not elog(WARN).
+ */
+ if (! lock)
+ {
+ SpinRelease(masterLock);
+ elog(NOTICE,"LockRelease: locktable corrupted");
+ return(FALSE);
+ }
+
+ if (! found)
+ {
+ SpinRelease(masterLock);
+ elog(NOTICE,"LockRelease: locktable lookup failed, no lock");
+ return(FALSE);
+ }
+
+ Assert(lock->nHolding > 0);
+
+ /*
+ * fix the general lock stats
+ */
+ lock->nHolding--;
+ lock->holders[lockt]--;
+ lock->nActive--;
+ lock->activeHolders[lockt]--;
+
+ Assert(lock->nActive >= 0);
+
+ if (! lock->nHolding)
+ {
+ /* ------------------
+ * if there's no one waiting in the queue,
+ * we just released the last lock.
+ * Delete it from the lock table.
+ * ------------------
+ */
+ Assert( ltable->lockHash->hash == tag_hash);
+ lock = (LOCK *) hash_search(ltable->lockHash,
+ (Pointer) &(lock->tag),
+ HASH_REMOVE_SAVED,
+ &found);
+ Assert(lock && found);
+ wakeupNeeded = false;
+ }
+
+ /* ------------------
+ * Zero out all of the tag bytes (this clears the padding bytes for long
+ * word alignment and ensures hashing consistency).
+ * ------------------
+ */
+ memset(&item, 0, XID_TAGSIZE);
+
+ TransactionIdStore(GetCurrentTransactionId(), &item.tag.xid);
+ item.tag.lock = MAKE_OFFSET(lock);
+#if 0
+ item.tag.pid = MyPid;
+#endif
+
+ if (! ( result = (XIDLookupEnt *) hash_search(xidTable,
+ (Pointer)&item,
+ HASH_FIND_SAVE,
+ &found) )
+ || !found)
+ {
+ SpinRelease(masterLock);
+ elog(NOTICE,"LockReplace: xid table corrupted");
+ return(FALSE);
+ }
+ /*
+ * now check to see if I have any private locks. If I do,
+ * decrement the counts associated with them.
+ */
+ result->holders[lockt]--;
+ result->nHolding--;
+
+ XID_PRINT("LockRelease updated xid stats", result);
+
+ /*
+ * If this was my last hold on this lock, delete my entry
+ * in the XID table.
+ */
+ if (! result->nHolding)
+ {
+ if (result->queue.next != INVALID_OFFSET)
+ SHMQueueDelete(&result->queue);
+ if (! (result = (XIDLookupEnt *)
+ hash_search(xidTable, (Pointer)&item, HASH_REMOVE_SAVED, &found)) ||
+ ! found)
+ {
+ SpinRelease(masterLock);
+ elog(NOTICE,"LockReplace: xid table corrupted");
+ return(FALSE);
+ }
+ }
+
+ /* --------------------------
+ * If there are still active locks of the type I just released, no one
+ * should be woken up. Whoever is asleep will still conflict
+ * with the remaining locks.
+ * --------------------------
+ */
+ if (! (lock->activeHolders[lockt]))
+ {
+ /* change the conflict mask. No more of this lock type. */
+ lock->mask &= BITS_OFF[lockt];
+ }
+
+ if (wakeupNeeded)
+ {
+ /* --------------------------
+ * Wake the first waiting process and grant him the lock if it
+ * doesn't conflict. The woken process must record the lock
+ * himself.
+ * --------------------------
+ */
+ (void) ProcLockWakeup(&(lock->waitProcs), (char *) ltable, (char *) lock);
+ }
+
+ SpinRelease(masterLock);
+ return(TRUE);
+}
+
+/*
+ * GrantLock -- udpate the lock data structure to show
+ * the new lock holder.
+ */
+void
+GrantLock(LOCK *lock, LOCKT lockt)
+{
+ lock->nActive++;
+ lock->activeHolders[lockt]++;
+ lock->mask |= BITS_ON[lockt];
+}
+
+bool
+LockReleaseAll(LockTableId tableId, SHM_QUEUE *lockQueue)
+{
+ PROC_QUEUE *waitQueue;
+ int done;
+ XIDLookupEnt *xidLook = NULL;
+ XIDLookupEnt *tmp = NULL;
+ SHMEM_OFFSET end = MAKE_OFFSET(lockQueue);
+ SPINLOCK masterLock;
+ LOCKTAB *ltable;
+ int i,nLockTypes;
+ LOCK *lock;
+ bool found;
+
+ Assert (tableId < NumTables);
+ ltable = AllTables[tableId];
+ if (!ltable)
+ return (FALSE);
+
+ nLockTypes = ltable->ctl->nLockTypes;
+ masterLock = ltable->ctl->masterLock;
+
+ if (SHMQueueEmpty(lockQueue))
+ return TRUE;
+
+ SHMQueueFirst(lockQueue,(Pointer*)&xidLook,&xidLook->queue);
+
+ XID_PRINT("LockReleaseAll:", xidLook);
+
+ SpinAcquire(masterLock);
+ for (;;)
+ {
+ /* ---------------------------
+ * XXX Here we assume the shared memory queue is circular and
+ * that we know its internal structure. Should have some sort of
+ * macros to allow one to walk it. mer 20 July 1991
+ * ---------------------------
+ */
+ done = (xidLook->queue.next == end);
+ lock = (LOCK *) MAKE_PTR(xidLook->tag.lock);
+
+ LOCK_PRINT("ReleaseAll",(&lock->tag),0);
+
+ /* ------------------
+ * fix the general lock stats
+ * ------------------
+ */
+ if (lock->nHolding != xidLook->nHolding)
+ {
+ lock->nHolding -= xidLook->nHolding;
+ lock->nActive -= xidLook->nHolding;
+ Assert(lock->nActive >= 0);
+ for (i=1; i<=nLockTypes; i++)
+ {
+ lock->holders[i] -= xidLook->holders[i];
+ lock->activeHolders[i] -= xidLook->holders[i];
+ if (! lock->activeHolders[i])
+ lock->mask &= BITS_OFF[i];
+ }
+ }
+ else
+ {
+ /* --------------
+ * set nHolding to zero so that we can garbage collect the lock
+ * down below...
+ * --------------
+ */
+ lock->nHolding = 0;
+ }
+ /* ----------------
+ * always remove the xidLookup entry, we're done with it now
+ * ----------------
+ */
+ if ((! hash_search(ltable->xidHash, (Pointer)xidLook, HASH_REMOVE, &found))
+ || !found)
+ {
+ SpinRelease(masterLock);
+ elog(NOTICE,"LockReplace: xid table corrupted");
+ return(FALSE);
+ }
+
+ if (! lock->nHolding)
+ {
+ /* --------------------
+ * if there's no one waiting in the queue, we've just released
+ * the last lock.
+ * --------------------
+ */
+
+ Assert( ltable->lockHash->hash == tag_hash);
+ lock = (LOCK *)
+ hash_search(ltable->lockHash,(Pointer)&(lock->tag),HASH_REMOVE, &found);
+ if ((! lock) || (!found))
+ {
+ SpinRelease(masterLock);
+ elog(NOTICE,"LockReplace: cannot remove lock from HTAB");
+ return(FALSE);
+ }
+ }
+ else
+ {
+ /* --------------------
+ * Wake the first waiting process and grant him the lock if it
+ * doesn't conflict. The woken process must record the lock
+ * him/herself.
+ * --------------------
+ */
+ waitQueue = &(lock->waitProcs);
+ (void) ProcLockWakeup(waitQueue, (char *) ltable, (char *) lock);
+ }
+
+ if (done)
+ break;
+ SHMQueueFirst(&xidLook->queue,(Pointer*)&tmp,&tmp->queue);
+ xidLook = tmp;
+ }
+ SpinRelease(masterLock);
+ SHMQueueInit(lockQueue);
+ return TRUE;
+}
+
+int
+LockShmemSize()
+{
+ int size = 0;
+ int nLockBuckets, nLockSegs;
+ int nXidBuckets, nXidSegs;
+
+ nLockBuckets = 1 << (int)my_log2((NLOCKENTS - 1) / DEF_FFACTOR + 1);
+ nLockSegs = 1 << (int)my_log2((nLockBuckets - 1) / DEF_SEGSIZE + 1);
+
+ nXidBuckets = 1 << (int)my_log2((NLOCKS_PER_XACT-1) / DEF_FFACTOR + 1);
+ nXidSegs = 1 << (int)my_log2((nLockBuckets - 1) / DEF_SEGSIZE + 1);
+
+ size += MAXALIGN(NBACKENDS * sizeof(PROC)); /* each MyProc */
+ size += MAXALIGN(NBACKENDS * sizeof(LOCKCTL)); /* each ltable->ctl */
+ size += MAXALIGN(sizeof(PROC_HDR)); /* ProcGlobal */
+
+ size += MAXALIGN(my_log2(NLOCKENTS) * sizeof(void *));
+ size += MAXALIGN(sizeof(HHDR));
+ size += nLockSegs * MAXALIGN(DEF_SEGSIZE * sizeof(SEGMENT));
+ size += NLOCKENTS * /* XXX not multiple of BUCKET_ALLOC_INCR? */
+ (MAXALIGN(sizeof(BUCKET_INDEX)) +
+ MAXALIGN(sizeof(LOCK))); /* contains hash key */
+
+ size += MAXALIGN(my_log2(NBACKENDS) * sizeof(void *));
+ size += MAXALIGN(sizeof(HHDR));
+ size += nXidSegs * MAXALIGN(DEF_SEGSIZE * sizeof(SEGMENT));
+ size += NBACKENDS * /* XXX not multiple of BUCKET_ALLOC_INCR? */
+ (MAXALIGN(sizeof(BUCKET_INDEX)) +
+ MAXALIGN(sizeof(XIDLookupEnt))); /* contains hash key */
+
+ return size;
+}
+
+/* -----------------
+ * Boolean function to determine current locking status
+ * -----------------
+ */
+bool
+LockingDisabled()
+{
+ return LockingIsDisabled;
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * multi.c--
+ * multi level lock table manager
+ *
+ * Standard multi-level lock manager as per the Gray paper
+ * (at least, that is what it is supposed to be). We implement
+ * three levels -- RELN, PAGE, TUPLE. Tuple is actually TID
+ * a physical record pointer. It isn't an object id.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/Attic/multi.c,v 1.1.1.1 1996/07/09 06:21:56 scrappy Exp $
+ *
+ * NOTES:
+ * (1) The lock.c module assumes that the caller here is doing
+ * two phase locking.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include "storage/lmgr.h"
+#include "storage/multilev.h"
+
+#include "utils/rel.h"
+#include "utils/elog.h"
+#include "miscadmin.h" /* MyDatabaseId */
+
+
+/*
+ * INTENT indicates to higher level that a lower level lock has been
+ * set. For example, a write lock on a tuple conflicts with a write
+ * lock on a relation. This conflict is detected as a WRITE_INTENT/
+ * WRITE conflict between the tuple's intent lock and the relation's
+ * write lock.
+ */
+static int MultiConflicts[] = {
+ (int)NULL,
+ /* All reads and writes at any level conflict with a write lock */
+ (1 << WRITE_LOCK)|(1 << WRITE_INTENT)|(1 << READ_LOCK)|(1 << READ_INTENT),
+ /* read locks conflict with write locks at curr and lower levels */
+ (1 << WRITE_LOCK)| (1 << WRITE_INTENT),
+ /* write intent locks */
+ (1 << READ_LOCK) | (1 << WRITE_LOCK),
+ /* read intent locks*/
+ (1 << WRITE_LOCK),
+ /* extend locks for archive storage manager conflict only w/extend locks */
+ (1 << EXTEND_LOCK)
+};
+
+/*
+ * write locks have higher priority than read locks and extend locks. May
+ * want to treat INTENT locks differently.
+ */
+static int MultiPrios[] = {
+ (int)NULL,
+ 2,
+ 1,
+ 2,
+ 1,
+ 1
+};
+
+/*
+ * Lock table identifier for this lock table. The multi-level
+ * lock table is ONE lock table, not three.
+ */
+LockTableId MultiTableId = (LockTableId)NULL;
+LockTableId ShortTermTableId = (LockTableId)NULL;
+
+/*
+ * Create the lock table described by MultiConflicts and Multiprio.
+ */
+LockTableId
+InitMultiLevelLockm()
+{
+ int tableId;
+
+ /* -----------------------
+ * If we're already initialized just return the table id.
+ * -----------------------
+ */
+ if (MultiTableId)
+ return MultiTableId;
+
+ tableId = LockTabInit("LockTable", MultiConflicts, MultiPrios, 5);
+ MultiTableId = tableId;
+ if (! (MultiTableId)) {
+ elog(WARN,"InitMultiLockm: couldnt initialize lock table");
+ }
+ /* -----------------------
+ * No short term lock table for now. -Jeff 15 July 1991
+ *
+ * ShortTermTableId = LockTabRename(tableId);
+ * if (! (ShortTermTableId)) {
+ * elog(WARN,"InitMultiLockm: couldnt rename lock table");
+ * }
+ * -----------------------
+ */
+ return MultiTableId;
+}
+
+/*
+ * MultiLockReln -- lock a relation
+ *
+ * Returns: TRUE if the lock can be set, FALSE otherwise.
+ */
+bool
+MultiLockReln(LockInfo linfo, LOCKT lockt)
+{
+ LOCKTAG tag;
+
+ /* LOCKTAG has two bytes of padding, unfortunately. The
+ * hash function will return miss if the padding bytes aren't
+ * zero'd.
+ */
+ memset(&tag,0,sizeof(tag));
+ tag.relId = linfo->lRelId.relId;
+ tag.dbId = linfo->lRelId.dbId;
+ return(MultiAcquire(MultiTableId, &tag, lockt, RELN_LEVEL));
+}
+
+/*
+ * MultiLockTuple -- Lock the TID associated with a tuple
+ *
+ * Returns: TRUE if lock is set, FALSE otherwise.
+ *
+ * Side Effects: causes intention level locks to be set
+ * at the page and relation level.
+ */
+bool
+MultiLockTuple(LockInfo linfo, ItemPointer tidPtr, LOCKT lockt)
+{
+ LOCKTAG tag;
+
+ /* LOCKTAG has two bytes of padding, unfortunately. The
+ * hash function will return miss if the padding bytes aren't
+ * zero'd.
+ */
+ memset(&tag,0,sizeof(tag));
+
+ tag.relId = linfo->lRelId.relId;
+ tag.dbId = linfo->lRelId.dbId;
+
+ /* not locking any valid Tuple, just the page */
+ tag.tupleId = *tidPtr;
+ return(MultiAcquire(MultiTableId, &tag, lockt, TUPLE_LEVEL));
+}
+
+/*
+ * same as above at page level
+ */
+bool
+MultiLockPage(LockInfo linfo, ItemPointer tidPtr, LOCKT lockt)
+{
+ LOCKTAG tag;
+
+ /* LOCKTAG has two bytes of padding, unfortunately. The
+ * hash function will return miss if the padding bytes aren't
+ * zero'd.
+ */
+ memset(&tag,0,sizeof(tag));
+
+
+ /* ----------------------------
+ * Now we want to set the page offset to be invalid
+ * and lock the block. There is some confusion here as to what
+ * a page is. In Postgres a page is an 8k block, however this
+ * block may be partitioned into many subpages which are sometimes
+ * also called pages. The term is overloaded, so don't be fooled
+ * when we say lock the page we mean the 8k block. -Jeff 16 July 1991
+ * ----------------------------
+ */
+ tag.relId = linfo->lRelId.relId;
+ tag.dbId = linfo->lRelId.dbId;
+ BlockIdCopy(&(tag.tupleId.ip_blkid), &(tidPtr->ip_blkid));
+ return(MultiAcquire(MultiTableId, &tag, lockt, PAGE_LEVEL));
+}
+
+/*
+ * MultiAcquire -- acquire multi level lock at requested level
+ *
+ * Returns: TRUE if lock is set, FALSE if not
+ * Side Effects:
+ */
+bool
+MultiAcquire(LockTableId tableId,
+ LOCKTAG *tag,
+ LOCKT lockt,
+ LOCK_LEVEL level)
+{
+ LOCKT locks[N_LEVELS];
+ int i,status;
+ LOCKTAG xxTag, *tmpTag = &xxTag;
+ int retStatus = TRUE;
+
+ /*
+ * Three levels implemented. If we set a low level (e.g. Tuple)
+ * lock, we must set INTENT locks on the higher levels. The
+ * intent lock detects conflicts between the low level lock
+ * and an existing high level lock. For example, setting a
+ * write lock on a tuple in a relation is disallowed if there
+ * is an existing read lock on the entire relation. The
+ * write lock would set a WRITE + INTENT lock on the relation
+ * and that lock would conflict with the read.
+ */
+ switch (level) {
+ case RELN_LEVEL:
+ locks[0] = lockt;
+ locks[1] = NO_LOCK;
+ locks[2] = NO_LOCK;
+ break;
+ case PAGE_LEVEL:
+ locks[0] = lockt + INTENT;
+ locks[1] = lockt;
+ locks[2] = NO_LOCK;
+ break;
+ case TUPLE_LEVEL:
+ locks[0] = lockt + INTENT;
+ locks[1] = lockt + INTENT;
+ locks[2] = lockt;
+ break;
+ default:
+ elog(WARN,"MultiAcquire: bad lock level");
+ return(FALSE);
+ }
+
+ /*
+ * construct a new tag as we go. Always loop through all levels,
+ * but if we arent' seting a low level lock, locks[i] is set to
+ * NO_LOCK for the lower levels. Always start from the highest
+ * level and go to the lowest level.
+ */
+ memset(tmpTag,0,sizeof(*tmpTag));
+ tmpTag->relId = tag->relId;
+ tmpTag->dbId = tag->dbId;
+
+ for (i=0;i
+ if (locks[i] != NO_LOCK) {
+ switch (i) {
+ case RELN_LEVEL:
+ /* -------------
+ * Set the block # and offset to invalid
+ * -------------
+ */
+ BlockIdSet(&(tmpTag->tupleId.ip_blkid), InvalidBlockNumber);
+ tmpTag->tupleId.ip_posid = InvalidOffsetNumber;
+ break;
+ case PAGE_LEVEL:
+ /* -------------
+ * Copy the block #, set the offset to invalid
+ * -------------
+ */
+ BlockIdCopy(&(tmpTag->tupleId.ip_blkid),
+ &(tag->tupleId.ip_blkid));
+ tmpTag->tupleId.ip_posid = InvalidOffsetNumber;
+ break;
+ case TUPLE_LEVEL:
+ /* --------------
+ * Copy the entire tuple id.
+ * --------------
+ */
+ ItemPointerCopy(&tmpTag->tupleId, &tag->tupleId);
+ break;
+ }
+
+ status = LockAcquire(tableId, tmpTag, locks[i]);
+ if (! status) {
+ /* failed for some reason. Before returning we have
+ * to release all of the locks we just acquired.
+ * MultiRelease(xx,xx,xx, i) means release starting from
+ * the last level lock we successfully acquired
+ */
+ retStatus = FALSE;
+ (void) MultiRelease(tableId, tag, lockt, i);
+ /* now leave the loop. Don't try for any more locks */
+ break;
+ }
+ }
+ }
+ return(retStatus);
+}
+
+/* ------------------
+ * Release a page in the multi-level lock table
+ * ------------------
+ */
+bool
+MultiReleasePage(LockInfo linfo, ItemPointer tidPtr, LOCKT lockt)
+{
+ LOCKTAG tag;
+
+ /* ------------------
+ * LOCKTAG has two bytes of padding, unfortunately. The
+ * hash function will return miss if the padding bytes aren't
+ * zero'd.
+ * ------------------
+ */
+ memset(&tag, 0,sizeof(LOCKTAG));
+
+ tag.relId = linfo->lRelId.relId;
+ tag.dbId = linfo->lRelId.dbId;
+ BlockIdCopy(&(tag.tupleId.ip_blkid), &(tidPtr->ip_blkid));
+
+ return (MultiRelease(MultiTableId, &tag, lockt, PAGE_LEVEL));
+}
+
+/* ------------------
+ * Release a relation in the multi-level lock table
+ * ------------------
+ */
+bool
+MultiReleaseReln(LockInfo linfo, LOCKT lockt)
+{
+ LOCKTAG tag;
+
+ /* ------------------
+ * LOCKTAG has two bytes of padding, unfortunately. The
+ * hash function will return miss if the padding bytes aren't
+ * zero'd.
+ * ------------------
+ */
+ memset(&tag, 0, sizeof(LOCKTAG));
+ tag.relId = linfo->lRelId.relId;
+ tag.dbId = linfo->lRelId.dbId;
+
+ return (MultiRelease(MultiTableId, &tag, lockt, RELN_LEVEL));
+}
+
+/*
+ * MultiRelease -- release a multi-level lock
+ *
+ * Returns: TRUE if successful, FALSE otherwise.
+ */
+bool
+MultiRelease(LockTableId tableId,
+ LOCKTAG *tag,
+ LOCKT lockt,
+ LOCK_LEVEL level)
+{
+ LOCKT locks[N_LEVELS];
+ int i,status;
+ LOCKTAG xxTag, *tmpTag = &xxTag;
+
+ /*
+ * same level scheme as MultiAcquire().
+ */
+ switch (level) {
+ case RELN_LEVEL:
+ locks[0] = lockt;
+ locks[1] = NO_LOCK;
+ locks[2] = NO_LOCK;
+ break;
+ case PAGE_LEVEL:
+ locks[0] = lockt + INTENT;
+ locks[1] = lockt;
+ locks[2] = NO_LOCK;
+ break;
+ case TUPLE_LEVEL:
+ locks[0] = lockt + INTENT;
+ locks[1] = lockt + INTENT;
+ locks[2] = lockt;
+ break;
+ default:
+ elog(WARN,"MultiRelease: bad lockt");
+ }
+
+ /*
+ * again, construct the tag on the fly. This time, however,
+ * we release the locks in the REVERSE order -- from lowest
+ * level to highest level.
+ *
+ * Must zero out the tag to set padding byes to zero and ensure
+ * hashing consistency.
+ */
+ memset(tmpTag, 0, sizeof(*tmpTag));
+ tmpTag->relId = tag->relId;
+ tmpTag->dbId = tag->dbId;
+
+ for (i=(N_LEVELS-1); i>=0; i--) {
+ if (locks[i] != NO_LOCK) {
+ switch (i) {
+ case RELN_LEVEL:
+ /* -------------
+ * Set the block # and offset to invalid
+ * -------------
+ */
+ BlockIdSet(&(tmpTag->tupleId.ip_blkid), InvalidBlockNumber);
+ tmpTag->tupleId.ip_posid = InvalidOffsetNumber;
+ break;
+ case PAGE_LEVEL:
+ /* -------------
+ * Copy the block #, set the offset to invalid
+ * -------------
+ */
+ BlockIdCopy(&(tmpTag->tupleId.ip_blkid),
+ &(tag->tupleId.ip_blkid));
+ tmpTag->tupleId.ip_posid = InvalidOffsetNumber;
+ break;
+ case TUPLE_LEVEL:
+ ItemPointerCopy(&tmpTag->tupleId, &tag->tupleId);
+ break;
+ }
+ status = LockRelease(tableId, tmpTag, locks[i]);
+ if (! status) {
+ elog(WARN,"MultiRelease: couldn't release after error");
+ }
+ }
+ }
+ /* shouldn't reach here */
+ return false;
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * proc.c--
+ * routines to manage per-process shared memory data structure
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.1.1.1 1996/07/09 06:21:57 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ * Each postgres backend gets one of these. We'll use it to
+ * clean up after the process should the process suddenly die.
+ *
+ *
+ * Interface (a):
+ * ProcSleep(), ProcWakeup(), ProcWakeupNext(),
+ * ProcQueueAlloc() -- create a shm queue for sleeping processes
+ * ProcQueueInit() -- create a queue without allocing memory
+ *
+ * Locking and waiting for buffers can cause the backend to be
+ * put to sleep. Whoever releases the lock, etc. wakes the
+ * process up again (and gives it an error code so it knows
+ * whether it was awoken on an error condition).
+ *
+ * Interface (b):
+ *
+ * ProcReleaseLocks -- frees the locks associated with this process,
+ * ProcKill -- destroys the shared memory state (and locks)
+ * associated with the process.
+ *
+ * 5/15/91 -- removed the buffer pool based lock chain in favor
+ * of a shared memory lock chain. The write-protection is
+ * more expensive if the lock chain is in the buffer pool.
+ * The only reason I kept the lock chain in the buffer pool
+ * in the first place was to allow the lock table to grow larger
+ * than available shared memory and that isn't going to work
+ * without a lot of unimplemented support anyway.
+ *
+ * 4/7/95 -- instead of allocating a set of 1 semaphore per process, we
+ * allocate a semaphore from a set of PROC_NSEMS_PER_SET semaphores
+ * shared among backends (we keep a few sets of semaphores around).
+ * 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.1.1.1 1996/07/09 06:21:57 scrappy Exp $
+ */
+#include
+#ifndef WIN32
+#include
+#endif /* WIN32 */
+#include
+#include
+#include "libpq/pqsignal.h" /* substitute for */
+
+#if defined(PORTNAME_bsdi)
+/* hacka, hacka, hacka (XXX) */
+union semun {
+ int val; /* value for SETVAL */
+ struct semid_ds *buf; /* buffer for IPC_STAT & IPC_SET */
+ ushort *array; /* array for GETALL & SETALL */
+};
+#endif
+
+#include "access/xact.h"
+#include "utils/hsearch.h"
+#include "utils/elog.h"
+
+#include "storage/buf.h"
+#include "storage/lock.h"
+#include "storage/shmem.h"
+#include "storage/spin.h"
+#include "storage/proc.h"
+
+/*
+ * timeout (in seconds) for resolving possible deadlock
+ */
+#ifndef DEADLOCK_TIMEOUT
+#define DEADLOCK_TIMEOUT 60
+#endif
+
+/* --------------------
+ * Spin lock for manipulating the shared process data structure:
+ * ProcGlobal.... Adding an extra spin lock seemed like the smallest
+ * hack to get around reading and updating this structure in shared
+ * memory. -mer 17 July 1991
+ * --------------------
+ */
+SPINLOCK ProcStructLock;
+
+/*
+ * For cleanup routines. Don't cleanup if the initialization
+ * has not happened.
+ */
+static bool ProcInitialized = FALSE;
+
+static PROC_HDR *ProcGlobal = NULL;
+
+PROC *MyProc = NULL;
+
+static void ProcKill(int exitStatus, int pid);
+static void ProcGetNewSemKeyAndNum(IPCKey *key, int *semNum);
+static void ProcFreeSem(IpcSemaphoreKey semKey, int semNum);
+#if defined(PORTNAME_linux)
+extern int HandleDeadLock(int);
+#else
+extern int HandleDeadLock(void);
+#endif
+/*
+ * InitProcGlobal -
+ * initializes the global process table. We put it here so that
+ * the postmaster can do this initialization. (ProcFreeAllSem needs
+ * to read this table on exiting the postmaster. If we have the first
+ * backend do this, starting up and killing the postmaster without
+ * starting any backends will be a problem.)
+ */
+void
+InitProcGlobal(IPCKey key)
+{
+ bool found = false;
+
+ /* attach to the free list */
+ ProcGlobal = (PROC_HDR *)
+ ShmemInitStruct("Proc Header",(unsigned)sizeof(PROC_HDR),&found);
+
+ /* --------------------
+ * We're the first - initialize.
+ * --------------------
+ */
+ if (! found)
+ {
+ int i;
+
+ ProcGlobal->numProcs = 0;
+ ProcGlobal->freeProcs = INVALID_OFFSET;
+ ProcGlobal->currKey = IPCGetProcessSemaphoreInitKey(key);
+ for (i=0; i < MAX_PROC_SEMS/PROC_NSEMS_PER_SET; i++)
+ ProcGlobal->freeSemMap[i] = 0;
+ }
+}
+
+/* ------------------------
+ * InitProc -- create a per-process data structure for this process
+ * used by the lock manager on semaphore queues.
+ * ------------------------
+ */
+void
+InitProcess(IPCKey key)
+{
+ bool found = false;
+ int pid;
+ int semstat;
+ unsigned long location, myOffset;
+
+ /* ------------------
+ * Routine called if deadlock timer goes off. See ProcSleep()
+ * ------------------
+ */
+#ifndef WIN32
+ signal(SIGALRM, HandleDeadLock);
+#endif /* WIN32 we'll have to figure out how to handle this later */
+
+ SpinAcquire(ProcStructLock);
+
+ /* attach to the free list */
+ ProcGlobal = (PROC_HDR *)
+ ShmemInitStruct("Proc Header",(unsigned)sizeof(PROC_HDR),&found);
+ if (!found) {
+ /* this should not happen. InitProcGlobal() is called before this. */
+ elog(WARN, "InitProcess: Proc Header uninitialized");
+ }
+
+ if (MyProc != NULL)
+ {
+ SpinRelease(ProcStructLock);
+ elog(WARN,"ProcInit: you already exist");
+ return;
+ }
+
+ /* try to get a proc from the free list first */
+
+ myOffset = ProcGlobal->freeProcs;
+
+ if (myOffset != INVALID_OFFSET)
+ {
+ MyProc = (PROC *) MAKE_PTR(myOffset);
+ ProcGlobal->freeProcs = MyProc->links.next;
+ }
+ else
+ {
+ /* have to allocate one. We can't use the normal binding
+ * table mechanism because the proc structure is stored
+ * by PID instead of by a global name (need to look it
+ * up by PID when we cleanup dead processes).
+ */
+
+ MyProc = (PROC *) ShmemAlloc((unsigned)sizeof(PROC));
+ if (! MyProc)
+ {
+ SpinRelease(ProcStructLock);
+ elog (FATAL,"cannot create new proc: out of memory");
+ }
+
+ /* this cannot be initialized until after the buffer pool */
+ SHMQueueInit(&(MyProc->lockQueue));
+ MyProc->procId = ProcGlobal->numProcs;
+ ProcGlobal->numProcs++;
+ }
+
+ /*
+ * zero out the spin lock counts and set the sLocks field for
+ * ProcStructLock to 1 as we have acquired this spinlock above but
+ * didn't record it since we didn't have MyProc until now.
+ */
+ memset(MyProc->sLocks, 0, sizeof(MyProc->sLocks));
+ MyProc->sLocks[ProcStructLock] = 1;
+
+
+ if (IsUnderPostmaster) {
+ IPCKey semKey;
+ int semNum;
+ int semId;
+ union semun semun;
+
+ ProcGetNewSemKeyAndNum(&semKey, &semNum);
+
+ semId = IpcSemaphoreCreate(semKey,
+ PROC_NSEMS_PER_SET,
+ IPCProtection,
+ IpcSemaphoreDefaultStartValue,
+ 0,
+ &semstat);
+ /*
+ * we might be reusing a semaphore that belongs to a dead
+ * backend. So be careful and reinitialize its value here.
+ */
+ semun.val = IpcSemaphoreDefaultStartValue;
+ semctl(semId, semNum, SETVAL, semun);
+
+ IpcSemaphoreLock(semId, semNum, IpcExclusiveLock);
+ MyProc->sem.semId = semId;
+ MyProc->sem.semNum = semNum;
+ MyProc->sem.semKey = semKey;
+ } else {
+ MyProc->sem.semId = -1;
+ }
+
+ /* ----------------------
+ * Release the lock.
+ * ----------------------
+ */
+ SpinRelease(ProcStructLock);
+
+ MyProc->pid = 0;
+#if 0
+ MyProc->pid = MyPid;
+#endif
+
+ /* ----------------
+ * Start keeping spin lock stats from here on. Any botch before
+ * this initialization is forever botched
+ * ----------------
+ */
+ memset(MyProc->sLocks, 0, MAX_SPINS*sizeof(*MyProc->sLocks));
+
+ /* -------------------------
+ * Install ourselves in the binding table. The name to
+ * use is determined by the OS-assigned process id. That
+ * allows the cleanup process to find us after any untimely
+ * exit.
+ * -------------------------
+ */
+ pid = getpid();
+ location = MAKE_OFFSET(MyProc);
+ if ((! ShmemPIDLookup(pid,&location)) || (location != MAKE_OFFSET(MyProc)))
+ {
+ elog(FATAL,"InitProc: ShmemPID table broken");
+ }
+
+ MyProc->errType = NO_ERROR;
+ SHMQueueElemInit(&(MyProc->links));
+
+ on_exitpg(ProcKill, (caddr_t)pid);
+
+ ProcInitialized = TRUE;
+}
+
+/*
+ * ProcReleaseLocks() -- release all locks associated with this process
+ *
+ */
+void
+ProcReleaseLocks()
+{
+ if (!MyProc)
+ return;
+ LockReleaseAll(1,&MyProc->lockQueue);
+}
+
+/*
+ * ProcRemove -
+ * used by the postmaster to clean up the global tables. This also frees
+ * up the semaphore used for the lmgr of the process. (We have to do
+ * this is the postmaster instead of doing a IpcSemaphoreKill on exiting
+ * the process because the semaphore set is shared among backends and
+ * we don't want to remove other's semaphores on exit.)
+ */
+bool
+ProcRemove(int pid)
+{
+ SHMEM_OFFSET location;
+ PROC *proc;
+
+ location = INVALID_OFFSET;
+
+ location = ShmemPIDDestroy(pid);
+ if (location == INVALID_OFFSET)
+ return(FALSE);
+ proc = (PROC *) MAKE_PTR(location);
+
+ SpinAcquire(ProcStructLock);
+
+ ProcFreeSem(proc->sem.semKey, proc->sem.semNum);
+
+ proc->links.next = ProcGlobal->freeProcs;
+ ProcGlobal->freeProcs = MAKE_OFFSET(proc);
+
+ SpinRelease(ProcStructLock);
+
+ return(TRUE);
+}
+
+/*
+ * ProcKill() -- Destroy the per-proc data structure for
+ * this process. Release any of its held spin locks.
+ */
+static void
+ProcKill(int exitStatus, int pid)
+{
+ PROC *proc;
+ SHMEM_OFFSET location;
+
+ /* --------------------
+ * If this is a FATAL exit the postmaster will have to kill all the
+ * existing backends and reinitialize shared memory. So all we don't
+ * need to do anything here.
+ * --------------------
+ */
+ if (exitStatus != 0)
+ return;
+
+ if (! pid)
+ {
+ pid = getpid();
+ }
+
+ ShmemPIDLookup(pid,&location);
+ if (location == INVALID_OFFSET)
+ return;
+
+ proc = (PROC *) MAKE_PTR(location);
+
+ if (proc != MyProc) {
+ Assert( pid != getpid() );
+ } else
+ MyProc = NULL;
+
+ /* ---------------
+ * Assume one lock table.
+ * ---------------
+ */
+ ProcReleaseSpins(proc);
+ LockReleaseAll(1,&proc->lockQueue);
+
+ /* ----------------
+ * get off the wait queue
+ * ----------------
+ */
+ LockLockTable();
+ if (proc->links.next != INVALID_OFFSET) {
+ Assert(proc->waitLock->waitProcs.size > 0);
+ SHMQueueDelete(&(proc->links));
+ --proc->waitLock->waitProcs.size;
+ }
+ SHMQueueElemInit(&(proc->links));
+ UnlockLockTable();
+
+ return;
+}
+
+/*
+ * ProcQueue package: routines for putting processes to sleep
+ * and waking them up
+ */
+
+/*
+ * ProcQueueAlloc -- alloc/attach to a shared memory process queue
+ *
+ * Returns: a pointer to the queue or NULL
+ * Side Effects: Initializes the queue if we allocated one
+ */
+PROC_QUEUE *
+ProcQueueAlloc(char *name)
+{
+ bool found;
+ PROC_QUEUE *queue = (PROC_QUEUE *)
+ ShmemInitStruct(name,(unsigned)sizeof(PROC_QUEUE),&found);
+
+ if (! queue)
+ {
+ return(NULL);
+ }
+ if (! found)
+ {
+ ProcQueueInit(queue);
+ }
+ return(queue);
+}
+
+/*
+ * ProcQueueInit -- initialize a shared memory process queue
+ */
+void
+ProcQueueInit(PROC_QUEUE *queue)
+{
+ SHMQueueInit(&(queue->links));
+ queue->size = 0;
+}
+
+
+
+/*
+ * ProcSleep -- put a process to sleep
+ *
+ * P() on the semaphore should put us to sleep. The process
+ * semaphore is cleared by default, so the first time we try
+ * to acquire it, we sleep.
+ *
+ * ASSUME: that no one will fiddle with the queue until after
+ * we release the spin lock.
+ *
+ * NOTES: The process queue is now a priority queue for locking.
+ */
+int
+ProcSleep(PROC_QUEUE *queue,
+ SPINLOCK spinlock,
+ int token,
+ int prio,
+ LOCK *lock)
+{
+ int i;
+ PROC *proc;
+#ifndef WIN32 /* figure this out later */
+ struct itimerval timeval, dummy;
+#endif /* WIN32 */
+
+ proc = (PROC *) MAKE_PTR(queue->links.prev);
+ for (i=0;isize;i++)
+ {
+ if (proc->prio < prio)
+ proc = (PROC *) MAKE_PTR(proc->links.prev);
+ else
+ break;
+ }
+
+ MyProc->token = token;
+ MyProc->waitLock = lock;
+
+ /* -------------------
+ * currently, we only need this for the ProcWakeup routines
+ * -------------------
+ */
+ TransactionIdStore((TransactionId) GetCurrentTransactionId(), &MyProc->xid);
+
+ /* -------------------
+ * assume that these two operations are atomic (because
+ * of the spinlock).
+ * -------------------
+ */
+ SHMQueueInsertTL(&(proc->links),&(MyProc->links));
+ queue->size++;
+
+ SpinRelease(spinlock);
+
+ /* --------------
+ * Postgres does not have any deadlock detection code and for this
+ * reason we must set a timer to wake up the process in the event of
+ * a deadlock. For now the timer is set for 1 minute and we assume that
+ * any process which sleeps for this amount of time is deadlocked and will
+ * receive a SIGALRM signal. The handler should release the processes
+ * semaphore and abort the current transaction.
+ *
+ * Need to zero out struct to set the interval and the micro seconds fields
+ * to 0.
+ * --------------
+ */
+#ifndef WIN32
+ memset(&timeval, 0, sizeof(struct itimerval));
+ timeval.it_value.tv_sec = DEADLOCK_TIMEOUT;
+
+ if (setitimer(ITIMER_REAL, &timeval, &dummy))
+ elog(FATAL, "ProcSleep: Unable to set timer for process wakeup");
+#endif /* WIN32 */
+
+ /* --------------
+ * if someone wakes us between SpinRelease and IpcSemaphoreLock,
+ * IpcSemaphoreLock will not block. The wakeup is "saved" by
+ * the semaphore implementation.
+ * --------------
+ */
+ IpcSemaphoreLock(MyProc->sem.semId, MyProc->sem.semNum, IpcExclusiveLock);
+
+ /* ---------------
+ * We were awoken before a timeout - now disable the timer
+ * ---------------
+ */
+#ifndef WIN32
+ timeval.it_value.tv_sec = 0;
+
+
+ if (setitimer(ITIMER_REAL, &timeval, &dummy))
+ elog(FATAL, "ProcSleep: Unable to diable timer for process wakeup");
+#endif /* WIN32 */
+
+ /* ----------------
+ * We were assumed to be in a critical section when we went
+ * to sleep.
+ * ----------------
+ */
+ SpinAcquire(spinlock);
+
+ return(MyProc->errType);
+}
+
+
+/*
+ * ProcWakeup -- wake up a process by releasing its private semaphore.
+ *
+ * remove the process from the wait queue and set its links invalid.
+ * RETURN: the next process in the wait queue.
+ */
+PROC *
+ProcWakeup(PROC *proc, int errType)
+{
+ PROC *retProc;
+ /* assume that spinlock has been acquired */
+
+ if (proc->links.prev == INVALID_OFFSET ||
+ proc->links.next == INVALID_OFFSET)
+ return((PROC *) NULL);
+
+ retProc = (PROC *) MAKE_PTR(proc->links.prev);
+
+ /* you have to update waitLock->waitProcs.size yourself */
+ SHMQueueDelete(&(proc->links));
+ SHMQueueElemInit(&(proc->links));
+
+ proc->errType = errType;
+
+ IpcSemaphoreUnlock(proc->sem.semId, proc->sem.semNum, IpcExclusiveLock);
+
+ return retProc;
+}
+
+
+/*
+ * ProcGetId --
+ */
+int
+ProcGetId()
+{
+ return( MyProc->procId );
+}
+
+/*
+ * ProcLockWakeup -- routine for waking up processes when a lock is
+ * released.
+ */
+int
+ProcLockWakeup(PROC_QUEUE *queue, char *ltable, char *lock)
+{
+ PROC *proc;
+ int count;
+
+ if (! queue->size)
+ return(STATUS_NOT_FOUND);
+
+ proc = (PROC *) MAKE_PTR(queue->links.prev);
+ count = 0;
+ while ((LockResolveConflicts ((LOCKTAB *) ltable,
+ (LOCK *) lock,
+ proc->token,
+ proc->xid) == STATUS_OK))
+ {
+ /* there was a waiting process, grant it the lock before waking it
+ * up. This will prevent another process from seizing the lock
+ * between the time we release the lock master (spinlock) and
+ * the time that the awoken process begins executing again.
+ */
+ GrantLock((LOCK *) lock, proc->token);
+ queue->size--;
+
+ /*
+ * ProcWakeup removes proc from the lock waiting process queue and
+ * returns the next proc in chain. If a writer just dropped
+ * its lock and there are several waiting readers, wake them all up.
+ */
+ proc = ProcWakeup(proc, NO_ERROR);
+
+ count++;
+ if (!proc || queue->size == 0)
+ break;
+ }
+
+ if (count)
+ return(STATUS_OK);
+ else
+ /* Something is still blocking us. May have deadlocked. */
+ return(STATUS_NOT_FOUND);
+}
+
+void
+ProcAddLock(SHM_QUEUE *elem)
+{
+ SHMQueueInsertTL(&MyProc->lockQueue,elem);
+}
+
+/* --------------------
+ * We only get to this routine if we got SIGALRM after DEADLOCK_TIMEOUT
+ * while waiting for a lock to be released by some other process. After
+ * the one minute deadline we assume we have a deadlock and must abort
+ * this transaction. We must also indicate that I'm no longer waiting
+ * on a lock so that other processes don't try to wake me up and screw
+ * up my semaphore.
+ * --------------------
+ */
+int
+#if defined(PORTNAME_linux)
+HandleDeadLock(int i)
+#else
+HandleDeadLock()
+#endif
+{
+ LOCK *lock;
+ int size;
+
+ LockLockTable();
+
+ /* ---------------------
+ * Check to see if we've been awoken by anyone in the interim.
+ *
+ * If we have we can return and resume our transaction -- happy day.
+ * Before we are awoken the process releasing the lock grants it to
+ * us so we know that we don't have to wait anymore.
+ *
+ * Damn these names are LONG! -mer
+ * ---------------------
+ */
+ if (IpcSemaphoreGetCount(MyProc->sem.semId, MyProc->sem.semNum) ==
+ IpcSemaphoreDefaultStartValue) {
+ UnlockLockTable();
+ return 1;
+ }
+
+ /*
+ * you would think this would be unnecessary, but...
+ *
+ * this also means we've been removed already. in some ports
+ * (e.g., sparc and aix) the semop(2) implementation is such that
+ * we can actually end up in this handler after someone has removed
+ * us from the queue and bopped the semaphore *but the test above
+ * fails to detect the semaphore update* (presumably something weird
+ * having to do with the order in which the semaphore wakeup signal
+ * and SIGALRM get handled).
+ */
+ if (MyProc->links.prev == INVALID_OFFSET ||
+ MyProc->links.next == INVALID_OFFSET) {
+ UnlockLockTable();
+ return(1);
+ }
+
+ lock = MyProc->waitLock;
+ size = lock->waitProcs.size; /* so we can look at this in the core */
+
+ /* ------------------------
+ * Get this process off the lock's wait queue
+ * ------------------------
+ */
+ Assert(lock->waitProcs.size > 0);
+ --lock->waitProcs.size;
+ SHMQueueDelete(&(MyProc->links));
+ SHMQueueElemInit(&(MyProc->links));
+
+ /* ------------------
+ * Unlock my semaphore so that the count is right for next time.
+ * I was awoken by a signal, not by someone unlocking my semaphore.
+ * ------------------
+ */
+ IpcSemaphoreUnlock(MyProc->sem.semId, MyProc->sem.semNum, IpcExclusiveLock);
+
+ /* -------------
+ * Set MyProc->errType to STATUS_ERROR so that we abort after
+ * returning from this handler.
+ * -------------
+ */
+ MyProc->errType = STATUS_ERROR;
+
+ /*
+ * if this doesn't follow the IpcSemaphoreUnlock then we get lock
+ * table corruption ("LockReplace: xid table corrupted") due to
+ * race conditions. i don't claim to understand this...
+ */
+ UnlockLockTable();
+
+ elog(NOTICE, "Timeout -- possible deadlock");
+ return 0;
+}
+
+void
+ProcReleaseSpins(PROC *proc)
+{
+ int i;
+
+ if (!proc)
+ proc = MyProc;
+
+ if (!proc)
+ return;
+ for (i=0; i < (int)MAX_SPINS; i++)
+ {
+ if (proc->sLocks[i])
+ {
+ Assert(proc->sLocks[i] == 1);
+ SpinRelease(i);
+ }
+ }
+}
+
+/*****************************************************************************
+ *
+ *****************************************************************************/
+
+/*
+ * ProcGetNewSemKeyAndNum -
+ * scan the free semaphore bitmap and allocate a single semaphore from
+ * a semaphore set. (If the semaphore set doesn't exist yet,
+ * IpcSemaphoreCreate will create it. Otherwise, we use the existing
+ * semaphore set.)
+ */
+static void
+ProcGetNewSemKeyAndNum(IPCKey *key, int *semNum)
+{
+ int i;
+ int32 *freeSemMap = ProcGlobal->freeSemMap;
+ unsigned int fullmask;
+
+ /*
+ * we hold ProcStructLock when entering this routine. We scan through
+ * the bitmap to look for a free semaphore.
+ */
+ fullmask = ~0 >> (32 - PROC_NSEMS_PER_SET);
+ for(i=0; i < MAX_PROC_SEMS/PROC_NSEMS_PER_SET; i++) {
+ int mask = 1;
+ int j;
+
+ if (freeSemMap[i] == fullmask)
+ continue; /* none free for this set */
+
+ for(j = 0; j < PROC_NSEMS_PER_SET; j++) {
+ if ((freeSemMap[i] & mask) == 0) {
+ /*
+ * a free semaphore found. Mark it as allocated.
+ */
+ freeSemMap[i] |= mask;
+
+ *key = ProcGlobal->currKey + i;
+ *semNum = j;
+ return;
+ }
+ mask <<= 1;
+ }
+ }
+
+ /* if we reach here, all the semaphores are in use. */
+ elog(WARN, "InitProc: cannot allocate a free semaphore");
+}
+
+/*
+ * ProcFreeSem -
+ * free up our semaphore in the semaphore set. If we're the last one
+ * in the set, also remove the semaphore set.
+ */
+static void
+ProcFreeSem(IpcSemaphoreKey semKey, int semNum)
+{
+ int mask;
+ int i;
+ int32 *freeSemMap = ProcGlobal->freeSemMap;
+
+ i = semKey - ProcGlobal->currKey;
+ mask = ~(1 << semNum);
+ freeSemMap[i] &= mask;
+
+ if (freeSemMap[i]==0)
+ IpcSemaphoreKill(semKey);
+}
+
+/*
+ * ProcFreeAllSemaphores -
+ * on exiting the postmaster, we free up all the semaphores allocated
+ * to the lmgrs of the backends.
+ */
+void
+ProcFreeAllSemaphores()
+{
+ int i;
+ int32 *freeSemMap = ProcGlobal->freeSemMap;
+
+ for(i=0; i < MAX_PROC_SEMS/PROC_NSEMS_PER_SET; i++) {
+ if (freeSemMap[i]!=0)
+ IpcSemaphoreKill(ProcGlobal->currKey + i);
+ }
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * single.c--
+ * set single locks in the multi-level lock hierarchy
+ *
+ * Sometimes we don't want to set all levels of the multi-level
+ * lock hierarchy at once. This allows us to set and release
+ * one level at a time. It's useful in index scans when
+ * you can set an intent lock at the beginning and thereafter
+ * only set page locks. Tends to speed things up.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/Attic/single.c,v 1.1.1.1 1996/07/09 06:21:57 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "storage/lmgr.h" /* where the declarations go */
+#include "storage/lock.h"
+#include "storage/multilev.h"
+#include "utils/rel.h"
+
+/*
+ * SingleLockReln -- lock a relation
+ *
+ * Returns: TRUE if the lock can be set, FALSE otherwise.
+ */
+bool
+SingleLockReln(LockInfo linfo, LOCKT lockt, int action)
+{
+ LOCKTAG tag;
+
+ /*
+ * LOCKTAG has two bytes of padding, unfortunately. The
+ * hash function will return miss if the padding bytes aren't
+ * zero'd.
+ */
+ memset(&tag,0,sizeof(tag));
+ tag.relId = linfo->lRelId.relId;
+ tag.dbId = linfo->lRelId.dbId;
+ BlockIdSet(&(tag.tupleId.ip_blkid), InvalidBlockNumber);
+ tag.tupleId.ip_posid = InvalidOffsetNumber;
+
+ if (action == UNLOCK)
+ return(LockRelease(MultiTableId, &tag, lockt));
+ else
+ return(LockAcquire(MultiTableId, &tag, lockt));
+}
+
+/*
+ * SingleLockPage -- use multi-level lock table, but lock
+ * only at the page level.
+ *
+ * Assumes that an INTENT lock has already been set in the
+ * multi-level lock table.
+ *
+ */
+bool
+SingleLockPage(LockInfo linfo,
+ ItemPointer tidPtr,
+ LOCKT lockt,
+ int action)
+{
+ LOCKTAG tag;
+
+ /*
+ * LOCKTAG has two bytes of padding, unfortunately. The
+ * hash function will return miss if the padding bytes aren't
+ * zero'd.
+ */
+ memset(&tag,0,sizeof(tag));
+ tag.relId = linfo->lRelId.relId;
+ tag.dbId = linfo->lRelId.dbId;
+ BlockIdCopy(&(tag.tupleId.ip_blkid), &(tidPtr->ip_blkid));
+ tag.tupleId.ip_posid = InvalidOffsetNumber;
+
+
+ if (action == UNLOCK)
+ return(LockRelease(MultiTableId, &tag, lockt));
+ else
+ return(LockAcquire(MultiTableId, &tag, lockt));
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * lock.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: lock.h,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef LOCK_H_
+#define LOCK_H_
+
+#include "postgres.h"
+#include "storage/itemptr.h"
+#include "storage/shmem.h"
+#include "storage/spin.h"
+#include "storage/backendid.h"
+#include "utils/hsearch.h"
+
+extern SPINLOCK LockMgrLock;
+typedef int MASK;
+
+#define INIT_TABLE_SIZE 100
+#define MAX_TABLE_SIZE 1000
+
+
+/* ----------------------
+ * The following defines are used to estimate how much shared
+ * memory the lock manager is going to require.
+ *
+ * NBACKENDS - The number of concurrently running backends
+ * NLOCKS_PER_XACT - The number of unique locks acquired in a transaction
+ * NLOCKENTS - The maximum number of lock entries in the lock table.
+ * ----------------------
+ */
+#define NBACKENDS 50
+#define NLOCKS_PER_XACT 40
+#define NLOCKENTS NLOCKS_PER_XACT*NBACKENDS
+
+typedef int LOCK_TYPE;
+typedef int LOCKT;
+typedef int LockTableId;
+
+/* MAX_LOCKTYPES cannot be larger than the bits in MASK */
+#define MAX_LOCKTYPES 6
+
+/*
+ * MAX_TABLES corresponds to the number of spin locks allocated in
+ * CreateSpinLocks() or the number of shared memory locations allocated
+ * for lock table spin locks in the case of machines with TAS instructions.
+ */
+#define MAX_TABLES 2
+
+#define INVALID_TABLEID 0
+
+/*typedef struct LOCK LOCK; */
+
+
+typedef struct ltag {
+ Oid relId;
+ Oid dbId;
+ ItemPointerData tupleId;
+} LOCKTAG;
+
+#define TAGSIZE (sizeof(LOCKTAG))
+
+/* This is the control structure for a lock table. It
+ * lives in shared memory:
+ *
+ * tableID -- the handle used by the lock table's clients to
+ * refer to the table.
+ *
+ * nLockTypes -- number of lock types (READ,WRITE,etc) that
+ * are defined on this lock table
+ *
+ * conflictTab -- this is an array of bitmasks showing lock
+ * type conflicts. conflictTab[i] is a mask with the j-th bit
+ * turned on if lock types i and j conflict.
+ *
+ * prio -- each locktype has a priority, so, for example, waiting
+ * writers can be given priority over readers (to avoid
+ * starvation).
+ *
+ * masterlock -- synchronizes access to the table
+ *
+ */
+typedef struct lockctl {
+ LockTableId tableId;
+ int nLockTypes;
+ int conflictTab[MAX_LOCKTYPES];
+ int prio[MAX_LOCKTYPES];
+ SPINLOCK masterLock;
+} LOCKCTL;
+
+/*
+ * lockHash -- hash table on lock Ids,
+ * xidHash -- hash on xid and lockId in case
+ * multiple processes are holding the lock
+ * ctl - control structure described above.
+ */
+typedef struct ltable {
+ HTAB *lockHash;
+ HTAB *xidHash;
+ LOCKCTL *ctl;
+} LOCKTAB;
+
+/* -----------------------
+ * A transaction never conflicts with its own locks. Hence, if
+ * multiple transactions hold non-conflicting locks on the same
+ * data, private per-transaction information must be stored in the
+ * XID table. The tag is XID + shared memory lock address so that
+ * all locks can use the same XID table. The private information
+ * we store is the number of locks of each type (holders) and the
+ * total number of locks (nHolding) held by the transaction.
+ *
+ * NOTE: --
+ * There were some problems with the fact that currently TransactionIdData
+ * is a 5 byte entity and compilers long word aligning of structure fields.
+ * If the 3 byte padding is put in front of the actual xid data then the
+ * hash function (which uses XID_TAGSIZE when deciding how many bytes of a
+ * struct to look at for the key) might only see the last two bytes of the xid.
+ *
+ * Clearly this is not good since its likely that these bytes will be the
+ * same for many transactions and hence they will share the same entry in
+ * hash table causing the entry to be corrupted. For this long-winded
+ * reason I have put the tag in a struct of its own to ensure that the
+ * XID_TAGSIZE is computed correctly. It used to be sizeof (SHMEM_OFFSET) +
+ * sizeof(TransactionIdData) which != sizeof(XIDTAG).
+ *
+ * Finally since the hash function will now look at all 12 bytes of the tag
+ * the padding bytes MUST be zero'd before use in hash_search() as they
+ * will have random values otherwise. Jeff 22 July 1991.
+ * -----------------------
+ */
+
+typedef struct XIDTAG {
+ SHMEM_OFFSET lock;
+ int pid;
+ TransactionId xid;
+} XIDTAG;
+
+typedef struct XIDLookupEnt {
+ /* tag */
+ XIDTAG tag;
+
+ /* data */
+ int holders[MAX_LOCKTYPES];
+ int nHolding;
+ SHM_QUEUE queue;
+} XIDLookupEnt;
+
+#define XID_TAGSIZE (sizeof(XIDTAG))
+
+/* originally in procq.h */
+typedef struct procQueue {
+ SHM_QUEUE links;
+ int size;
+} PROC_QUEUE;
+
+
+/*
+ * lock information:
+ *
+ * tag -- uniquely identifies the object being locked
+ * mask -- union of the conflict masks of all lock types
+ * currently held on this object.
+ * waitProcs -- queue of processes waiting for this lock
+ * holders -- count of each lock type currently held on the
+ * lock.
+ * nHolding -- total locks of all types.
+ */
+typedef struct Lock {
+ /* hash key */
+ LOCKTAG tag;
+
+ /* data */
+ int mask;
+ PROC_QUEUE waitProcs;
+ int holders[MAX_LOCKTYPES];
+ int nHolding;
+ int activeHolders[MAX_LOCKTYPES];
+ int nActive;
+} LOCK;
+
+#define LockGetLock_nHolders(l) l->nHolders
+
+#define LockDecrWaitHolders(lock, lockt) \
+ lock->nHolding--; \
+ lock->holders[lockt]--
+
+#define LockLockTable() SpinAcquire(LockMgrLock);
+#define UnlockLockTable() SpinRelease(LockMgrLock);
+
+extern SPINLOCK LockMgrLock;
+
+/*
+ * function prototypes
+ */
+extern void InitLocks(void);
+extern void LockDisable(int status);
+extern LockTableId LockTabInit(char *tabName, MASK *conflictsP, int *prioP,
+ int ntypes);
+extern LockTableId LockTabRename(LockTableId tableId);
+extern bool LockAcquire(LockTableId tableId, LOCKTAG *lockName, LOCKT lockt);
+extern int LockResolveConflicts(LOCKTAB *ltable, LOCK *lock, LOCKT lockt,
+ TransactionId xid);
+extern int WaitOnLock(LOCKTAB *ltable, LockTableId tableId, LOCK *lock,
+ LOCKT lockt);
+extern bool LockRelease(LockTableId tableId, LOCKTAG *lockName, LOCKT lockt);
+extern void GrantLock(LOCK *lock, LOCKT lockt);
+extern bool LockReleaseAll(LockTableId tableId, SHM_QUEUE *lockQueue);
+extern int LockShmemSize(void);
+extern bool LockingDisabled(void);
+
+#endif /* LOCK_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * multilev.h--
+ * multi level lock table consts/defs for single.c and multi.c and their
+ * clients
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: multilev.h,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MULTILEV_H
+#define MULTILEV_H
+
+#include "storage/lock.h"
+#include "storage/lmgr.h"
+
+#define READ_LOCK 2
+#define WRITE_LOCK 1
+
+/* any time a small granularity READ/WRITE lock is set.
+ * Higher granularity READ_INTENT/WRITE_INTENT locks must
+ * also be set. A read intent lock is has value READ+INTENT.
+ * in this implementation.
+ */
+#define NO_LOCK 0
+#define INTENT 2
+#define READ_INTENT (READ_LOCK+INTENT)
+#define WRITE_INTENT (WRITE_LOCK+INTENT)
+
+#define EXTEND_LOCK 5
+
+#define SHORT_TERM 1
+#define LONG_TERM 2
+#define UNLOCK 0
+
+#define N_LEVELS 3
+#define RELN_LEVEL 0
+#define PAGE_LEVEL 1
+#define TUPLE_LEVEL 2
+typedef int LOCK_LEVEL;
+
+/* multi.c */
+
+extern LockTableId MultiTableId;
+extern LockTableId ShortTermTableId;
+
+/*
+ * function prototypes
+ */
+extern LockTableId InitMultiLevelLockm(void);
+extern bool MultiLockReln(LockInfo linfo, LOCKT lockt);
+extern bool MultiLockTuple(LockInfo linfo, ItemPointer tidPtr, LOCKT lockt);
+extern bool MultiLockPage(LockInfo linfo, ItemPointer tidPtr, LOCKT lockt);
+extern bool MultiAcquire(LockTableId tableId, LOCKTAG *tag, LOCKT lockt,
+ LOCK_LEVEL level);
+extern bool MultiReleasePage(LockInfo linfo, ItemPointer tidPtr, LOCKT lockt);
+extern bool MultiReleaseReln(LockInfo linfo, LOCKT lockt);
+extern bool MultiRelease(LockTableId tableId, LOCKTAG *tag, LOCKT lockt,
+ LOCK_LEVEL level);
+
+#endif /* MULTILEV_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * off.h--
+ * POSTGRES disk "offset" definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: off.h,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef OFF_H
+#define OFF_H
+
+#include "c.h"
+#include "machine.h" /* for BLCKSZ */
+#include "storage/itemid.h"
+
+/*
+ * OffsetNumber:
+ *
+ * this is a 1-based index into the linp (ItemIdData) array in the
+ * header of each disk page.
+ */
+typedef uint16 OffsetNumber;
+
+#define InvalidOffsetNumber ((OffsetNumber) 0)
+#define FirstOffsetNumber ((OffsetNumber) 1)
+#define MaxOffsetNumber ((OffsetNumber) (BLCKSZ / sizeof(ItemIdData)))
+#define OffsetNumberMask (0xffff) /* valid uint16 bits */
+
+/* ----------------
+ * support macros
+ * ----------------
+ */
+
+/*
+ * OffsetNumberIsValid --
+ * True iff the offset number is valid.
+ */
+#define OffsetNumberIsValid(offsetNumber) \
+ ((bool) ((offsetNumber != InvalidOffsetNumber) && \
+ (offsetNumber <= MaxOffsetNumber)))
+
+/*
+ * OffsetNumberNext --
+ * OffsetNumberPrev --
+ * Increments/decrements the argument. These macros look pointless
+ * but they help us disambiguate the different manipulations on
+ * OffsetNumbers (e.g., sometimes we substract one from an
+ * OffsetNumber to move back, and sometimes we do so to form a
+ * real C array index).
+ */
+#define OffsetNumberNext(offsetNumber) \
+ ((OffsetNumber) (1 + (offsetNumber)))
+#define OffsetNumberPrev(offsetNumber) \
+ ((OffsetNumber) (-1 + (offsetNumber)))
+
+#endif /* OFF_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * page.h--
+ * POSTGRES buffer page abstraction definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: page.h,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PAGE_H
+#define PAGE_H
+
+#include "c.h"
+
+typedef Pointer Page;
+
+/*
+ * PageIsValid --
+ * True iff page is valid.
+ */
+#define PageIsValid(page) PointerIsValid(page)
+
+#endif /* PAGE_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for storage/page
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/storage/page/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:58 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= bufpage.c itemptr.c
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * bufpage.c--
+ * POSTGRES standard buffer page code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/page/bufpage.c,v 1.1.1.1 1996/07/09 06:21:58 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+
+#include "c.h"
+
+#include "storage/item.h"
+#include "storage/buf.h"
+#include "storage/bufmgr.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/memutils.h"
+#include "storage/bufpage.h"
+
+#include "lib/qsort.h"
+
+static bool PageManagerShuffle = true; /* default is shuffle mode */
+
+/* ----------------------------------------------------------------
+ * Buffer support functions
+ * ----------------------------------------------------------------
+ */
+/*
+ * BufferGetPageSize --
+ * Returns the page size within a buffer.
+ *
+ * Notes:
+ * Assumes buffer is valid.
+ *
+ * The buffer can be a raw disk block and need not contain a valid
+ * (formatted) disk page.
+ */
+Size
+BufferGetPageSize(Buffer buffer)
+{
+ Size pageSize;
+
+ Assert(BufferIsValid(buffer));
+ pageSize = BLCKSZ; /* XXX dig out of buffer descriptor */
+
+ Assert(PageSizeIsValid(pageSize));
+ return (pageSize);
+}
+
+/*
+ * BufferGetPage --
+ * Returns the page associated with a buffer.
+ */
+Page
+BufferGetPage(Buffer buffer)
+{
+ return (Page) BufferGetBlock(buffer);
+}
+
+
+/* ----------------------------------------------------------------
+ * Page support functions
+ * ----------------------------------------------------------------
+ */
+
+/*
+ * PageInit --
+ * Initializes the contents of a page.
+ */
+void
+PageInit(Page page, Size pageSize, Size specialSize)
+{
+ PageHeader p = (PageHeader) page;
+
+ Assert(pageSize == BLCKSZ);
+ Assert(pageSize >
+ specialSize + sizeof(PageHeaderData) - sizeof(ItemIdData));
+
+ specialSize = DOUBLEALIGN(specialSize);
+
+ p->pd_lower = sizeof(PageHeaderData) - sizeof(ItemIdData);
+ p->pd_upper = pageSize - specialSize;
+ p->pd_special = pageSize - specialSize;
+ PageSetPageSize(page, pageSize);
+}
+
+/*
+ * PageGetItem --
+ * Retrieves an item on the given page.
+ *
+ * Note:
+ * This does change the status of any of the resources passed.
+ * The semantics may change in the future.
+ */
+Item
+PageGetItem(Page page, ItemId itemId)
+{
+ Item item;
+
+ Assert(PageIsValid(page));
+ Assert((*itemId).lp_flags & LP_USED);
+
+ item = (Item)(((char *)page) + (*itemId).lp_off);
+
+ return (item);
+}
+
+/*
+ * PageAddItem --
+ * Adds item to the given page.
+ *
+ * Note:
+ * This does not assume that the item resides on a single page.
+ * It is the responsiblity of the caller to act appropriately
+ * depending on this fact. The "pskip" routines provide a
+ * friendlier interface, in this case.
+ *
+ * This does change the status of any of the resources passed.
+ * The semantics may change in the future.
+ *
+ * This routine should probably be combined with others?
+ */
+/* ----------------
+ * PageAddItem
+ *
+ * add an item to a page.
+ *
+ * Notes on interface:
+ * If offsetNumber is valid, shuffle ItemId's down to make room
+ * to use it, if PageManagerShuffle is true. If PageManagerShuffle is
+ * false, then overwrite the specified ItemId. (PageManagerShuffle is
+ * true by default, and is modified by calling PageManagerModeSet.)
+ * If offsetNumber is not valid, then assign one by finding the first
+ * one that is both unused and deallocated.
+ *
+ * NOTE: If offsetNumber is valid, and PageManagerShuffle is true, it
+ * is assumed that there is room on the page to shuffle the ItemId's
+ * down by one.
+ * ----------------
+ */
+OffsetNumber
+PageAddItem(Page page,
+ Item item,
+ Size size,
+ OffsetNumber offsetNumber,
+ ItemIdFlags flags)
+{
+ register i;
+ Size alignedSize;
+ Offset lower;
+ Offset upper;
+ ItemId itemId;
+ ItemId fromitemId, toitemId;
+ OffsetNumber limit;
+
+ bool shuffled = false;
+
+ /*
+ * Find first unallocated offsetNumber
+ */
+ limit = OffsetNumberNext(PageGetMaxOffsetNumber(page));
+
+ /* was offsetNumber passed in? */
+ if (OffsetNumberIsValid(offsetNumber)) {
+ if (PageManagerShuffle == true) {
+ /* shuffle ItemId's (Do the PageManager Shuffle...) */
+ for (i = (limit - 1); i >= offsetNumber; i--) {
+ fromitemId = &((PageHeader)page)->pd_linp[i - 1];
+ toitemId = &((PageHeader)page)->pd_linp[i];
+ *toitemId = *fromitemId;
+ }
+ shuffled = true; /* need to increase "lower" */
+ } else { /* overwrite mode */
+ itemId = &((PageHeader)page)->pd_linp[offsetNumber - 1];
+ if (((*itemId).lp_flags & LP_USED) ||
+ ((*itemId).lp_len != 0)) {
+ elog(WARN, "PageAddItem: tried overwrite of used ItemId");
+ return (InvalidOffsetNumber);
+ }
+ }
+ } else { /* offsetNumber was not passed in, so find one */
+ /* look for "recyclable" (unused & deallocated) ItemId */
+ for (offsetNumber = 1; offsetNumber < limit; offsetNumber++) {
+ itemId = &((PageHeader)page)->pd_linp[offsetNumber - 1];
+ if ((((*itemId).lp_flags & LP_USED) == 0) &&
+ ((*itemId).lp_len == 0))
+ break;
+ }
+ }
+ if (offsetNumber > limit)
+ lower = (Offset) (((char *) (&((PageHeader)page)->pd_linp[offsetNumber])) - ((char *) page));
+ else if (offsetNumber == limit || shuffled == true)
+ lower = ((PageHeader)page)->pd_lower + sizeof (ItemIdData);
+ else
+ lower = ((PageHeader)page)->pd_lower;
+
+ alignedSize = DOUBLEALIGN(size);
+
+ upper = ((PageHeader)page)->pd_upper - alignedSize;
+
+ if (lower > upper) {
+ return (InvalidOffsetNumber);
+ }
+
+ itemId = &((PageHeader)page)->pd_linp[offsetNumber - 1];
+ (*itemId).lp_off = upper;
+ (*itemId).lp_len = size;
+ (*itemId).lp_flags = flags;
+ memmove((char *)page + upper, item, size);
+ ((PageHeader)page)->pd_lower = lower;
+ ((PageHeader)page)->pd_upper = upper;
+
+ return (offsetNumber);
+}
+
+/*
+ * PageGetTempPage --
+ * Get a temporary page in local memory for special processing
+ */
+Page
+PageGetTempPage(Page page, Size specialSize)
+{
+ Size pageSize;
+ Size size;
+ Page temp;
+ PageHeader thdr;
+
+ pageSize = PageGetPageSize(page);
+
+ if ((temp = (Page) palloc(pageSize)) == (Page) NULL)
+ elog(FATAL, "Cannot allocate %d bytes for temp page.", pageSize);
+ thdr = (PageHeader) temp;
+
+ /* copy old page in */
+ memmove(temp, page, pageSize);
+
+ /* clear out the middle */
+ size = (pageSize - sizeof(PageHeaderData)) + sizeof(ItemIdData);
+ size -= DOUBLEALIGN(specialSize);
+ memset((char *) &(thdr->pd_linp[0]), 0, size);
+
+ /* set high, low water marks */
+ thdr->pd_lower = sizeof (PageHeaderData) - sizeof (ItemIdData);
+ thdr->pd_upper = pageSize - DOUBLEALIGN(specialSize);
+
+ return (temp);
+}
+
+/*
+ * PageRestoreTempPage --
+ * Copy temporary page back to permanent page after special processing
+ * and release the temporary page.
+ */
+void
+PageRestoreTempPage(Page tempPage, Page oldPage)
+{
+ Size pageSize;
+
+ pageSize = PageGetPageSize(tempPage);
+ memmove((char *) oldPage, (char *) tempPage, pageSize);
+
+ pfree(tempPage);
+}
+
+/*
+ * PageGetMaxOffsetNumber --
+ * Returns the maximum offset number used by the given page.
+ *
+ * NOTE: The offset is invalid if the page is non-empty.
+ * Test whether PageIsEmpty before calling this routine
+ * and/or using its return value.
+ */
+OffsetNumber
+PageGetMaxOffsetNumber(Page page)
+{
+ LocationIndex low;
+ OffsetNumber i;
+
+ low = ((PageHeader) page)->pd_lower;
+ i = (low - (sizeof(PageHeaderData) - sizeof(ItemIdData)))
+ / sizeof(ItemIdData);
+
+ return(i);
+}
+
+/* ----------------
+ * itemid stuff for PageRepairFragmentation
+ * ----------------
+ */
+struct itemIdSortData {
+ int offsetindex; /* linp array index */
+ ItemIdData itemiddata;
+};
+
+static int
+itemidcompare(struct itemIdSortData *itemidp1, struct itemIdSortData *itemidp2)
+{
+ if (itemidp1->itemiddata.lp_off == itemidp2->itemiddata.lp_off)
+ return(0);
+ else if (itemidp1->itemiddata.lp_off < itemidp2->itemiddata.lp_off)
+ return(1);
+ else
+ return(-1);
+}
+
+/*
+ * PageRepairFragmentation --
+ * Frees fragmented space on a page.
+ */
+void
+PageRepairFragmentation(Page page)
+{
+ int i;
+ struct itemIdSortData *itemidbase, *itemidptr;
+ ItemId lp;
+ int nline, nused;
+ int itemidcompare();
+ Offset upper;
+ Size alignedSize;
+
+ nline = (int16) PageGetMaxOffsetNumber(page);
+ nused = 0;
+ for (i=0; i
+ lp = ((PageHeader)page)->pd_linp + i;
+ if ((*lp).lp_flags & LP_USED)
+ nused++;
+ }
+
+ if (nused == 0) {
+ for (i=0; i
+ lp = ((PageHeader)page)->pd_linp + i;
+ if ((*lp).lp_len > 0) /* unused, but allocated */
+ (*lp).lp_len = 0; /* indicate unused & deallocated */
+ }
+
+ ((PageHeader)page)->pd_upper = ((PageHeader)page)->pd_special;
+ } else { /* nused != 0 */
+ itemidbase = (struct itemIdSortData *)
+ palloc(sizeof(struct itemIdSortData) * nused);
+ memset((char *) itemidbase, 0, sizeof(struct itemIdSortData) * nused);
+ itemidptr = itemidbase;
+ for (i=0; i
+ lp = ((PageHeader)page)->pd_linp + i;
+ if ((*lp).lp_flags & LP_USED) {
+ itemidptr->offsetindex = i;
+ itemidptr->itemiddata = *lp;
+ itemidptr++;
+ } else {
+ if ((*lp).lp_len > 0) /* unused, but allocated */
+ (*lp).lp_len = 0; /* indicate unused & deallocated */
+ }
+ }
+
+ /* sort itemIdSortData array...*/
+ pg_qsort((char *) itemidbase, nused, sizeof(struct itemIdSortData),
+ (void*) itemidcompare);
+
+ /* compactify page */
+ ((PageHeader)page)->pd_upper = ((PageHeader)page)->pd_special;
+
+ for (i=0, itemidptr = itemidbase; i
+ lp = ((PageHeader)page)->pd_linp + itemidptr->offsetindex;
+ alignedSize = DOUBLEALIGN((*lp).lp_len);
+ upper = ((PageHeader)page)->pd_upper - alignedSize;
+ memmove((char *) page + upper,
+ (char *)page + (*lp).lp_off,
+ (*lp).lp_len);
+ (*lp).lp_off = upper;
+ ((PageHeader)page)->pd_upper = upper;
+ }
+
+ pfree(itemidbase);
+ }
+}
+
+/*
+ * PageGetFreeSpace --
+ * Returns the size of the free (allocatable) space on a page.
+ */
+Size
+PageGetFreeSpace(Page page)
+{
+ Size space;
+
+
+ space = ((PageHeader)page)->pd_upper - ((PageHeader)page)->pd_lower;
+
+ if (space < sizeof (ItemIdData)) {
+ return (0);
+ }
+ space -= sizeof (ItemIdData); /* XXX not always true */
+
+ return (space);
+}
+
+/*
+ * PageManagerModeSet --
+ *
+ * Sets mode to either: ShufflePageManagerMode (the default) or
+ * OverwritePageManagerMode. For use by access methods code
+ * for determining semantics of PageAddItem when the offsetNumber
+ * argument is passed in.
+ */
+void
+PageManagerModeSet(PageManagerMode mode)
+{
+ if (mode == ShufflePageManagerMode)
+ PageManagerShuffle = true;
+ else if (mode == OverwritePageManagerMode)
+ PageManagerShuffle = false;
+}
+
+/*
+ *----------------------------------------------------------------
+ * PageIndexTupleDelete
+ *----------------------------------------------------------------
+ *
+ * This routine does the work of removing a tuple from an index page.
+ */
+void
+PageIndexTupleDelete(Page page, OffsetNumber offnum)
+{
+ PageHeader phdr;
+ char *addr;
+ ItemId tup;
+ Size size;
+ char *locn;
+ int nbytes;
+ int offidx;
+
+ phdr = (PageHeader) page;
+
+ /* change offset number to offset index */
+ offidx = offnum - 1;
+
+ tup = PageGetItemId(page, offnum);
+ size = ItemIdGetLength(tup);
+ size = DOUBLEALIGN(size);
+
+ /* location of deleted tuple data */
+ locn = (char *) (page + ItemIdGetOffset(tup));
+
+ /*
+ * First, we want to get rid of the pd_linp entry for the index
+ * tuple. We copy all subsequent linp's back one slot in the
+ * array.
+ */
+
+ nbytes = phdr->pd_lower -
+ ((char *)&phdr->pd_linp[offidx + 1] - (char *) phdr);
+ memmove((char *) &(phdr->pd_linp[offidx]),
+ (char *) &(phdr->pd_linp[offidx + 1]),
+ nbytes);
+
+ /*
+ * Now move everything between the old upper bound (beginning of tuple
+ * space) and the beginning of the deleted tuple forward, so that
+ * space in the middle of the page is left free. If we've just deleted
+ * the tuple at the beginning of tuple space, then there's no need
+ * to do the copy (and bcopy on some architectures SEGV's if asked
+ * to move zero bytes).
+ */
+
+ /* beginning of tuple space */
+ addr = (char *) (page + phdr->pd_upper);
+
+ if (locn != addr)
+ memmove(addr + size, addr, (int) (locn - addr));
+
+ /* adjust free space boundary pointers */
+ phdr->pd_upper += size;
+ phdr->pd_lower -= sizeof (ItemIdData);
+
+ /* finally, we need to adjust the linp entries that remain */
+ if (!PageIsEmpty(page))
+ PageIndexTupleDeleteAdjustLinePointers(phdr, locn, size);
+}
+
+/*
+ *----------------------------------------------------------------
+ * PageIndexTupleDeleteAdjustLinePointers
+ *----------------------------------------------------------------
+ *
+ * Once the line pointers and tuple data have been shifted around
+ * on the page, we need to go down the line pointer vector and
+ * adjust pointers to reflect new locations. Anything that used
+ * to be before the deleted tuple's data was moved forward by the
+ * size of the deleted tuple.
+ *
+ * This routine does the work of adjusting the line pointers.
+ * Location is where the tuple data used to lie; size is how
+ * much space it occupied. We assume that size has been aligned
+ * as required by the time we get here.
+ *
+ * This routine should never be called on an empty page.
+ */
+void
+PageIndexTupleDeleteAdjustLinePointers(PageHeader phdr,
+ char *location,
+ Size size)
+{
+ int i;
+
+ /* location is an index into the page... */
+ location -= (int) phdr;
+
+ for (i = PageGetMaxOffsetNumber((Page) phdr) - 1; i >= 0; i--) {
+ if (phdr->pd_linp[i].lp_off <= (unsigned) location) {
+ phdr->pd_linp[i].lp_off += size;
+ }
+ }
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * itemptr.c--
+ * POSTGRES disk item pointer code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/page/itemptr.c,v 1.1.1.1 1996/07/09 06:21:59 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "c.h"
+
+#include "storage/block.h"
+#include "storage/off.h"
+#include "storage/itemptr.h"
+#include "storage/bufpage.h"
+
+/*
+ * ItemPointerEquals --
+ * Returns true if both item pointers point to the same item,
+ * otherwise returns false.
+ *
+ * Note:
+ * Assumes that the disk item pointers are not NULL.
+ */
+bool
+ItemPointerEquals(ItemPointer pointer1, ItemPointer pointer2)
+{
+ if (ItemPointerGetBlockNumber(pointer1) ==
+ ItemPointerGetBlockNumber(pointer2) &&
+ ItemPointerGetOffsetNumber(pointer1) ==
+ ItemPointerGetOffsetNumber(pointer2))
+ return(true);
+ else
+ return(false);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * pagenum.h--
+ * POSTGRES page number definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: pagenum.h,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PAGENUM_H
+#define PAGENUM_H
+
+#include "c.h"
+#include "storage/page.h"
+
+typedef uint16 PageNumber;
+
+typedef uint32 LogicalPageNumber;
+
+#define InvalidLogicalPageNumber 0
+
+/*
+ * LogicalPageNumberIsValid --
+ * True iff the logical page number is valid.
+ */
+#define LogicalPageNumberIsValid(pageNumber) \
+ ((bool)((pageNumber) != InvalidLogicalPageNumber))
+
+
+#endif /* PAGENUM_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * pos.h--
+ * POSTGRES "position" definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: pos.h,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef POS_H
+#define POS_H
+
+#include "c.h"
+
+/*
+ * a 'position' used to be
in postgres. this has+ * been changed to just as the notion of having multiple pages
+ * within a block has been removed.
+ *
+ * the 'offset' abstraction is somewhat confusing. it is NOT a byte
+ * offset within the page; instead, it is an offset into the line
+ * pointer array contained on every page that store (heap or index)
+ * tuples.
+ */
+typedef bits16 PositionIdData;
+typedef PositionIdData *PositionId;
+
+/* ----------------
+ * support macros
+ * ----------------
+ */
+
+/*
+ * PositionIdIsValid --
+ * True iff the position identifier is valid.
+ */
+#define PositionIdIsValid(positionId) \
+ PointerIsValid(positionId)
+
+/*
+ * PositionIdSetInvalid --
+ * Make an invalid position.
+ */
+#define PositionIdSetInvalid(positionId) \
+ *(positionId) = (bits16) 0
+
+/*
+ * PositionIdSet --
+ * Sets a position identifier to the specified value.
+ */
+#define PositionIdSet(positionId, offsetNumber) \
+ *(positionId) = (offsetNumber)
+
+/*
+ * PositionIdGetOffsetNumber --
+ * Retrieve the offset number from a position identifier.
+ */
+#define PositionIdGetOffsetNumber(positionId) \
+ ((OffsetNumber) *(positionId))
+
+#endif /* POS_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * proc.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: proc.h,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef _PROC_H_
+#define _PROC_H_
+
+#include "storage/ipc.h"
+#include "storage/lock.h"
+#ifndef WIN32
+#include
+#else
+/* This is because WIN32 already defines PROC */
+#define PROC PGL_PROC
+#endif /* WIN32 */
+#include "storage/shmem.h"
+
+
+typedef struct {
+ int sleeplock;
+ int semNum;
+ IpcSemaphoreId semId;
+ IpcSemaphoreKey semKey;
+} SEMA;
+
+/*
+ * Each backend has:
+ */
+typedef struct proc {
+
+ /* proc->links MUST BE THE FIRST ELEMENT OF STRUCT (see ProcWakeup()) */
+
+ SHM_QUEUE links; /* proc can be waiting for one event(lock) */
+ SEMA sem; /* ONE semaphore to sleep on */
+ int errType; /* error code tells why we woke up */
+
+ int procId; /* unique number for this structure
+ * NOT unique per backend, these things
+ * are reused after the backend dies.
+ */
+
+ int critSects; /* If critSects > 0, we are in sensitive
+ * routines that cannot be recovered when
+ * the process fails.
+ */
+
+ int prio; /* priority for sleep queue */
+
+ TransactionId xid; /* transaction currently being executed
+ * by this proc
+ */
+
+ LOCK * waitLock; /* Lock we're sleeping on */
+ int token; /* info for proc wakeup routines */
+ int pid; /* This procs process id */
+ short sLocks[MAX_SPINS]; /* Spin lock stats */
+ SHM_QUEUE lockQueue; /* locks associated with current transaction */
+} PROC;
+
+
+/*
+ * MAX_PROC_SEMS is the maximum number of per-process semaphores (those used
+ * by the lock mgr) we can keep track of. PROC_NSEMS_PER_SET is the number
+ * of semaphores in each (sys-V) semaphore set allocated. (Be careful not
+ * to set it to greater 32. Otherwise, the bitmap will overflow.)
+ */
+#define MAX_PROC_SEMS 128
+#define PROC_NSEMS_PER_SET 16
+
+typedef struct procglobal {
+ SHMEM_OFFSET freeProcs;
+ int numProcs;
+ IPCKey currKey;
+ int32 freeSemMap[MAX_PROC_SEMS/PROC_NSEMS_PER_SET];
+} PROC_HDR;
+
+extern PROC *MyProc;
+
+#define PROC_INCR_SLOCK(lock) if (MyProc) (MyProc->sLocks[(lock)])++
+#define PROC_DECR_SLOCK(lock) if (MyProc) (MyProc->sLocks[(lock)])--
+
+/*
+ * flags explaining why process woke up
+ */
+#define NO_ERROR 0
+#define ERR_TIMEOUT 1
+#define ERR_BUFFER_IO 2
+
+#define MAX_PRIO 50
+#define MIN_PRIO (-1)
+
+extern SPINLOCK ProcStructLock;
+
+/*
+ * Function Prototypes
+ */
+extern void InitProcess(IPCKey key);
+extern void ProcReleaseLocks(void);
+extern bool ProcRemove(int pid);
+/* extern bool ProcKill(int exitStatus, int pid); */
+/* make static in storage/lmgr/proc.c -- jolly */
+
+extern PROC_QUEUE *ProcQueueAlloc(char *name);
+extern void ProcQueueInit(PROC_QUEUE *queue);
+extern int ProcSleep(PROC_QUEUE *queue, SPINLOCK spinlock, int token,
+ int prio, LOCK *lock);
+extern PROC *ProcWakeup(PROC *proc, int errType);
+extern int ProcGetId(void);
+extern int ProcLockWakeup(PROC_QUEUE *queue, char * ltable, char * lock);
+extern void ProcAddLock(SHM_QUEUE *elem);
+#if defined(PORTNAME_linux)
+extern int HandleDeadLock(int);
+#else
+extern int HandleDeadLock(void);
+#endif
+extern void ProcReleaseSpins(PROC *proc);
+extern void ProcFreeAllSemaphores(void);
+
+#endif /* PROC_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * shmem.h--
+ * shared memory management structures
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: shmem.h,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef SHMEM_H
+#define SHMEM_H
+
+#include "storage/spin.h" /* for SPINLOCK */
+#include "utils/hsearch.h" /* for HTAB */
+
+/* The shared memory region can start at a different address
+ * in every process. Shared memory "pointers" are actually
+ * offsets relative to the start of the shared memory region(s).
+ */
+typedef unsigned long SHMEM_OFFSET;
+#define INVALID_OFFSET (-1)
+#define BAD_LOCATION (-1)
+
+/* start of the lowest shared memory region. For now, assume that
+ * there is only one shared memory region
+ */
+extern SHMEM_OFFSET ShmemBase;
+
+
+/* coerce an offset into a pointer in this process's address space */
+#define MAKE_PTR(xx_offs)\
+ (ShmemBase+((unsigned long)(xx_offs)))
+
+/* coerce a pointer into a shmem offset */
+#define MAKE_OFFSET(xx_ptr)\
+ (SHMEM_OFFSET) (((unsigned long)(xx_ptr))-ShmemBase)
+
+#define SHM_PTR_VALID(xx_ptr)\
+ (((unsigned long)xx_ptr) > ShmemBase)
+
+/* cannot have an offset to ShmemFreeStart (offset 0) */
+#define SHM_OFFSET_VALID(xx_offs)\
+ ((xx_offs != 0) && (xx_offs != INVALID_OFFSET))
+
+
+extern SPINLOCK ShmemLock;
+extern SPINLOCK BindingLock;
+
+/* shmemqueue.c */
+typedef struct SHM_QUEUE {
+ SHMEM_OFFSET prev;
+ SHMEM_OFFSET next;
+} SHM_QUEUE;
+
+/* shmem.c */
+extern void ShmemBindingTabReset();
+extern void ShmemCreate(unsigned int key, unsigned int size);
+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,
+ 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,
+ bool *foundPtr);
+
+
+typedef int TableID;
+
+/* size constants for the binding table */
+ /* max size of data structure string name */
+#define BTABLE_KEYSIZE (50)
+ /* data in binding table hash bucket */
+#define BTABLE_DATASIZE (sizeof(BindingEnt) - BTABLE_KEYSIZE)
+ /* maximum size of the binding table */
+#define BTABLE_SIZE (100)
+
+/* this is a hash bucket in the binding table */
+typedef struct {
+ char key[BTABLE_KEYSIZE]; /* string name */
+ unsigned long location; /* location in shared mem */
+ unsigned long size; /* numbytes allocated for the
+ * structure
+ */
+} BindingEnt;
+
+/*
+ * prototypes for functions in shmqueue.c
+ */
+extern void SHMQueueInit(SHM_QUEUE *queue);
+extern bool SHMQueueIsDetached(SHM_QUEUE *queue);
+extern void SHMQueueElemInit(SHM_QUEUE *queue);
+extern void SHMQueueDelete(SHM_QUEUE *queue);
+extern void SHMQueueInsertHD(SHM_QUEUE *queue, SHM_QUEUE *elem);
+extern void SHMQueueInsertTL(SHM_QUEUE *queue, SHM_QUEUE *elem);
+extern void SHMQueueFirst(SHM_QUEUE *queue, Pointer *nextPtrPtr,
+ SHM_QUEUE *nextQueue);
+extern bool SHMQueueEmpty(SHM_QUEUE *queue);
+
+#endif /* SHMEM_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * sinval.h--
+ * POSTGRES shared cache invalidation communication definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: sinval.h,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef SINVAL_H
+#define SINVAL_H
+
+#include "c.h"
+#include "storage/spin.h"
+#include "storage/ipc.h"
+#include "storage/itemptr.h"
+#include "storage/backendid.h"
+
+extern SPINLOCK SInvalLock;
+
+extern void CreateSharedInvalidationState(IPCKey key);
+extern void AttachSharedInvalidationState(IPCKey key);
+extern void InitSharedInvalidationState();
+extern void RegisterSharedInvalid(int cacheId, Index hashIndex,
+ ItemPointer pointer);
+extern void InvalidateSharedInvalid(void (*invalFunction)(),
+ void (*resetFunction)());
+
+
+#endif /* SINVAL_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * sinvaladt.h--
+ * POSTGRES shared cache invalidation segment definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: sinvaladt.h,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef SINVALADT_H
+#define SINVALADT_H
+
+#include "postgres.h" /* XXX */
+
+#include "storage/ipc.h"
+#include "storage/itemptr.h"
+#include "storage/sinval.h"
+
+/*
+ * The structure of the shared cache invaidation segment
+ *
+ */
+/*
+A------------- Header info --------------
+ criticalSectionSemaphoreId
+ generalSemaphoreId
+ startEntrySection (offset a)
+ endEntrySection (offset a + b)
+ startFreeSpace (offset relative to B)
+ startEntryChain (offset relatiev to B)
+ endEntryChain (offset relative to B)
+ numEntries
+ maxNumEntries
+ procState[MaxBackendId] --> limit
+ resetState (bool)
+a tag (POSTID)
+B------------- Start entry section -------
+ SISegEntry --> entryData --> ... (see SharedInvalidData!)
+ isfree (bool)
+ next (offset to next entry in chain )
+b .... (dynamically growing down)
+C----------------End shared segment -------
+
+*/
+
+/* Parameters (configurable) *******************************************/
+#define MaxBackendId 32 /* maximum number of backends */
+#define MAXNUMMESSAGES 1000 /* maximum number of messages in seg*/
+
+
+#define InvalidOffset 1000000000 /* a invalid offset (End of chain) */
+
+typedef struct ProcState {
+ int limit; /* the number of read messages */
+ bool resetState; /* true, if backend has to reset its state */
+ int tag; /* special tag, recieved from the postmaster */
+} ProcState;
+
+
+typedef struct SISeg {
+ IpcSemaphoreId criticalSectionSemaphoreId; /* semaphore id */
+ IpcSemaphoreId generalSemaphoreId; /* semaphore id */
+ Offset startEntrySection; /* (offset a) */
+ Offset endEntrySection; /* (offset a + b) */
+ Offset startFreeSpace; /* (offset relative to B) */
+ Offset startEntryChain; /* (offset relative to B) */
+ Offset endEntryChain; /* (offset relative to B) */
+ int numEntries;
+ int maxNumEntries;
+ ProcState procState[MaxBackendId]; /* reflects the invalidation state */
+ /* here starts the entry section, controlled by offsets */
+} SISeg;
+#define SizeSISeg sizeof(SISeg)
+
+typedef struct SharedInvalidData {
+ int cacheId; /* XXX */
+ Index hashIndex;
+ ItemPointerData pointerData;
+} SharedInvalidData;
+
+typedef SharedInvalidData *SharedInvalid;
+
+
+typedef struct SISegEntry {
+ SharedInvalidData entryData; /* the message data */
+ bool isfree; /* entry free? */
+ Offset next; /* offset to next entry*/
+} SISegEntry;
+
+#define SizeOfOneSISegEntry sizeof(SISegEntry)
+
+typedef struct SISegOffsets {
+ Offset startSegment; /* always 0 (for now) */
+ Offset offsetToFirstEntry; /* A + a = B */
+ Offset offsetToEndOfSegemnt; /* A + a + b */
+} SISegOffsets;
+
+
+/****************************************************************************/
+/* synchronization of the shared buffer access */
+/* access to the buffer is synchronized by the lock manager !! */
+/****************************************************************************/
+
+#define SI_LockStartValue 255
+#define SI_SharedLock (-1)
+#define SI_ExclusiveLock (-255)
+
+extern SISeg *shmInvalBuffer;
+
+/*
+ * prototypes for functions in sinvaladt.c
+ */
+extern int SIBackendInit(SISeg *segInOutP);
+extern int SISegmentInit(bool killExistingSegment, IPCKey key);
+
+extern bool SISetDataEntry(SISeg *segP, SharedInvalidData *data);
+extern void SISetProcStateInvalid(SISeg *segP);
+extern bool SIDelDataEntry(SISeg *segP);
+extern void SIReadEntryData(SISeg *segP, int backendId,
+ void (*invalFunction)(), void (*resetFunction)());
+extern void SIDelExpiredDataEntries(SISeg *segP);
+
+#endif /* SINVALADT_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * smgr.h--
+ * storage manager switch public interface declarations.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: smgr.h,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef SMGR_H
+#define SMGR_H
+
+#include "utils/rel.h"
+#include "storage/spin.h" /* for SPINLOCK */
+
+#define SM_FAIL 0
+#define SM_SUCCESS 1
+
+#define DEFAULT_SMGR 0
+
+extern int smgrinit(void);
+extern void smgrshutdown(int dummy);
+extern int smgrcreate(int16 which, Relation reln);
+extern int smgrunlink(int16 which, Relation reln);
+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,
+ char *buffer);
+extern int smgrwrite(int16 which, Relation reln, BlockNumber blocknum,
+ char *buffer);
+extern int smgrflush(int16 which, Relation reln, BlockNumber blocknum,
+ char *buffer);
+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 smgrcommit(void);
+extern int smgrabort(void);
+extern bool smgriswo(int16 smgrno);
+
+
+
+/* internals: move me elsewhere -- ay 7/94 */
+
+/* in md.c */
+extern int mdinit(void);
+extern int mdcreate(Relation reln);
+extern int mdunlink(Relation reln);
+extern int mdextend(Relation reln, char *buffer);
+extern int mdopen(Relation reln);
+extern int mdclose(Relation reln);
+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,
+ BlockNumber blkno, char *buffer);
+extern int mdnblocks(Relation reln);
+extern int mdcommit(void);
+extern int mdabort(void);
+
+/* mm.c */
+extern SPINLOCK MMCacheLock;
+
+extern int mminit(void);
+extern int mmshutdown(void);
+extern int mmcreate(Relation reln);
+extern int mmunlink(Relation reln);
+extern int mmextend(Relation reln, char *buffer);
+extern int mmopen(Relation reln);
+extern int mmclose(Relation reln);
+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,
+ BlockNumber blkno, char *buffer);
+extern int mmnblocks(Relation reln);
+extern int mmcommit(void);
+extern int mmabort(void);
+extern int MMShmemSize(void);
+
+#endif /* SMGR_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for storage/smgr
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/storage/smgr/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:59 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= md.c mm.c smgr.c smgrtype.c
--- /dev/null
+# $Header: /cvsroot/pgsql/src/backend/storage/smgr/README,v 1.1.1.1 1996/07/09 06:21:59 scrappy Exp $
+
+This directory contains the code that supports the Postgres storage manager
+switch and all of the installed storage managers. In released systems,
+the only supported storage manager is the magnetic disk manager. At UC
+Berkeley, the Sony WORM optical disk jukebox and persistent main memory are
+also supported.
+
+As of Postgres Release 3.0, every relation in the system is tagged with the
+storage manager on which it resides. The storage manager switch code turns
+what used to by filesystem operations into operations on the correct store,
+for any given relation.
+
+The files in this directory, and their contents, are
+
+ smgrtype.c Storage manager type -- maps string names to storage manager
+ IDs and provides simple comparison operators. This is the
+ regproc support for type 'smgr' in the system catalogs.
+
+ smgr.c The storage manager switch dispatch code. The routines in
+ this file call the appropriate storage manager to do hardware
+ accesses requested by the backend.
+
+ md.c The magnetic disk storage manager.
+
+ mm.c The persistent main memory storage manager (#undef'ed in
+ tmp/c.h for all distributed systems).
+
+ sj.c The sony jukebox storage manager and cache management code
+ (#undef'ed in tmp/c.h for all distributed systems). The
+ routines in this file allocate extents, maintain block
+ maps, and guarantee the persistence and coherency of a cache
+ of jukebox blocks on magnetic disk.
+
+ pgjb.c The postgres jukebox interface routines. The routines here
+ handle exclusion on the physical device and translate requests
+ from the storage manager code (sj.c) into jbaccess calls.
+
+ jbaccess.c Access code for the physical Sony jukebox device. This code
+ was swiped from Andy McFadden's jblib.a code at UC Berkeley.
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * md.c--
+ * This code manages relations that reside on magnetic disk.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/smgr/md.c,v 1.1.1.1 1996/07/09 06:21:59 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* for sprintf() */
+#include
+
+#include "postgres.h"
+#include "miscadmin.h" /* for DataDir */
+
+#include "machine.h"
+#include "storage/smgr.h" /* where the declarations go */
+#include "storage/block.h"
+#include "storage/fd.h"
+#include "utils/mcxt.h"
+#include "utils/rel.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "catalog/catalog.h"
+
+#undef DIAGNOSTIC
+
+/*
+ * The magnetic disk storage manager keeps track of open file descriptors
+ * in its own descriptor pool. This happens for two reasons. First, at
+ * transaction boundaries, we walk the list of descriptors and flush
+ * anything that we've dirtied in the current transaction. Second, we
+ * have to support relations of > 4GBytes. In order to do this, we break
+ * relations up into chunks of < 2GBytes and store one chunk in each of
+ * several files that represent the relation.
+ */
+
+typedef struct _MdfdVec {
+ int mdfd_vfd; /* fd number in vfd pool */
+ uint16 mdfd_flags; /* clean, dirty */
+ int mdfd_lstbcnt; /* most recent block count */
+ struct _MdfdVec *mdfd_chain; /* for large relations */
+} MdfdVec;
+
+static int Nfds = 100;
+static MdfdVec *Md_fdvec = (MdfdVec *) NULL;
+static int CurFd = 0;
+static MemoryContext MdCxt;
+
+#define MDFD_DIRTY (uint16) 0x01
+
+#define RELSEG_SIZE 262144 /* (2 ** 31) / 8192 -- 2GB file */
+
+/* routines declared here */
+static MdfdVec *_mdfd_openseg(Relation reln, int segno, int oflags);
+static MdfdVec *_mdfd_getseg(Relation reln, int blkno, int oflag);
+static int _fdvec_ext(void);
+static BlockNumber _mdnblocks(File file, Size blcksz);
+
+/*
+ * mdinit() -- Initialize private state for magnetic disk storage manager.
+ *
+ * We keep a private table of all file descriptors. Whenever we do
+ * a write to one, we mark it dirty in our table. Whenever we force
+ * changes to disk, we mark the file descriptor clean. At transaction
+ * commit, we force changes to disk for all dirty file descriptors.
+ * This routine allocates and initializes the table.
+ *
+ * Returns SM_SUCCESS or SM_FAIL with errno set as appropriate.
+ */
+int
+mdinit()
+{
+ MemoryContext oldcxt;
+
+ MdCxt = (MemoryContext) CreateGlobalMemory("MdSmgr");
+ if (MdCxt == (MemoryContext) NULL)
+ return (SM_FAIL);
+
+ oldcxt = MemoryContextSwitchTo(MdCxt);
+ Md_fdvec = (MdfdVec *) palloc(Nfds * sizeof(MdfdVec));
+ (void) MemoryContextSwitchTo(oldcxt);
+
+ if (Md_fdvec == (MdfdVec *) NULL)
+ return (SM_FAIL);
+
+ memset(Md_fdvec, 0, Nfds * sizeof(MdfdVec));
+
+ return (SM_SUCCESS);
+}
+
+int
+mdcreate(Relation reln)
+{
+ int fd, vfd;
+ int tmp;
+ char *path;
+ extern bool IsBootstrapProcessingMode();
+
+ path = relpath(&(reln->rd_rel->relname.data[0]));
+ fd = FileNameOpenFile(path, O_RDWR|O_CREAT|O_EXCL, 0600);
+
+ /*
+ * If the file already exists and is empty, we pretend that the
+ * create succeeded. During bootstrap processing, we skip that check,
+ * because pg_time, pg_variable, and pg_log get created before their
+ * .bki file entries are processed.
+ */
+
+ if (fd < 0) {
+ if ((fd = FileNameOpenFile(path, O_RDWR, 0600)) >= 0) {
+ if (!IsBootstrapProcessingMode() &&
+ FileRead(fd, (char *) &tmp, sizeof(tmp)) != 0) {
+ FileClose(fd);
+ return (-1);
+ }
+ }
+ }
+
+ if (CurFd >= Nfds) {
+ if (_fdvec_ext() == SM_FAIL)
+ return (-1);
+ }
+
+ Md_fdvec[CurFd].mdfd_vfd = fd;
+ Md_fdvec[CurFd].mdfd_flags = (uint16) 0;
+ Md_fdvec[CurFd].mdfd_chain = (MdfdVec *) NULL;
+ Md_fdvec[CurFd].mdfd_lstbcnt = 0;
+
+ vfd = CurFd++;
+
+ return (vfd);
+}
+
+/*
+ * mdunlink() -- Unlink a relation.
+ */
+int
+mdunlink(Relation reln)
+{
+ int fd;
+ int i;
+ MdfdVec *v, *ov;
+ MemoryContext oldcxt;
+ char fname[20]; /* XXX should have NAMESIZE defined */
+ char tname[20];
+
+ /* On Windows NT you can't unlink a file if it is open so we have
+ ** to do this.
+ */
+#ifdef WIN32
+ (void) mdclose(reln);
+#endif /* WIN32 */
+
+
+ memset(fname,0,20);
+ strncpy(fname, RelationGetRelationName(reln)->data, 16);
+
+ if (FileNameUnlink(fname) < 0)
+ return (SM_FAIL);
+
+ /* unlink all the overflow files for large relations */
+ for (i = 1; ; i++) {
+#ifdef WIN32
+ (void) mdclose(reln);
+#endif /* WIN32 */
+ sprintf(tname, "%s.%d", fname, i);
+ if (FileNameUnlink(tname) < 0)
+ break;
+ }
+
+ /* finally, clean out the mdfd vector */
+ fd = RelationGetFile(reln);
+ Md_fdvec[fd].mdfd_flags = (uint16) 0;
+
+ oldcxt = MemoryContextSwitchTo(MdCxt);
+ for (v = &Md_fdvec[fd]; v != (MdfdVec *) NULL; ) {
+ ov = v;
+ v = v->mdfd_chain;
+ if (ov != &Md_fdvec[fd])
+ pfree(ov);
+ }
+ Md_fdvec[fd].mdfd_chain = (MdfdVec *) NULL;
+ (void) MemoryContextSwitchTo(oldcxt);
+
+ return (SM_SUCCESS);
+}
+
+/*
+ * mdextend() -- Add a block to the specified relation.
+ *
+ * This routine returns SM_FAIL or SM_SUCCESS, with errno set as
+ * appropriate.
+ */
+int
+mdextend(Relation reln, char *buffer)
+{
+ long pos;
+ int nblocks;
+ MdfdVec *v;
+
+ nblocks = mdnblocks(reln);
+ v = _mdfd_getseg(reln, nblocks, O_CREAT);
+
+ if ((pos = FileSeek(v->mdfd_vfd, 0L, SEEK_END)) < 0)
+ return (SM_FAIL);
+
+ if (FileWrite(v->mdfd_vfd, buffer, BLCKSZ) != BLCKSZ)
+ return (SM_FAIL);
+
+ /* remember that we did a write, so we can sync at xact commit */
+ v->mdfd_flags |= MDFD_DIRTY;
+
+ /* try to keep the last block count current, though it's just a hint */
+ if ((v->mdfd_lstbcnt = (++nblocks % RELSEG_SIZE)) == 0)
+ v->mdfd_lstbcnt = RELSEG_SIZE;
+
+#ifdef DIAGNOSTIC
+ if (_mdnblocks(v->mdfd_vfd, BLCKSZ) > RELSEG_SIZE
+ || v->mdfd_lstbcnt > RELSEG_SIZE)
+ elog(FATAL, "segment too big!");
+#endif
+
+ return (SM_SUCCESS);
+}
+
+/*
+ * mdopen() -- Open the specified relation.
+ */
+int
+mdopen(Relation reln)
+{
+ char *path;
+ int fd;
+ int vfd;
+
+ if (CurFd >= Nfds) {
+ if (_fdvec_ext() == SM_FAIL)
+ return (-1);
+ }
+
+ path = relpath(&(reln->rd_rel->relname.data[0]));
+
+ fd = FileNameOpenFile(path, O_RDWR, 0600);
+
+ /* this should only happen during bootstrap processing */
+ if (fd < 0)
+ fd = FileNameOpenFile(path, O_RDWR|O_CREAT|O_EXCL, 0600);
+
+ Md_fdvec[CurFd].mdfd_vfd = fd;
+ Md_fdvec[CurFd].mdfd_flags = (uint16) 0;
+ Md_fdvec[CurFd].mdfd_chain = (MdfdVec *) NULL;
+ Md_fdvec[CurFd].mdfd_lstbcnt = _mdnblocks(fd, BLCKSZ);
+
+#ifdef DIAGNOSTIC
+ if (Md_fdvec[CurFd].mdfd_lstbcnt > RELSEG_SIZE)
+ elog(FATAL, "segment too big on relopen!");
+#endif
+
+ vfd = CurFd++;
+
+ return (vfd);
+}
+
+/*
+ * mdclose() -- Close the specified relation.
+ *
+ * Returns SM_SUCCESS or SM_FAIL with errno set as appropriate.
+ */
+int
+mdclose(Relation reln)
+{
+ int fd;
+ MdfdVec *v;
+
+ fd = RelationGetFile(reln);
+
+ for (v = &Md_fdvec[fd]; v != (MdfdVec *) NULL; v = v->mdfd_chain) {
+
+ /* may be closed already */
+ if (v->mdfd_vfd < 0)
+ continue;
+
+ /*
+ * We sync the file descriptor so that we don't need to reopen it at
+ * transaction commit to force changes to disk.
+ */
+
+ FileSync(v->mdfd_vfd);
+ FileClose(v->mdfd_vfd);
+
+ /* mark this file descriptor as clean in our private table */
+ v->mdfd_flags &= ~MDFD_DIRTY;
+ }
+
+ return (SM_SUCCESS);
+}
+
+/*
+ * mdread() -- Read the specified block from a relation.
+ *
+ * Returns SM_SUCCESS or SM_FAIL.
+ */
+int
+mdread(Relation reln, BlockNumber blocknum, char *buffer)
+{
+ int status;
+ long seekpos;
+ int nbytes;
+ MdfdVec *v;
+
+ v = _mdfd_getseg(reln, blocknum, 0);
+
+ seekpos = (long) (BLCKSZ * (blocknum % RELSEG_SIZE));
+
+#ifdef DIAGNOSTIC
+ if (seekpos >= BLCKSZ * RELSEG_SIZE)
+ elog(FATAL, "seekpos too big!");
+#endif
+
+ if (FileSeek(v->mdfd_vfd, seekpos, SEEK_SET) != seekpos) {
+ return (SM_FAIL);
+ }
+
+ status = SM_SUCCESS;
+ if ((nbytes = FileRead(v->mdfd_vfd, buffer, BLCKSZ)) != BLCKSZ) {
+ if (nbytes == 0) {
+ memset(buffer, 0, BLCKSZ);
+ } else {
+ status = SM_FAIL;
+ }
+ }
+
+ return (status);
+}
+
+/*
+ * mdwrite() -- Write the supplied block at the appropriate location.
+ *
+ * Returns SM_SUCCESS or SM_FAIL.
+ */
+int
+mdwrite(Relation reln, BlockNumber blocknum, char *buffer)
+{
+ int status;
+ long seekpos;
+ MdfdVec *v;
+
+ v = _mdfd_getseg(reln, blocknum, 0);
+
+ seekpos = (long) (BLCKSZ * (blocknum % RELSEG_SIZE));
+#ifdef DIAGNOSTIC
+ if (seekpos >= BLCKSZ * RELSEG_SIZE)
+ elog(FATAL, "seekpos too big!");
+#endif
+
+ if (FileSeek(v->mdfd_vfd, seekpos, SEEK_SET) != seekpos) {
+ return (SM_FAIL);
+ }
+
+ status = SM_SUCCESS;
+ if (FileWrite(v->mdfd_vfd, buffer, BLCKSZ) != BLCKSZ)
+ status = SM_FAIL;
+
+ v->mdfd_flags |= MDFD_DIRTY;
+
+ return (status);
+}
+
+/*
+ * mdflush() -- Synchronously write a block to disk.
+ *
+ * This is exactly like mdwrite(), but doesn't return until the file
+ * system buffer cache has been flushed.
+ */
+int
+mdflush(Relation reln, BlockNumber blocknum, char *buffer)
+{
+ int status;
+ long seekpos;
+ MdfdVec *v;
+
+ v = _mdfd_getseg(reln, blocknum, 0);
+
+ seekpos = (long) (BLCKSZ * (blocknum % RELSEG_SIZE));
+#ifdef DIAGNOSTIC
+ if (seekpos >= BLCKSZ * RELSEG_SIZE)
+ elog(FATAL, "seekpos too big!");
+#endif
+
+ if (FileSeek(v->mdfd_vfd, seekpos, SEEK_SET) != seekpos) {
+ return (SM_FAIL);
+ }
+
+ /* write and sync the block */
+ status = SM_SUCCESS;
+ if (FileWrite(v->mdfd_vfd, buffer, BLCKSZ) != BLCKSZ
+ || FileSync(v->mdfd_vfd) < 0)
+ status = SM_FAIL;
+
+ /*
+ * By here, the block is written and changes have been forced to stable
+ * storage. Mark the descriptor as clean until the next write, so we
+ * don't sync it again unnecessarily at transaction commit.
+ */
+
+ v->mdfd_flags &= ~MDFD_DIRTY;
+
+ return (status);
+}
+
+/*
+ * mdblindwrt() -- Write a block to disk blind.
+ *
+ * We have to be able to do this using only the name and OID of
+ * the database and relation in which the block belongs. This
+ * is a synchronous write.
+ */
+int
+mdblindwrt(char *dbstr,
+ char *relstr,
+ Oid dbid,
+ Oid relid,
+ BlockNumber blkno,
+ char *buffer)
+{
+ int fd;
+ int segno;
+ long seekpos;
+ int status;
+ char *path;
+ int nchars;
+
+ /* be sure we have enough space for the '.segno', if any */
+ segno = blkno / RELSEG_SIZE;
+ if (segno > 0)
+ nchars = 10;
+ else
+ nchars = 0;
+
+ /* construct the path to the file and open it */
+ if (dbid == (Oid) 0) {
+ path = (char *) palloc(strlen(DataDir) + sizeof(NameData) + 2 + nchars);
+ if (segno == 0)
+ sprintf(path, "%s/%.*s", DataDir, NAMEDATALEN, relstr);
+ else
+ sprintf(path, "%s/%.*s.%d", DataDir, NAMEDATALEN, relstr, segno);
+ } else {
+ path = (char *) palloc(strlen(DataDir) + strlen("/base/") + 2 * sizeof(NameData) + 2 + nchars);
+ if (segno == 0)
+ sprintf(path, "%s/base/%.*s/%.*s", DataDir, NAMEDATALEN,
+ dbstr, NAMEDATALEN, relstr);
+ else
+ sprintf(path, "%s/base/%.*s/%.*s.%d", DataDir, NAMEDATALEN, dbstr,
+ NAMEDATALEN, relstr, segno);
+ }
+
+ if ((fd = open(path, O_RDWR, 0600)) < 0)
+ return (SM_FAIL);
+
+ /* seek to the right spot */
+ seekpos = (long) (BLCKSZ * (blkno % RELSEG_SIZE));
+ if (lseek(fd, seekpos, SEEK_SET) != seekpos) {
+ (void) close(fd);
+ return (SM_FAIL);
+ }
+
+ status = SM_SUCCESS;
+
+ /* write and sync the block */
+ if (write(fd, buffer, BLCKSZ) != BLCKSZ || fsync(fd) < 0)
+ status = SM_FAIL;
+
+ if (close(fd) < 0)
+ status = SM_FAIL;
+
+ pfree(path);
+
+ return (status);
+}
+
+/*
+ * mdnblocks() -- Get the number of blocks stored in a relation.
+ *
+ * Returns # of blocks or -1 on error.
+ */
+int
+mdnblocks(Relation reln)
+{
+ int fd;
+ MdfdVec *v;
+ int nblocks;
+ int segno;
+
+ fd = RelationGetFile(reln);
+ v = &Md_fdvec[fd];
+
+#ifdef DIAGNOSTIC
+ if (_mdnblocks(v->mdfd_vfd, BLCKSZ) > RELSEG_SIZE)
+ elog(FATAL, "segment too big in getseg!");
+#endif
+
+ segno = 0;
+ for (;;) {
+ if (v->mdfd_lstbcnt == RELSEG_SIZE
+ || (nblocks = _mdnblocks(v->mdfd_vfd, BLCKSZ)) == RELSEG_SIZE) {
+
+ v->mdfd_lstbcnt = RELSEG_SIZE;
+ segno++;
+
+ if (v->mdfd_chain == (MdfdVec *) NULL) {
+ v->mdfd_chain = _mdfd_openseg(reln, segno, O_CREAT);
+ if (v->mdfd_chain == (MdfdVec *) NULL)
+ elog(WARN, "cannot count blocks for %.16s -- open failed",
+ RelationGetRelationName(reln));
+ }
+
+ v = v->mdfd_chain;
+ } else {
+ return ((segno * RELSEG_SIZE) + nblocks);
+ }
+ }
+}
+
+/*
+ * mdcommit() -- Commit a transaction.
+ *
+ * All changes to magnetic disk relations must be forced to stable
+ * storage. This routine makes a pass over the private table of
+ * file descriptors. Any descriptors to which we have done writes,
+ * but not synced, are synced here.
+ *
+ * Returns SM_SUCCESS or SM_FAIL with errno set as appropriate.
+ */
+int
+mdcommit()
+{
+ int i;
+ MdfdVec *v;
+
+ for (i = 0; i < CurFd; i++) {
+ for (v = &Md_fdvec[i]; v != (MdfdVec *) NULL; v = v->mdfd_chain) {
+ if (v->mdfd_flags & MDFD_DIRTY) {
+ if (FileSync(v->mdfd_vfd) < 0)
+ return (SM_FAIL);
+
+ v->mdfd_flags &= ~MDFD_DIRTY;
+ }
+ }
+ }
+
+ return (SM_SUCCESS);
+}
+
+/*
+ * mdabort() -- Abort a transaction.
+ *
+ * Changes need not be forced to disk at transaction abort. We mark
+ * all file descriptors as clean here. Always returns SM_SUCCESS.
+ */
+int
+mdabort()
+{
+ int i;
+ MdfdVec *v;
+
+ for (i = 0; i < CurFd; i++) {
+ for (v = &Md_fdvec[i]; v != (MdfdVec *) NULL; v = v->mdfd_chain) {
+ v->mdfd_flags &= ~MDFD_DIRTY;
+ }
+ }
+
+ return (SM_SUCCESS);
+}
+
+/*
+ * _fdvec_ext() -- Extend the md file descriptor vector.
+ *
+ * The file descriptor vector must be large enough to hold at least
+ * 'fd' entries.
+ */
+static
+int _fdvec_ext()
+{
+ MdfdVec *nvec;
+ MemoryContext oldcxt;
+
+ Nfds *= 2;
+
+ oldcxt = MemoryContextSwitchTo(MdCxt);
+
+ nvec = (MdfdVec *) palloc(Nfds * sizeof(MdfdVec));
+ memset(nvec, 0, Nfds * sizeof(MdfdVec));
+ memmove(nvec, (char *) Md_fdvec, (Nfds / 2) * sizeof(MdfdVec));
+ pfree(Md_fdvec);
+
+ (void) MemoryContextSwitchTo(oldcxt);
+
+ Md_fdvec = nvec;
+
+ return (SM_SUCCESS);
+}
+
+static MdfdVec *
+_mdfd_openseg(Relation reln, int segno, int oflags)
+{
+ MemoryContext oldcxt;
+ MdfdVec *v;
+ int fd;
+ bool dofree;
+ char *path, *fullpath;
+
+ /* be sure we have enough space for the '.segno', if any */
+ path = relpath(RelationGetRelationName(reln)->data);
+
+ dofree = false;
+ if (segno > 0) {
+ dofree = true;
+ fullpath = (char *) palloc(strlen(path) + 12);
+ sprintf(fullpath, "%s.%d", path, segno);
+ } else
+ fullpath = path;
+
+ /* open the file */
+ fd = PathNameOpenFile(fullpath, O_RDWR|oflags, 0600);
+
+ if (dofree)
+ pfree(fullpath);
+
+ if (fd < 0)
+ return ((MdfdVec *) NULL);
+
+ /* allocate an mdfdvec entry for it */
+ oldcxt = MemoryContextSwitchTo(MdCxt);
+ v = (MdfdVec *) palloc(sizeof(MdfdVec));
+ (void) MemoryContextSwitchTo(oldcxt);
+
+ /* fill the entry */
+ v->mdfd_vfd = fd;
+ v->mdfd_flags = (uint16) 0;
+ v->mdfd_chain = (MdfdVec *) NULL;
+ v->mdfd_lstbcnt = _mdnblocks(fd, BLCKSZ);
+
+#ifdef DIAGNOSTIC
+ if (v->mdfd_lstbcnt > RELSEG_SIZE)
+ elog(FATAL, "segment too big on open!");
+#endif
+
+ /* all done */
+ return (v);
+}
+
+static MdfdVec *
+_mdfd_getseg(Relation reln, int blkno, int oflag)
+{
+ MdfdVec *v;
+ int segno;
+ int fd;
+ int i;
+
+ fd = RelationGetFile(reln);
+ if (fd < 0) {
+ if ((fd = mdopen(reln)) < 0)
+ elog(WARN, "cannot open relation %.16s",
+ RelationGetRelationName(reln));
+ reln->rd_fd = fd;
+ }
+
+ for (v = &Md_fdvec[fd], segno = blkno / RELSEG_SIZE, i = 1;
+ segno > 0;
+ i++, segno--) {
+
+ if (v->mdfd_chain == (MdfdVec *) NULL) {
+ v->mdfd_chain = _mdfd_openseg(reln, i, oflag);
+
+ if (v->mdfd_chain == (MdfdVec *) NULL)
+ elog(WARN, "cannot open segment %d of relation %.16s",
+ i, RelationGetRelationName(reln));
+ }
+ v = v->mdfd_chain;
+ }
+
+ return (v);
+}
+
+static BlockNumber
+_mdnblocks(File file, Size blcksz)
+{
+ long len;
+
+ len = FileSeek(file, 0L, SEEK_END) - 1;
+ return((BlockNumber)((len < 0) ? 0 : 1 + len / blcksz));
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * mm.c--
+ * main memory storage manager
+ *
+ * This code manages relations that reside in (presumably stable)
+ * main memory.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/smgr/Attic/mm.c,v 1.1.1.1 1996/07/09 06:21:59 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#ifdef MAIN_MEMORY
+
+#include
+#include "machine.h"
+#include "storage/ipc.h"
+#include "storage/smgr.h" /* where the declarations go */
+#include "storage/block.h"
+#include "storage/shmem.h"
+#include "storage/spin.h"
+
+#include "utils/hsearch.h"
+#include "utils/rel.h"
+#include "utils/elog.h"
+#include "utils/memutils.h"
+
+/*
+ * MMCacheTag -- Unique triplet for blocks stored by the main memory
+ * storage manager.
+ */
+
+typedef struct MMCacheTag {
+ Oid mmct_dbid;
+ Oid mmct_relid;
+ BlockNumber mmct_blkno;
+} MMCacheTag;
+
+/*
+ * Shared-memory hash table for main memory relations contains
+ * entries of this form.
+ */
+
+typedef struct MMHashEntry {
+ MMCacheTag mmhe_tag;
+ int mmhe_bufno;
+} MMHashEntry;
+
+/*
+ * MMRelTag -- Unique identifier for each relation that is stored in the
+ * main-memory storage manager.
+ */
+
+typedef struct MMRelTag {
+ Oid mmrt_dbid;
+ Oid mmrt_relid;
+} MMRelTag;
+
+/*
+ * Shared-memory hash table for # blocks in main memory relations contains
+ * entries of this form.
+ */
+
+typedef struct MMRelHashEntry {
+ MMRelTag mmrhe_tag;
+ int mmrhe_nblocks;
+} MMRelHashEntry;
+
+#define MMNBUFFERS 10
+#define MMNRELATIONS 2
+
+SPINLOCK MMCacheLock;
+extern bool IsPostmaster;
+extern Oid MyDatabaseId;
+
+static int *MMCurTop;
+static int *MMCurRelno;
+static MMCacheTag *MMBlockTags;
+static char *MMBlockCache;
+static HTAB *MMCacheHT;
+static HTAB *MMRelCacheHT;
+
+int
+mminit()
+{
+ char *mmcacheblk;
+ int mmsize = 0;
+ bool found;
+ HASHCTL info;
+
+ SpinAcquire(MMCacheLock);
+
+ mmsize += MAXALIGN(BLCKSZ * MMNBUFFERS);
+ mmsize += MAXALIGN(sizeof(*MMCurTop));
+ mmsize += MAXALIGN(sizeof(*MMCurRelno));
+ mmsize += MAXALIGN((MMNBUFFERS * sizeof(MMCacheTag)));
+ mmcacheblk = (char *) ShmemInitStruct("Main memory smgr", mmsize, &found);
+
+ if (mmcacheblk == (char *) NULL) {
+ SpinRelease(MMCacheLock);
+ return (SM_FAIL);
+ }
+
+ info.keysize = sizeof(MMCacheTag);
+ info.datasize = sizeof(int);
+ info.hash = tag_hash;
+
+ MMCacheHT = (HTAB *) ShmemInitHash("Main memory store HT",
+ MMNBUFFERS, MMNBUFFERS,
+ &info, (HASH_ELEM|HASH_FUNCTION));
+
+ if (MMCacheHT == (HTAB *) NULL) {
+ SpinRelease(MMCacheLock);
+ return (SM_FAIL);
+ }
+
+ info.keysize = sizeof(MMRelTag);
+ info.datasize = sizeof(int);
+ info.hash = tag_hash;
+
+ MMRelCacheHT = (HTAB *) ShmemInitHash("Main memory rel HT",
+ MMNRELATIONS, MMNRELATIONS,
+ &info, (HASH_ELEM|HASH_FUNCTION));
+
+ if (MMRelCacheHT == (HTAB *) NULL) {
+ SpinRelease(MMCacheLock);
+ return (SM_FAIL);
+ }
+
+ if (IsPostmaster) {
+ memset(mmcacheblk, 0, mmsize);
+ SpinRelease(MMCacheLock);
+ return (SM_SUCCESS);
+ }
+
+ SpinRelease(MMCacheLock);
+
+ MMCurTop = (int *) mmcacheblk;
+ mmcacheblk += sizeof(int);
+ MMCurRelno = (int *) mmcacheblk;
+ mmcacheblk += sizeof(int);
+ MMBlockTags = (MMCacheTag *) mmcacheblk;
+ mmcacheblk += (MMNBUFFERS * sizeof(MMCacheTag));
+ MMBlockCache = mmcacheblk;
+
+ return (SM_SUCCESS);
+}
+
+int
+mmshutdown()
+{
+ return (SM_SUCCESS);
+}
+
+int
+mmcreate(Relation reln)
+{
+ MMRelHashEntry *entry;
+ bool found;
+ MMRelTag tag;
+
+ SpinAcquire(MMCacheLock);
+
+ if (*MMCurRelno == MMNRELATIONS) {
+ SpinRelease(MMCacheLock);
+ return (SM_FAIL);
+ }
+
+ (*MMCurRelno)++;
+
+ tag.mmrt_relid = reln->rd_id;
+ if (reln->rd_rel->relisshared)
+ tag.mmrt_dbid = (Oid) 0;
+ else
+ tag.mmrt_dbid = MyDatabaseId;
+
+ entry = (MMRelHashEntry *) hash_search(MMRelCacheHT,
+ (char *) &tag, HASH_ENTER, &found);
+
+ if (entry == (MMRelHashEntry *) NULL) {
+ SpinRelease(MMCacheLock);
+ elog(FATAL, "main memory storage mgr rel cache hash table corrupt");
+ }
+
+ if (found) {
+ /* already exists */
+ SpinRelease(MMCacheLock);
+ return (SM_FAIL);
+ }
+
+ entry->mmrhe_nblocks = 0;
+
+ SpinRelease(MMCacheLock);
+
+ return (SM_SUCCESS);
+}
+
+/*
+ * mmunlink() -- Unlink a relation.
+ */
+int
+mmunlink(Relation reln)
+{
+ int i;
+ Oid reldbid;
+ MMHashEntry *entry;
+ MMRelHashEntry *rentry;
+ bool found;
+ MMRelTag rtag;
+
+ if (reln->rd_rel->relisshared)
+ reldbid = (Oid) 0;
+ else
+ reldbid = MyDatabaseId;
+
+ SpinAcquire(MMCacheLock);
+
+ for (i = 0; i < MMNBUFFERS; i++) {
+ if (MMBlockTags[i].mmct_dbid == reldbid
+ && MMBlockTags[i].mmct_relid == reln->rd_id) {
+ entry = (MMHashEntry *) hash_search(MMCacheHT,
+ (char *) &MMBlockTags[i],
+ HASH_REMOVE, &found);
+ if (entry == (MMHashEntry *) NULL || !found) {
+ SpinRelease(MMCacheLock);
+ elog(FATAL, "mmunlink: cache hash table corrupted");
+ }
+ MMBlockTags[i].mmct_dbid = (Oid) 0;
+ MMBlockTags[i].mmct_relid = (Oid) 0;
+ MMBlockTags[i].mmct_blkno = (BlockNumber) 0;
+ }
+ }
+ rtag.mmrt_dbid = reldbid;
+ rtag.mmrt_relid = reln->rd_id;
+
+ rentry = (MMRelHashEntry *) hash_search(MMRelCacheHT, (char *) &rtag,
+ HASH_REMOVE, &found);
+
+ if (rentry == (MMRelHashEntry *) NULL || !found) {
+ SpinRelease(MMCacheLock);
+ elog(FATAL, "mmunlink: rel cache hash table corrupted");
+ }
+
+ (*MMCurRelno)--;
+
+ SpinRelease(MMCacheLock);
+ return 1;
+}
+
+/*
+ * mmextend() -- Add a block to the specified relation.
+ *
+ * This routine returns SM_FAIL or SM_SUCCESS, with errno set as
+ * appropriate.
+ */
+int
+mmextend(Relation reln, char *buffer)
+{
+ MMRelHashEntry *rentry;
+ MMHashEntry *entry;
+ int i;
+ Oid reldbid;
+ int offset;
+ bool found;
+ MMRelTag rtag;
+ MMCacheTag tag;
+
+ if (reln->rd_rel->relisshared)
+ reldbid = (Oid) 0;
+ else
+ reldbid = MyDatabaseId;
+
+ tag.mmct_dbid = rtag.mmrt_dbid = reldbid;
+ tag.mmct_relid = rtag.mmrt_relid = reln->rd_id;
+
+ SpinAcquire(MMCacheLock);
+
+ if (*MMCurTop == MMNBUFFERS) {
+ for (i = 0; i < MMNBUFFERS; i++) {
+ if (MMBlockTags[i].mmct_dbid == 0 &&
+ MMBlockTags[i].mmct_relid == 0)
+ break;
+ }
+ if (i == MMNBUFFERS) {
+ SpinRelease(MMCacheLock);
+ return (SM_FAIL);
+ }
+ } else {
+ i = *MMCurTop;
+ (*MMCurTop)++;
+ }
+
+ rentry = (MMRelHashEntry *) hash_search(MMRelCacheHT, (char *) &rtag,
+ HASH_FIND, &found);
+ if (rentry == (MMRelHashEntry *) NULL || !found) {
+ SpinRelease(MMCacheLock);
+ elog(FATAL, "mmextend: rel cache hash table corrupt");
+ }
+
+ tag.mmct_blkno = rentry->mmrhe_nblocks;
+
+ entry = (MMHashEntry *) hash_search(MMCacheHT, (char *) &tag,
+ HASH_ENTER, &found);
+ if (entry == (MMHashEntry *) NULL || found) {
+ SpinRelease(MMCacheLock);
+ elog(FATAL, "mmextend: cache hash table corrupt");
+ }
+
+ entry->mmhe_bufno = i;
+ MMBlockTags[i].mmct_dbid = reldbid;
+ MMBlockTags[i].mmct_relid = reln->rd_id;
+ MMBlockTags[i].mmct_blkno = rentry->mmrhe_nblocks;
+
+ /* page numbers are zero-based, so we increment this at the end */
+ (rentry->mmrhe_nblocks)++;
+
+ /* write the extended page */
+ offset = (i * BLCKSZ);
+ memmove(&(MMBlockCache[offset]), buffer, BLCKSZ);
+
+ SpinRelease(MMCacheLock);
+
+ return (SM_SUCCESS);
+}
+
+/*
+ * mmopen() -- Open the specified relation.
+ */
+int
+mmopen(Relation reln)
+{
+ /* automatically successful */
+ return (0);
+}
+
+/*
+ * mmclose() -- Close the specified relation.
+ *
+ * Returns SM_SUCCESS or SM_FAIL with errno set as appropriate.
+ */
+int
+mmclose(Relation reln)
+{
+ /* automatically successful */
+ return (SM_SUCCESS);
+}
+
+/*
+ * mmread() -- Read the specified block from a relation.
+ *
+ * Returns SM_SUCCESS or SM_FAIL.
+ */
+int
+mmread(Relation reln, BlockNumber blocknum, char *buffer)
+{
+ MMHashEntry *entry;
+ bool found;
+ int offset;
+ MMCacheTag tag;
+
+ if (reln->rd_rel->relisshared)
+ tag.mmct_dbid = (Oid) 0;
+ else
+ tag.mmct_dbid = MyDatabaseId;
+
+ tag.mmct_relid = reln->rd_id;
+ tag.mmct_blkno = blocknum;
+
+ SpinAcquire(MMCacheLock);
+ entry = (MMHashEntry *) hash_search(MMCacheHT, (char *) &tag,
+ HASH_FIND, &found);
+
+ if (entry == (MMHashEntry *) NULL) {
+ SpinRelease(MMCacheLock);
+ elog(FATAL, "mmread: hash table corrupt");
+ }
+
+ if (!found) {
+ /* reading nonexistent pages is defined to fill them with zeroes */
+ SpinRelease(MMCacheLock);
+ memset(buffer, 0, BLCKSZ);
+ return (SM_SUCCESS);
+ }
+
+ offset = (entry->mmhe_bufno * BLCKSZ);
+ memmove(buffer, &MMBlockCache[offset], BLCKSZ);
+
+ SpinRelease(MMCacheLock);
+
+ return (SM_SUCCESS);
+}
+
+/*
+ * mmwrite() -- Write the supplied block at the appropriate location.
+ *
+ * Returns SM_SUCCESS or SM_FAIL.
+ */
+int
+mmwrite(Relation reln, BlockNumber blocknum, char *buffer)
+{
+ MMHashEntry *entry;
+ bool found;
+ int offset;
+ MMCacheTag tag;
+
+ if (reln->rd_rel->relisshared)
+ tag.mmct_dbid = (Oid) 0;
+ else
+ tag.mmct_dbid = MyDatabaseId;
+
+ tag.mmct_relid = reln->rd_id;
+ tag.mmct_blkno = blocknum;
+
+ SpinAcquire(MMCacheLock);
+ entry = (MMHashEntry *) hash_search(MMCacheHT, (char *) &tag,
+ HASH_FIND, &found);
+
+ if (entry == (MMHashEntry *) NULL) {
+ SpinRelease(MMCacheLock);
+ elog(FATAL, "mmread: hash table corrupt");
+ }
+
+ if (!found) {
+ SpinRelease(MMCacheLock);
+ elog(FATAL, "mmwrite: hash table missing requested page");
+ }
+
+ offset = (entry->mmhe_bufno * BLCKSZ);
+ memmove(&MMBlockCache[offset], buffer, BLCKSZ);
+
+ SpinRelease(MMCacheLock);
+
+ return (SM_SUCCESS);
+}
+
+/*
+ * mmflush() -- Synchronously write a block to stable storage.
+ *
+ * For main-memory relations, this is exactly equivalent to mmwrite().
+ */
+int
+mmflush(Relation reln, BlockNumber blocknum, char *buffer)
+{
+ return (mmwrite(reln, blocknum, buffer));
+}
+
+/*
+ * mmblindwrt() -- Write a block to stable storage blind.
+ *
+ * We have to be able to do this using only the name and OID of
+ * the database and relation in which the block belongs.
+ */
+int
+mmblindwrt(char *dbstr,
+ char *relstr,
+ Oid dbid,
+ Oid relid,
+ BlockNumber blkno,
+ char *buffer)
+{
+ return (SM_FAIL);
+}
+
+/*
+ * mmnblocks() -- Get the number of blocks stored in a relation.
+ *
+ * Returns # of blocks or -1 on error.
+ */
+int
+mmnblocks(Relation reln)
+{
+ MMRelTag rtag;
+ MMRelHashEntry *rentry;
+ bool found;
+ int nblocks;
+
+ if (reln->rd_rel->relisshared)
+ rtag.mmrt_dbid = (Oid) 0;
+ else
+ rtag.mmrt_dbid = MyDatabaseId;
+
+ rtag.mmrt_relid = reln->rd_id;
+
+ SpinAcquire(MMCacheLock);
+
+ rentry = (MMRelHashEntry *) hash_search(MMRelCacheHT, (char *) &rtag,
+ HASH_FIND, &found);
+
+ if (rentry == (MMRelHashEntry *) NULL) {
+ SpinRelease(MMCacheLock);
+ elog(FATAL, "mmnblocks: rel cache hash table corrupt");
+ }
+
+ if (found)
+ nblocks = rentry->mmrhe_nblocks;
+ else
+ nblocks = -1;
+
+ SpinRelease(MMCacheLock);
+
+ return (nblocks);
+}
+
+/*
+ * mmcommit() -- Commit a transaction.
+ *
+ * Returns SM_SUCCESS or SM_FAIL with errno set as appropriate.
+ */
+int
+mmcommit()
+{
+ return (SM_SUCCESS);
+}
+
+/*
+ * mmabort() -- Abort a transaction.
+ */
+
+int
+mmabort()
+{
+ return (SM_SUCCESS);
+}
+
+/*
+ * MMShmemSize() -- Declare amount of shared memory we require.
+ *
+ * The shared memory initialization code creates a block of shared
+ * memory exactly big enough to hold all the structures it needs to.
+ * This routine declares how much space the main memory storage
+ * manager will use.
+ */
+int
+MMShmemSize()
+{
+ int size = 0;
+ int nbuckets;
+ int nsegs;
+ int tmp;
+
+ /*
+ * first compute space occupied by the (dbid,relid,blkno) hash table
+ */
+
+ nbuckets = 1 << (int)my_log2((MMNBUFFERS - 1) / DEF_FFACTOR + 1);
+ nsegs = 1 << (int)my_log2((nbuckets - 1) / DEF_SEGSIZE + 1);
+
+ size += MAXALIGN(my_log2(MMNBUFFERS) * sizeof(void *));
+ size += MAXALIGN(sizeof(HHDR));
+ size += nsegs * MAXALIGN(DEF_SEGSIZE * sizeof(SEGMENT));
+ tmp = (int)ceil((double)MMNBUFFERS/BUCKET_ALLOC_INCR);
+ size += tmp * BUCKET_ALLOC_INCR *
+ (MAXALIGN(sizeof(BUCKET_INDEX)) +
+ MAXALIGN(sizeof(MMHashEntry))); /* contains hash key */
+
+ /*
+ * now do the same for the rel hash table
+ */
+
+ size += MAXALIGN(my_log2(MMNRELATIONS) * sizeof(void *));
+ size += MAXALIGN(sizeof(HHDR));
+ size += nsegs * MAXALIGN(DEF_SEGSIZE * sizeof(SEGMENT));
+ tmp = (int)ceil((double)MMNRELATIONS/BUCKET_ALLOC_INCR);
+ size += tmp * BUCKET_ALLOC_INCR *
+ (MAXALIGN(sizeof(BUCKET_INDEX)) +
+ MAXALIGN(sizeof(MMRelHashEntry))); /* contains hash key */
+
+ /*
+ * finally, add in the memory block we use directly
+ */
+
+ size += MAXALIGN(BLCKSZ * MMNBUFFERS);
+ size += MAXALIGN(sizeof(*MMCurTop));
+ size += MAXALIGN(sizeof(*MMCurRelno));
+ size += MAXALIGN(MMNBUFFERS * sizeof(MMCacheTag));
+
+ return (size);
+}
+
+#endif /* MAIN_MEMORY */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * smgr.c--
+ * public interface routines to storage manager switch.
+ *
+ * All file system operations in POSTGRES dispatch through these
+ * routines.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgr.c,v 1.1.1.1 1996/07/09 06:21:59 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "postgres.h"
+
+#include "machine.h"
+#include "storage/ipc.h"
+#include "storage/smgr.h"
+#include "storage/block.h"
+#include "utils/rel.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+typedef struct f_smgr {
+ int (*smgr_init)(); /* may be NULL */
+ int (*smgr_shutdown)(); /* may be NULL */
+ int (*smgr_create)();
+ int (*smgr_unlink)();
+ int (*smgr_extend)();
+ int (*smgr_open)();
+ int (*smgr_close)();
+ int (*smgr_read)();
+ int (*smgr_write)();
+ int (*smgr_flush)();
+ int (*smgr_blindwrt)();
+ int (*smgr_nblocks)();
+ int (*smgr_commit)(); /* may be NULL */
+ int (*smgr_abort)(); /* may be NULL */
+} f_smgr;
+
+/*
+ * The weird placement of commas in this init block is to keep the compiler
+ * happy, regardless of what storage managers we have (or don't have).
+ */
+
+static f_smgr smgrsw[] = {
+
+ /* magnetic disk */
+ { mdinit, NULL, mdcreate, mdunlink, mdextend, mdopen, mdclose,
+ mdread, mdwrite, mdflush, mdblindwrt, mdnblocks, mdcommit, mdabort },
+
+#ifdef MAIN_MEMORY
+ /* main memory */
+ { mminit, mmshutdown, mmcreate, mmunlink, mmextend, mmopen, mmclose,
+ mmread, mmwrite, mmflush, mmblindwrt, mmnblocks, mmcommit, mmabort },
+
+#endif /* MAIN_MEMORY */
+};
+
+/*
+ * This array records which storage managers are write-once, and which
+ * support overwrite. A 'true' entry means that the storage manager is
+ * write-once. In the best of all possible worlds, there would be no
+ * write-once storage managers.
+ */
+
+static bool smgrwo[] = {
+ false, /* magnetic disk */
+#ifdef MAIN_MEMORY
+ false, /* main memory*/
+#endif /* MAIN_MEMORY */
+};
+static int NSmgr = lengthof(smgrsw);
+
+/*
+ * smgrinit(), smgrshutdown() -- Initialize or shut down all storage
+ * managers.
+ *
+ */
+int
+smgrinit()
+{
+ int i;
+ extern char *smgrout();
+
+ for (i = 0; i < NSmgr; i++) {
+ if (smgrsw[i].smgr_init) {
+ if ((*(smgrsw[i].smgr_init))() == SM_FAIL)
+ elog(FATAL, "initialization failed on %s", smgrout(i));
+ }
+ }
+
+ /* register the shutdown proc */
+ on_exitpg(smgrshutdown, 0);
+
+ return (SM_SUCCESS);
+}
+
+void
+smgrshutdown(int dummy)
+{
+ int i;
+ extern char *smgrout();
+
+ for (i = 0; i < NSmgr; i++) {
+ if (smgrsw[i].smgr_shutdown) {
+ if ((*(smgrsw[i].smgr_shutdown))() == SM_FAIL)
+ elog(FATAL, "shutdown failed on %s", smgrout(i));
+ }
+ }
+}
+
+/*
+ * smgrcreate() -- Create a new relation.
+ *
+ * This routine takes a reldesc, creates the relation on the appropriate
+ * device, and returns a file descriptor for it.
+ */
+int
+smgrcreate(int16 which, Relation reln)
+{
+ int fd;
+
+ if ((fd = (*(smgrsw[which].smgr_create))(reln)) < 0)
+ elog(WARN, "cannot open %.*s",
+ NAMEDATALEN, &(reln->rd_rel->relname.data[0]));
+
+ return (fd);
+}
+
+/*
+ * smgrunlink() -- Unlink a relation.
+ *
+ * The relation is removed from the store.
+ */
+int
+smgrunlink(int16 which, Relation reln)
+{
+ int status;
+
+ if ((status = (*(smgrsw[which].smgr_unlink))(reln)) == SM_FAIL)
+ elog(WARN, "cannot unlink %.*s",
+ NAMEDATALEN, &(reln->rd_rel->relname.data[0]));
+
+ return (status);
+}
+
+/*
+ * smgrextend() -- Add a new block to a file.
+ *
+ * Returns SM_SUCCESS on success; aborts the current transaction on
+ * failure.
+ */
+int
+smgrextend(int16 which, Relation reln, char *buffer)
+{
+ int status;
+
+ status = (*(smgrsw[which].smgr_extend))(reln, buffer);
+
+ if (status == SM_FAIL)
+ elog(WARN, "%.*s: cannot extend",
+ NAMEDATALEN, &(reln->rd_rel->relname.data[0]));
+
+ return (status);
+}
+
+/*
+ * smgropen() -- Open a relation using a particular storage manager.
+ *
+ * Returns the fd for the open relation on success, aborts the
+ * transaction on failure.
+ */
+int
+smgropen(int16 which, Relation reln)
+{
+ int fd;
+
+ if ((fd = (*(smgrsw[which].smgr_open))(reln)) < 0)
+ elog(WARN, "cannot open %.*s",
+ NAMEDATALEN, &(reln->rd_rel->relname.data[0]));
+
+ return (fd);
+}
+
+/*
+ * smgrclose() -- Close a relation.
+ *
+ * Returns SM_SUCCESS on success, aborts on failure.
+ */
+int
+smgrclose(int16 which, Relation reln)
+{
+ if ((*(smgrsw[which].smgr_close))(reln) == SM_FAIL)
+ elog(WARN, "cannot close %.*s",
+ NAMEDATALEN, &(reln->rd_rel->relname.data[0]));
+
+ return (SM_SUCCESS);
+}
+
+/*
+ * smgrread() -- read a particular block from a relation into the supplied
+ * buffer.
+ *
+ * This routine is called from the buffer manager in order to
+ * instantiate pages in the shared buffer cache. All storage managers
+ * return pages in the format that POSTGRES expects. This routine
+ * dispatches the read. On success, it returns SM_SUCCESS. On failure,
+ * the current transaction is aborted.
+ */
+int
+smgrread(int16 which, Relation reln, BlockNumber blocknum, char *buffer)
+{
+ int status;
+
+ status = (*(smgrsw[which].smgr_read))(reln, blocknum, buffer);
+
+ if (status == SM_FAIL)
+ elog(WARN, "cannot read block %d of %.*s",
+ blocknum, NAMEDATALEN, &(reln->rd_rel->relname.data[0]));
+
+ return (status);
+}
+
+/*
+ * smgrwrite() -- Write the supplied buffer out.
+ *
+ * This is not a synchronous write -- the interface for that is
+ * smgrflush(). The buffer is written out via the appropriate
+ * storage manager. This routine returns SM_SUCCESS or aborts
+ * the current transaction.
+ */
+int
+smgrwrite(int16 which, Relation reln, BlockNumber blocknum, char *buffer)
+{
+ int status;
+
+ status = (*(smgrsw[which].smgr_write))(reln, blocknum, buffer);
+
+ if (status == SM_FAIL)
+ elog(WARN, "cannot write block %d of %.*s",
+ blocknum, NAMEDATALEN, &(reln->rd_rel->relname.data[0]));
+
+ return (status);
+}
+
+/*
+ * smgrflush() -- A synchronous smgrwrite().
+ */
+int
+smgrflush(int16 which, Relation reln, BlockNumber blocknum, char *buffer)
+{
+ int status;
+
+ status = (*(smgrsw[which].smgr_flush))(reln, blocknum, buffer);
+
+ if (status == SM_FAIL)
+ elog(WARN, "cannot flush block %d of %.*s to stable store",
+ blocknum, NAMEDATALEN, &(reln->rd_rel->relname.data[0]));
+
+ return (status);
+}
+
+/*
+ * smgrblindwrt() -- Write a page out blind.
+ *
+ * In some cases, we may find a page in the buffer cache that we
+ * can't make a reldesc for. This happens, for example, when we
+ * want to reuse a dirty page that was written by a transaction
+ * that has not yet committed, which created a new relation. In
+ * this case, the buffer manager will call smgrblindwrt() with
+ * the name and OID of the database and the relation to which the
+ * buffer belongs. Every storage manager must be able to force
+ * this page down to stable storage in this circumstance.
+ */
+int
+smgrblindwrt(int16 which,
+ char *dbname,
+ char *relname,
+ Oid dbid,
+ Oid relid,
+ BlockNumber blkno,
+ char *buffer)
+{
+ char *dbstr;
+ char *relstr;
+ int status;
+
+ dbstr = pstrdup(dbname);
+ relstr = pstrdup(relname);
+
+ status = (*(smgrsw[which].smgr_blindwrt))(dbstr, relstr, dbid, relid,
+ blkno, buffer);
+
+ if (status == SM_FAIL)
+ elog(WARN, "cannot write block %d of %s [%s] blind",
+ blkno, relstr, dbstr);
+
+ pfree(dbstr);
+ pfree(relstr);
+
+ return (status);
+}
+
+/*
+ * smgrnblocks() -- Calculate the number of POSTGRES blocks in the
+ * supplied relation.
+ *
+ * Returns the number of blocks on success, aborts the current
+ * transaction on failure.
+ */
+int
+smgrnblocks(int16 which, Relation reln)
+{
+ int nblocks;
+
+ if ((nblocks = (*(smgrsw[which].smgr_nblocks))(reln)) < 0)
+ elog(WARN, "cannot count blocks for %.*s",
+ NAMEDATALEN, &(reln->rd_rel->relname.data[0]));
+
+ return (nblocks);
+}
+
+/*
+ * smgrcommit(), smgrabort() -- Commit or abort changes made during the
+ * current transaction.
+ */
+int
+smgrcommit()
+{
+ int i;
+ extern char *smgrout();
+
+ for (i = 0; i < NSmgr; i++) {
+ if (smgrsw[i].smgr_commit) {
+ if ((*(smgrsw[i].smgr_commit))() == SM_FAIL)
+ elog(FATAL, "transaction commit failed on %s", smgrout(i));
+ }
+ }
+
+ return (SM_SUCCESS);
+}
+
+int
+smgrabort()
+{
+ int i;
+ extern char *smgrout();
+
+ for (i = 0; i < NSmgr; i++) {
+ if (smgrsw[i].smgr_abort) {
+ if ((*(smgrsw[i].smgr_abort))() == SM_FAIL)
+ elog(FATAL, "transaction abort failed on %s", smgrout(i));
+ }
+ }
+
+ return (SM_SUCCESS);
+}
+
+bool
+smgriswo(int16 smgrno)
+{
+ if (smgrno < 0 || smgrno >= NSmgr)
+ elog(WARN, "illegal storage manager number %d", smgrno);
+
+ return (smgrwo[smgrno]);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * smgrtype.c--
+ * storage manager type
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgrtype.c,v 1.1.1.1 1996/07/09 06:21:59 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "postgres.h"
+
+#include "utils/builtins.h" /* where the declarations go */
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "storage/smgr.h"
+
+typedef struct smgrid {
+ char *smgr_name;
+} smgrid;
+
+/*
+ * StorageManager[] -- List of defined storage managers.
+ *
+ * The weird comma placement is to keep compilers happy no matter
+ * which of these is (or is not) defined.
+ */
+
+static smgrid StorageManager[] = {
+ {"magnetic disk"},
+#ifdef MAIN_MEMORY
+ {"main memory"}
+#endif /* MAIN_MEMORY */
+};
+
+static int NStorageManagers = lengthof(StorageManager);
+
+int2
+smgrin(char *s)
+{
+ int i;
+
+ for (i = 0; i < NStorageManagers; i++) {
+ if (strcmp(s, StorageManager[i].smgr_name) == 0)
+ return((int2) i);
+ }
+ elog(WARN, "smgrin: illegal storage manager name %s", s);
+ return 0;
+}
+
+char *
+smgrout(int2 i)
+{
+ char *s;
+
+ if (i >= NStorageManagers || i < 0)
+ elog(WARN, "Illegal storage manager id %d", i);
+
+ s = (char *) palloc(strlen(StorageManager[i].smgr_name) + 1);
+ strcpy(s, StorageManager[i].smgr_name);
+ return (s);
+}
+
+bool
+smgreq(int2 a, int2 b)
+{
+ if (a == b)
+ return (true);
+ return (false);
+}
+
+bool
+smgrne(int2 a, int2 b)
+{
+ if (a == b)
+ return (false);
+ return (true);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * spin.h--
+ * synchronization routines
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: spin.h,v 1.1.1.1 1996/07/09 06:21:53 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef SPIN_H
+#define SPIN_H
+
+#include "ipc.h"
+
+/*
+ * two implementations of spin locks
+ *
+ * sequent, sparc, sun3: real spin locks. uses a TAS instruction; see
+ * src/storage/ipc/s_lock.c for details.
+ *
+ * default: fake spin locks using semaphores. see spin.c
+ *
+ */
+
+typedef int SPINLOCK;
+
+extern bool CreateSpinlocks(IPCKey key);
+extern bool AttachSpinLocks(IPCKey key);
+extern bool InitSpinLocks(int init, IPCKey key);
+
+extern void SpinAcquire(SPINLOCK lock);
+extern void SpinRelease(SPINLOCK lock);
+extern bool SpinIsLocked(SPINLOCK lock);
+
+#endif /* SPIN_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for the traffic cop module
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/tcop/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:21:59 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+VPATH:= $(VPATH):$(CURDIR)/tcop
+
+SRCS_TCOP= aclchk.c dest.c fastpath.c postgres.c pquery.c utility.c
+
+HEADERS+= dest.h fastpath.h pquery.h tcopdebug.h tcopprot.h utility.h
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * aclchk.c--
+ * Routines to check access control permissions.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/tcop/Attic/aclchk.c,v 1.1.1.1 1996/07/09 06:21:59 scrappy Exp $
+ *
+ * NOTES
+ * See acl.h.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "utils/acl.h" /* where declarations for this file goes */
+#include "access/heapam.h"
+#include "access/htup.h"
+#include "access/tupmacs.h"
+#include "utils/builtins.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "catalog/indexing.h"
+#include "catalog/catalog.h"
+#include "catalog/catname.h"
+#include "catalog/pg_group.h"
+#include "catalog/pg_user.h"
+#include "utils/syscache.h"
+#include "parser/catalog_utils.h"
+#include "fmgr.h"
+
+/*
+ * Enable use of user relations in place of real system catalogs.
+ */
+/*#define ACLDEBUG*/
+
+#ifdef ACLDEBUG
+/*
+ * Fool the code below into thinking that "pgacls" is pg_class.
+ * relname and relowner are in the same place, happily.
+ */
+#undef Anum_pg_class_relacl
+#define Anum_pg_class_relacl 3
+#undef Natts_pg_class
+#define Natts_pg_class 3
+#undef Name_pg_class
+#define Name_pg_class "pgacls"
+#undef Name_pg_group
+#define Name_pg_group "pggroup"
+#endif
+
+#ifdef ACLDEBUG_TRACE
+static
+dumpacl(Acl *acl)
+{
+ register unsigned i;
+ AclItem *aip;
+
+ elog(DEBUG, "acl size = %d, # acls = %d",
+ ACL_SIZE(acl), ACL_NUM(acl));
+ aip = (AclItem *) ACL_DAT(acl);
+ for (i = 0; i < ACL_NUM(acl); ++i)
+ elog(DEBUG, " acl[%d]: %s", i, aclitemout(aip + i));
+}
+#endif
+
+/*
+ *
+ */
+void
+ChangeAcl(char *relname,
+ AclItem *mod_aip,
+ unsigned modechg)
+{
+ register unsigned i;
+ Acl *old_acl = (Acl *) NULL, *new_acl;
+ Relation relation;
+ static ScanKeyData relkey[1] = {
+ { 0, Anum_pg_class_relname, NameEqualRegProcedure }
+ };
+ HeapScanDesc hsdp;
+ HeapTuple htp;
+ Buffer buffer;
+ Datum values[Natts_pg_class];
+ char nulls[Natts_pg_class];
+ char replaces[Natts_pg_class];
+ ItemPointerData tmp_ipd;
+ Relation idescs[Num_pg_class_indices];
+ int free_old_acl = 0;
+
+ /*
+ * Find the pg_class tuple matching 'relname' and extract the ACL.
+ * If there's no ACL, create a default using the pg_class.relowner
+ * field.
+ *
+ * We can't use the syscache here, since we need to do a heap_replace
+ * on the tuple we find. Feh.
+ */
+ relation = heap_openr(RelationRelationName);
+ if (!RelationIsValid(relation))
+ elog(WARN, "ChangeAcl: could not open '%s'??",
+ RelationRelationName);
+ fmgr_info(NameEqualRegProcedure, &relkey[0].sk_func, &relkey[0].sk_nargs);
+ relkey[0].sk_argument = NameGetDatum(relname);
+ hsdp = heap_beginscan(relation,
+ 0,
+ NowTimeQual,
+ (unsigned) 1,
+ relkey);
+ htp = heap_getnext(hsdp, 0, &buffer);
+ if (!HeapTupleIsValid(htp)) {
+ heap_endscan(hsdp);
+ heap_close(relation);
+ elog(WARN, "ChangeAcl: class \"%s\" not found",
+ relname);
+ return;
+ }
+ if (!heap_attisnull(htp, Anum_pg_class_relacl))
+ old_acl = (Acl *) heap_getattr(htp, buffer,
+ Anum_pg_class_relacl,
+ RelationGetTupleDescriptor(relation),
+ (bool *) NULL);
+ if (!old_acl || ACL_NUM(old_acl) < 1) {
+#ifdef ACLDEBUG_TRACE
+ elog(DEBUG, "ChangeAcl: using default ACL");
+#endif
+/* old_acl = acldefault(((Form_pg_class) GETSTRUCT(htp))->relowner); */
+ old_acl = acldefault();
+ free_old_acl = 1;
+ }
+
+#ifdef ACLDEBUG_TRACE
+ dumpacl(old_acl);
+#endif
+ new_acl = aclinsert3(old_acl, mod_aip, modechg);
+#ifdef ACLDEBUG_TRACE
+ dumpacl(new_acl);
+#endif
+
+ for (i = 0; i < Natts_pg_class; ++i) {
+ replaces[i] = ' ';
+ nulls[i] = ' '; /* ignored if replaces[i] == ' ' anyway */
+ values[i] = (Datum)NULL;/* ignored if replaces[i] == ' ' anyway */
+ }
+ replaces[Anum_pg_class_relacl - 1] = 'r';
+ values[Anum_pg_class_relacl - 1] = (Datum)new_acl;
+ htp = heap_modifytuple(htp, buffer, relation, values, nulls, replaces);
+ /* XXX is this necessary? */
+ ItemPointerCopy(&htp->t_ctid, &tmp_ipd);
+ /* XXX handle index on pg_class? */
+ setheapoverride(true);
+ (void) heap_replace(relation, &tmp_ipd, htp);
+ setheapoverride(false);
+ heap_endscan(hsdp);
+
+ /* keep the catalog indices up to date */
+ CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices,
+ idescs);
+ CatalogIndexInsert(idescs, Num_pg_class_indices, relation, htp);
+ CatalogCloseIndices(Num_pg_class_indices, idescs);
+
+ heap_close(relation);
+ if (free_old_acl)
+ pfree(old_acl);
+ pfree(new_acl);
+}
+
+AclId
+get_grosysid(char *groname)
+{
+ HeapTuple htp;
+ AclId id = 0;
+
+ htp = SearchSysCacheTuple(GRONAME, PointerGetDatum(groname),
+ 0,0,0);
+ if (HeapTupleIsValid(htp)) {
+ id = ((Form_pg_group) GETSTRUCT(htp))->grosysid;
+ } else {
+ elog(WARN, "non-existent group \"%s\"", groname);
+ }
+ return(id);
+}
+
+char*
+get_groname(AclId grosysid)
+{
+ HeapTuple htp;
+ char *name;
+
+ htp = SearchSysCacheTuple(GROSYSID, PointerGetDatum(grosysid),
+ 0,0,0);
+ if (HeapTupleIsValid(htp)) {
+ name = (((Form_pg_group) GETSTRUCT(htp))->groname).data;
+ } else {
+ elog(NOTICE, "get_groname: group %d not found", grosysid);
+ }
+ return(name);
+}
+
+static int32
+in_group(AclId uid, AclId gid)
+{
+ Relation relation;
+ HeapTuple htp;
+ Acl *tmp;
+ unsigned i, num;
+ AclId *aidp;
+ int32 found = 0;
+
+ relation = heap_openr(GroupRelationName);
+ if (!RelationIsValid(relation)) {
+ elog(NOTICE, "in_group: could not open \"%s\"??",
+ GroupRelationName);
+ return(0);
+ }
+ htp = SearchSysCacheTuple(GROSYSID, ObjectIdGetDatum(gid),
+ 0,0,0);
+ if (HeapTupleIsValid(htp) &&
+ !heap_attisnull(htp, Anum_pg_group_grolist)) {
+ tmp = (IdList *) heap_getattr(htp, InvalidBuffer,
+ Anum_pg_group_grolist,
+ RelationGetTupleDescriptor(relation),
+ (bool *) NULL);
+ /* XXX make me a function */
+ num = IDLIST_NUM(tmp);
+ aidp = IDLIST_DAT(tmp);
+ for (i = 0; i < num; ++i)
+ if (aidp[i] == uid) {
+ found = 1;
+ break;
+ }
+ } else {
+ elog(NOTICE, "in_group: group %d not found", gid);
+ }
+ heap_close(relation);
+ return(found);
+}
+
+/*
+ * aclcheck
+ * Returns 1 if the 'id' of type 'idtype' has ACL entries in 'acl' to satisfy
+ * any one of the requirements of 'mode'. Returns 0 otherwise.
+ */
+int32
+aclcheck(Acl *acl, AclId id, AclIdType idtype, AclMode mode)
+{
+ register unsigned i;
+ register AclItem *aip, *aidat;
+ unsigned num, found_group;
+
+ /* if no acl is found, use world default */
+ if (!acl) {
+ acl = acldefault();
+ }
+
+ num = ACL_NUM(acl);
+ aidat = ACL_DAT(acl);
+
+ /*
+ * We'll treat the empty ACL like that, too, although this is more
+ * like an error (i.e., you manually blew away your ACL array) --
+ * the system never creates an empty ACL.
+ */
+ if (num < 1) {
+#ifdef ACLDEBUG_TRACE
+ elog(DEBUG, "aclcheck: zero-length ACL, returning 1");
+#endif
+ return(1);
+ }
+
+ switch (idtype) {
+ case ACL_IDTYPE_UID:
+ for (i = 1, aip = aidat + 1; /* skip world entry */
+ i < num && aip->ai_idtype == ACL_IDTYPE_UID;
+ ++i, ++aip) {
+ if (aip->ai_id == id) {
+#ifdef ACLDEBUG_TRACE
+ elog(DEBUG, "aclcheck: found %d/%d",
+ aip->ai_id, aip->ai_mode);
+#endif
+ return((aip->ai_mode & mode) ? 1 : 0);
+ }
+ }
+ for (found_group = 0;
+ i < num && aip->ai_idtype == ACL_IDTYPE_GID;
+ ++i, ++aip) {
+ if (in_group(id, aip->ai_id)) {
+ if (aip->ai_mode & mode)
+ ++found_group;
+ else {
+#ifdef ACLDEBUG_TRACE
+ elog(DEBUG, "aclcheck: found %d/%d",
+ aip->ai_id, aip->ai_mode);
+#endif
+ return(0);
+ }
+ }
+ }
+ if (found_group) {
+#ifdef ACLDEBUG_TRACE
+ elog(DEBUG,"aclcheck: all groups ok");
+#endif
+ return(1);
+ }
+ break;
+ case ACL_IDTYPE_GID:
+ for (i = 1, aip = aidat + 1; /* skip world entry and UIDs */
+ i < num && aip->ai_idtype == ACL_IDTYPE_UID;
+ ++i, ++aip)
+ ;
+ for (;
+ i < num && aip->ai_idtype == ACL_IDTYPE_GID;
+ ++i, ++aip) {
+ if (aip->ai_id == id) {
+#ifdef ACLDEBUG_TRACE
+ elog(DEBUG, "aclcheck: found %d/%d",
+ aip->ai_id, aip->ai_mode);
+#endif
+ return((aip->ai_mode & mode) ? 1 : 0);
+ }
+ }
+ break;
+ case ACL_IDTYPE_WORLD:
+ break;
+ default:
+ elog(WARN, "aclcheck: bogus ACL id type: %d", idtype);
+ break;
+ }
+
+#ifdef ACLDEBUG_TRACE
+ elog(DEBUG, "aclcheck: using world=%d", aidat->ai_mode);
+#endif
+ return((aidat->ai_mode & mode) ? 1 : 0);
+}
+
+int32
+pg_aclcheck(char *relname, char *usename, AclMode mode)
+{
+ HeapTuple htp;
+ AclId id;
+ Acl *acl = (Acl *) NULL, *tmp;
+ int32 result;
+ Relation relation;
+
+ htp = SearchSysCacheTuple(USENAME, PointerGetDatum(usename),
+ 0,0,0);
+ if (!HeapTupleIsValid(htp))
+ elog(WARN, "pg_aclcheck: user \"%-.*s\" not found",
+ NAMEDATALEN, usename);
+ id = (AclId) ((Form_pg_user) GETSTRUCT(htp))->usesysid;
+
+ /* for the 'pg_database' relation, check the usecreatedb
+ field before checking normal permissions */
+ if ( strcmp(DatabaseRelationName, relname) == 0 &&
+ (((Form_pg_user) GETSTRUCT(htp))->usecreatedb)) {
+ /* note that even though the user can now append to the
+ pg_database table, there is still additional permissions checking
+ in dbcommands.c */
+ if (mode & ACL_AP)
+ return (1);
+ }
+
+ /*
+ * Deny anyone permission to update a system catalog unless
+ * pg_user.usecatupd is set. (This is to let superusers protect
+ * themselves from themselves.)
+ */
+ if (((mode & ACL_WR) || (mode & ACL_AP)) &&
+ IsSystemRelationName(relname) &&
+ !((Form_pg_user) GETSTRUCT(htp))->usecatupd) {
+ elog(DEBUG, "pg_aclcheck: catalog update to \"%-.*s\": permission denied",
+ NAMEDATALEN, relname);
+ return(0);
+ }
+
+ /*
+ * Otherwise, superusers bypass all permission-checking.
+ */
+ if (((Form_pg_user) GETSTRUCT(htp))->usesuper) {
+#ifdef ACLDEBUG_TRACE
+ elog(DEBUG, "pg_aclcheck: \"%-.*s\" is superuser",
+ NAMEDATALEN, usename);
+#endif
+ return(1);
+ }
+
+#ifndef ACLDEBUG
+ htp = SearchSysCacheTuple(RELNAME, PointerGetDatum(relname),
+ 0,0,0);
+ if (!HeapTupleIsValid(htp)) {
+ elog(WARN, "pg_aclcheck: class \"%-.*s\" not found",
+ NAMEDATALEN, relname);
+ return(1);
+ }
+ if (!heap_attisnull(htp, Anum_pg_class_relacl)) {
+ relation = heap_openr(RelationRelationName);
+ tmp = (Acl *) heap_getattr(htp, InvalidBuffer,
+ Anum_pg_class_relacl,
+ RelationGetTupleDescriptor(relation),
+ (bool *) NULL);
+ acl = makeacl(ACL_NUM(tmp));
+ memmove((char *) acl, (char *) tmp, ACL_SIZE(tmp));
+ heap_close(relation);
+ } else {
+ /* if the acl is null, by default the owner can do whatever
+ he wants to with it */
+ Oid ownerId;
+ relation = heap_openr(RelationRelationName);
+ ownerId = (Oid)heap_getattr(htp, InvalidBuffer,
+ Anum_pg_class_relowner,
+ RelationGetTupleDescriptor(relation),
+ (bool*) NULL);
+ acl = aclownerdefault(ownerId);
+ }
+#else
+ { /* This is why the syscache is great... */
+ static ScanKeyData relkey[1] = {
+ { 0, Anum_pg_class_relname, NameEqualRegProcedure }
+ };
+ HeapScanDesc hsdp;
+
+ relation = heap_openr(RelationRelationName);
+ if (!RelationIsValid(relation)) {
+ elog(NOTICE, "pg_checkacl: could not open \"%-.*s\"??",
+ RelationRelationName);
+ return(1);
+ }
+ fmgr_info(NameEqualRegProcedure,
+ &relkey[0].sk_func,
+ &relkey[0].sk_nargs);
+ relkey[0].sk_argument = NameGetDatum(relname);
+ hsdp = heap_beginscan(relation, 0, NowTimeQual, 1, relkey);
+ htp = heap_getnext(hsdp, 0, (Buffer *) 0);
+ if (HeapTupleIsValid(htp) &&
+ !heap_attisnull(htp, Anum_pg_class_relacl)) {
+ tmp = (Acl *) heap_getattr(htp, InvalidBuffer,
+ Anum_pg_class_relacl,
+ RelationGetTupleDescriptor(relation),
+ (bool *) NULL);
+ acl = makeacl(ACL_NUM(tmp));
+ memmove((char *) acl, (char *) tmp, ACL_SIZE(tmp));
+ }
+ heap_endscan(hsdp);
+ heap_close(relation);
+ }
+#endif
+ result = aclcheck(acl, id, (AclIdType) ACL_IDTYPE_UID, mode);
+ if (acl)
+ pfree(acl);
+ return(result);
+}
+
+int32
+pg_ownercheck(char *usename,
+ char *value,
+ int cacheid)
+{
+ HeapTuple htp;
+ AclId user_id, owner_id;
+
+ htp = SearchSysCacheTuple(USENAME, PointerGetDatum(usename),
+ 0,0,0);
+ if (!HeapTupleIsValid(htp))
+ elog(WARN, "pg_ownercheck: user \"%-.*s\" not found",
+ NAMEDATALEN, usename);
+ user_id = (AclId) ((Form_pg_user) GETSTRUCT(htp))->usesysid;
+
+ /*
+ * Superusers bypass all permission-checking.
+ */
+ if (((Form_pg_user) GETSTRUCT(htp))->usesuper) {
+#ifdef ACLDEBUG_TRACE
+ elog(DEBUG, "pg_ownercheck: user \"%-.*s\" is superuser",
+ NAMEDATALEN, usename);
+#endif
+ return(1);
+ }
+
+ htp = SearchSysCacheTuple(cacheid, PointerGetDatum(value),
+ 0,0,0);
+ switch (cacheid) {
+ case OPROID:
+ if (!HeapTupleIsValid(htp))
+ elog(WARN, "pg_ownercheck: operator %d not found",
+ (int) value);
+ owner_id = ((OperatorTupleForm) GETSTRUCT(htp))->oprowner;
+ break;
+ case PRONAME:
+ if (!HeapTupleIsValid(htp))
+ elog(WARN, "pg_ownercheck: function \"%-.*s\" not found",
+ NAMEDATALEN, value);
+ owner_id = ((Form_pg_proc) GETSTRUCT(htp))->proowner;
+ break;
+ case RELNAME:
+ if (!HeapTupleIsValid(htp))
+ elog(WARN, "pg_ownercheck: class \"%-.*s\" not found",
+ NAMEDATALEN, value);
+ owner_id = ((Form_pg_class) GETSTRUCT(htp))->relowner;
+ break;
+ case TYPNAME:
+ if (!HeapTupleIsValid(htp))
+ elog(WARN, "pg_ownercheck: type \"%-.*s\" not found",
+ NAMEDATALEN, value);
+ owner_id = ((TypeTupleForm) GETSTRUCT(htp))->typowner;
+ break;
+ default:
+ elog(WARN, "pg_ownercheck: invalid cache id: %d",
+ cacheid);
+ break;
+ }
+
+ return(user_id == owner_id);
+}
+
+int32
+pg_func_ownercheck(char *usename,
+ char *funcname,
+ int nargs,
+ Oid *arglist)
+{
+ HeapTuple htp;
+ AclId user_id, owner_id;
+
+ htp = SearchSysCacheTuple(USENAME, PointerGetDatum(usename),
+ 0,0,0);
+ if (!HeapTupleIsValid(htp))
+ elog(WARN, "pg_func_ownercheck: user \"%-.*s\" not found",
+ NAMEDATALEN, usename);
+ user_id = (AclId) ((Form_pg_user) GETSTRUCT(htp))->usesysid;
+
+ /*
+ * Superusers bypass all permission-checking.
+ */
+ if (((Form_pg_user) GETSTRUCT(htp))->usesuper) {
+#ifdef ACLDEBUG_TRACE
+ elog(DEBUG, "pg_ownercheck: user \"%-.*s\" is superuser",
+ NAMEDATALEN, usename);
+#endif
+ return(1);
+ }
+
+ htp = SearchSysCacheTuple(PRONAME,
+ PointerGetDatum(funcname),
+ PointerGetDatum(nargs),
+ PointerGetDatum(arglist),
+ 0);
+ if (!HeapTupleIsValid(htp))
+ func_error("pg_func_ownercheck", funcname, nargs, (int*)arglist);
+
+ owner_id = ((Form_pg_proc) GETSTRUCT(htp))->proowner;
+
+ return(user_id == owner_id);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * dest.c--
+ * support for various communication destinations - see lib/H/tcop/dest.h
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/tcop/dest.c,v 1.1.1.1 1996/07/09 06:21:59 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ * INTERFACE ROUTINES
+ * BeginCommand - prepare destination for tuples of the given type
+ * EndCommand - tell destination that no more tuples will arrive
+ * NullCommand - tell dest that the last of a query sequence was processed
+ *
+ * NOTES
+ * These routines do the appropriate work before and after
+ * tuples are returned by a query to keep the backend and the
+ * "destination" portals synchronized.
+ *
+ */
+#include /* for sprintf() */
+#include "postgres.h"
+
+#include "access/htup.h"
+#include "libpq/libpq-be.h"
+#include "access/printtup.h"
+#include "utils/portal.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+#include "executor/executor.h"
+
+#include "tcop/dest.h"
+
+#include "catalog/pg_type.h"
+#include "utils/mcxt.h"
+
+#include "commands/async.h"
+
+/* ----------------
+ * output functions
+ * ----------------
+ */
+void
+donothing(List *tuple, List *attrdesc)
+{
+}
+
+void (*DestToFunction(CommandDest dest))()
+{
+ switch (dest) {
+ case RemoteInternal:
+ return printtup_internal;
+ break;
+
+ case Remote:
+ return printtup;
+ break;
+
+ case Local:
+ return be_printtup;
+ break;
+
+ case Debug:
+ return debugtup;
+ break;
+
+ case None:
+ default:
+ return donothing;
+ break;
+ }
+
+ /*
+ * never gets here, but DECstation lint appears to be stupid...
+ */
+
+ return donothing;
+}
+
+#define IS_INSERT_TAG(tag) (*tag == 'I' && *(tag+1) == 'N')
+
+/* ----------------
+ * EndCommand - tell destination that no more tuples will arrive
+ * ----------------
+ */
+void
+EndCommand(char *commandTag, CommandDest dest)
+{
+ char buf[64];
+
+ switch (dest) {
+ case RemoteInternal:
+ case Remote:
+ /* ----------------
+ * tell the fe that the query is over
+ * ----------------
+ */
+ pq_putnchar("C", 1);
+/* pq_putint(0, 4); */
+ if (IS_INSERT_TAG(commandTag))
+ {
+ sprintf(buf, "%s %d", commandTag, GetAppendOid());
+ pq_putstr(buf);
+ }
+ else
+ pq_putstr(commandTag);
+ pq_flush();
+ break;
+
+ case Local:
+ case Debug:
+ break;
+ case CopyEnd:
+ pq_putnchar("Z", 1);
+ pq_flush();
+ break;
+ case None:
+ default:
+ break;
+ }
+}
+
+/*
+ * These are necessary to sync communications between fe/be processes doing
+ * COPY rel TO stdout
+ *
+ * or
+ *
+ * COPY rel FROM stdin
+ *
+ */
+void
+SendCopyBegin()
+{
+ pq_putnchar("B", 1);
+/* pq_putint(0, 4); */
+ pq_flush();
+}
+
+void
+ReceiveCopyBegin()
+{
+ pq_putnchar("D", 1);
+/* pq_putint(0, 4); */
+ pq_flush();
+}
+
+/* ----------------
+ * NullCommand - tell dest that the last of a query sequence was processed
+ *
+ * Necessary to implement the hacky FE/BE interface to handle
+ * multiple-return queries.
+ * ----------------
+ */
+void
+NullCommand(CommandDest dest)
+{
+ switch (dest) {
+ case RemoteInternal:
+ case Remote: {
+#if 0
+ /* Do any asynchronous notification. If front end wants to poll,
+ it can send null queries to call this function.
+ */
+ PQNotifyList *nPtr;
+ MemoryContext orig;
+
+ if (notifyContext == NULL) {
+ notifyContext = CreateGlobalMemory("notify");
+ }
+ orig = MemoryContextSwitchTo((MemoryContext)notifyContext);
+
+ for (nPtr = PQnotifies() ;
+ nPtr != NULL;
+ nPtr = (PQNotifyList *)SLGetSucc(&nPtr->Node)) {
+ pq_putnchar("A",1);
+ pq_putint(0, 4);
+ pq_putstr(nPtr->relname);
+ pq_putint(nPtr->be_pid,4);
+ PQremoveNotify(nPtr);
+ }
+ pq_flush();
+ PQcleanNotify(); /* garbage collect */
+ (void) MemoryContextSwitchTo(orig);
+#endif
+ /* ----------------
+ * tell the fe that the last of the queries has finished
+ * ----------------
+ */
+/* pq_putnchar("I", 1); */
+ pq_putstr("I");
+ /* pq_putint(0, 4);*/
+ pq_flush();
+ }
+ break;
+
+ case Local:
+ case Debug:
+ case None:
+ default:
+ break;
+ }
+}
+
+/* ----------------
+ * BeginCommand - prepare destination for tuples of the given type
+ * ----------------
+ */
+void
+BeginCommand(char *pname,
+ int operation,
+ TupleDesc tupdesc,
+ bool isIntoRel,
+ bool isIntoPortal,
+ char *tag,
+ CommandDest dest)
+{
+ PortalEntry *entry;
+ AttributeTupleForm *attrs = tupdesc->attrs;
+ int natts = tupdesc->natts;
+ int i;
+ char *p;
+
+ switch (dest) {
+ case RemoteInternal:
+ case Remote:
+ /* ----------------
+ * if this is a "retrieve portal" query, just return
+ * because nothing needs to be sent to the fe.
+ * ----------------
+ */
+ ResetAppendOid();
+ if (isIntoPortal)
+ return;
+
+ /* ----------------
+ * if portal name not specified for remote query,
+ * use the "blank" portal.
+ * ----------------
+ */
+ if (pname == NULL)
+ pname = "blank";
+
+ /* ----------------
+ * send fe info on tuples we're about to send
+ * ----------------
+ */
+ pq_flush();
+ pq_putnchar("P", 1); /* new portal.. */
+ pq_putstr(pname); /* portal name */
+
+ /* ----------------
+ * if this is a retrieve, then we send back the tuple
+ * descriptor of the tuples. "retrieve into" is an
+ * exception because no tuples are returned in that case.
+ * ----------------
+ */
+ if (operation == CMD_SELECT && !isIntoRel) {
+ pq_putnchar("T", 1); /* type info to follow.. */
+ pq_putint(natts, 2); /* number of attributes in tuples */
+
+ for (i = 0; i < natts; ++i) {
+ pq_putstr(attrs[i]->attname.data);/* if 16 char name oops.. */
+ pq_putint((int) attrs[i]->atttypid, 4);
+ pq_putint(attrs[i]->attlen, 2);
+ }
+ }
+ pq_flush();
+ break;
+
+ case Local:
+ /* ----------------
+ * prepare local portal buffer for query results
+ * and setup result for PQexec()
+ * ----------------
+ */
+ entry = be_currentportal();
+ if (pname != NULL)
+ pbuf_setportalinfo(entry, pname);
+
+ if (operation == CMD_SELECT && !isIntoRel) {
+ be_typeinit(entry, tupdesc, natts);
+ p = (char *) palloc(strlen(entry->name)+2);
+ p[0] = 'P';
+ strcpy(p+1,entry->name);
+ } else {
+ p = (char *) palloc(strlen(tag)+2);
+ p[0] = 'C';
+ strcpy(p+1,tag);
+ }
+ entry->result = p;
+ break;
+
+ case Debug:
+ /* ----------------
+ * show the return type of the tuples
+ * ----------------
+ */
+ if (pname == NULL)
+ pname = "blank";
+
+ showatts(pname, tupdesc);
+ break;
+
+ case None:
+ default:
+ break;
+ }
+}
+
+static Oid AppendOid;
+
+void
+ResetAppendOid()
+{
+ AppendOid = InvalidOid;
+}
+
+#define MULTI_TUPLE_APPEND -1
+
+void
+UpdateAppendOid(Oid newoid)
+{
+ /*
+ * First update after AppendOid was reset (at command beginning).
+ */
+ if (AppendOid == InvalidOid)
+ AppendOid = newoid;
+ /*
+ * Already detected a multiple tuple append, return a void oid ;)
+ */
+ else if (AppendOid == MULTI_TUPLE_APPEND)
+ return;
+ /*
+ * Oid has been assigned once before, tag this as a multiple tuple
+ * append.
+ */
+ else
+ AppendOid = MULTI_TUPLE_APPEND;
+}
+
+Oid
+GetAppendOid()
+{
+ if (AppendOid == MULTI_TUPLE_APPEND)
+ return InvalidOid;
+ return AppendOid;
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * dest.h--
+ * Whenever the backend is submitted a query, the results
+ * have to go someplace - either to the standard output,
+ * to a local portal buffer or to a remote portal buffer.
+ *
+ * - stdout is the destination only when we are running a
+ * backend without a postmaster and are returning results
+ * back to the user.
+ *
+ * - a local portal buffer is the destination when a backend
+ * executes a user-defined function which calls PQexec() or
+ * PQfn(). In this case, the results are collected into a
+ * PortalBuffer which the user's function may diddle with.
+ *
+ * - a remote portal buffer is the destination when we are
+ * running a backend with a frontend and the frontend executes
+ * PQexec() or PQfn(). In this case, the results are sent
+ * to the frontend via the pq_ functions.
+ *
+ * - None is the destination when the system executes
+ * a query internally. This is not used now but it may be
+ * useful for the parallel optimiser/executor.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: dest.h,v 1.1.1.1 1996/07/09 06:21:59 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef DEST_H
+#define DEST_H
+
+#include "catalog/pg_attribute.h"
+#include "access/tupdesc.h"
+
+/* ----------------
+ * CommandDest is used to allow the results of calling
+ * pg_eval() to go to the right place.
+ * ----------------
+ */
+typedef enum {
+ None, /* results are discarded */
+ Debug, /* results go to debugging output */
+ Local, /* results go in local portal buffer */
+ Remote, /* results sent to frontend process */
+ CopyBegin, /* results sent to frontend process but are strings */
+ CopyEnd, /* results sent to frontend process but are strings */
+ RemoteInternal /* results sent to frontend process in internal
+ (binary) form */
+} CommandDest;
+
+
+/* AttrInfo* replaced with TupleDesc, now that TupleDesc also has within it
+ the number of attributes
+
+typedef struct AttrInfo {
+ int numAttr;
+ AttributeTupleForm *attrs;
+} AttrInfo;
+*/
+
+extern void donothing(List *tuple, List *attrdesc);
+extern void (*DestToFunction(CommandDest dest))();
+extern void EndCommand(char *commandTag, CommandDest dest);
+extern void SendCopyBegin();
+extern void ReceiveCopyBegin();
+extern void NullCommand(CommandDest dest);
+extern void BeginCommand(char *pname, int operation, TupleDesc attinfo,
+ bool isIntoRel, bool isIntoPortal, char *tag,
+ CommandDest dest);
+extern void ResetAppendOid();
+extern void UpdateAppendOid(Oid newoid);
+extern Oid GetAppendOid();
+
+#endif /* DEST_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * fastpath.c--
+ * routines to handle function requests from the frontend
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/tcop/fastpath.c,v 1.1.1.1 1996/07/09 06:21:59 scrappy Exp $
+ *
+ * NOTES
+ * This cruft is the server side of PQfn.
+ *
+ * - jolly 07/11/95:
+ *
+ * no longer rely on return sizes provided by the frontend. Always
+ * use the true lengths for the catalogs. Assume that the frontend
+ * has allocated enough space to handle the result value returned.
+ *
+ * trust that the user knows what he is doing with the args. If the
+ * sys catalog says it is a varlena, assume that the user is only sending
+ * down VARDATA and that the argsize is the VARSIZE. If the arg is
+ * fixed len, assume that the argsize given by the user is correct.
+ *
+ * if the function returns by value, then only send 4 bytes value
+ * back to the frontend. If the return returns by reference,
+ * send down only the data portion and set the return size appropriately.
+ *
+ * OLD COMMENTS FOLLOW
+ *
+ * The VAR_LENGTH_{ARGS,RESULT} stuff is limited to MAX_STRING_LENGTH
+ * (see src/backend/tmp/fastpath.h) for no obvious reason. Since its
+ * primary use (for us) is for Inversion path names, it should probably
+ * be increased to 256 (MAXPATHLEN for Inversion, hidden in pg_type
+ * as well as utils/adt/filename.c).
+ *
+ * Quoth PMA on 08/15/93:
+ *
+ * This code has been almost completely rewritten with an eye to
+ * keeping it as compatible as possible with the previous (broken)
+ * implementation.
+ *
+ * The previous implementation would assume (1) that any value of
+ * length <= 4 bytes was passed-by-value, and that any other value
+ * was a struct varlena (by-reference). There was NO way to pass a
+ * fixed-length by-reference argument (like char16) or a struct
+ * varlena of size <= 4 bytes.
+ *
+ * The new implementation checks the catalogs to determine whether
+ * a value is by-value (type "0" is null-delimited character string,
+ * as it is for, e.g., the parser). The only other item obtained
+ * from the catalogs is whether or not the value should be placed in
+ * a struct varlena or not. Otherwise, the size given by the
+ * frontend is assumed to be correct (probably a bad decision, but
+ * we do strange things in the name of compatibility).
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "tcop/tcopdebug.h"
+
+#include "utils/palloc.h"
+#include "fmgr.h"
+#include "utils/elog.h"
+#include "utils/builtins.h" /* for oideq */
+#include "tcop/fastpath.h"
+#include "libpq/libpq.h"
+
+#include "access/xact.h" /* for TransactionId/CommandId protos */
+
+#include "utils/syscache.h"
+#include "catalog/pg_proc.h"
+#include "catalog/pg_type.h"
+
+
+/* ----------------
+ * SendFunctionResult
+ * ----------------
+ */
+static void
+SendFunctionResult(Oid fid, /* function id */
+ char *retval, /* actual return value */
+ bool retbyval,
+ int retlen /* the length according to the catalogs */
+ )
+{
+ pq_putnchar("V", 1);
+
+ if (retlen != 0) {
+ pq_putnchar("G", 1);
+ if (retbyval) { /* by-value */
+ pq_putint(retlen, 4);
+ pq_putint((int)retval, retlen);
+ } else { /* by-reference ... */
+ if (retlen < 0) { /* ... varlena */
+ pq_putint(VARSIZE(retval) - VARHDRSZ, 4);
+ pq_putnchar(VARDATA(retval), VARSIZE(retval) - VARHDRSZ);
+ } else { /* ... fixed */
+ pq_putint(retlen, 4);
+ pq_putnchar(retval, retlen);
+ }
+ }
+ }
+
+ pq_putnchar("0", 1);
+ pq_flush();
+}
+
+/*
+ * This structure saves enough state so that one can avoid having to
+ * do catalog lookups over and over again. (Each RPC can require up
+ * to MAXFMGRARGS+2 lookups, which is quite tedious.)
+ *
+ * The previous incarnation of this code just assumed that any argument
+ * of size <= 4 was by value; this is not correct. There is no cheap
+ * way to determine function argument length etc.; one must simply pay
+ * the price of catalog lookups.
+ */
+struct fp_info {
+ Oid funcid;
+ int nargs;
+ bool argbyval[MAXFMGRARGS];
+ int32 arglen[MAXFMGRARGS]; /* signed (for varlena) */
+ bool retbyval;
+ int32 retlen; /* signed (for varlena) */
+ TransactionId xid;
+ CommandId cid;
+};
+
+/*
+ * We implement one-back caching here. If we need to do more, we can.
+ * Most routines in tight loops (like PQfswrite -> F_LOWRITE) will do
+ * the same thing repeatedly.
+ */
+static struct fp_info last_fp = { InvalidOid };
+
+/*
+ * valid_fp_info
+ *
+ * RETURNS:
+ * 1 if the state in 'fip' is valid
+ * 0 otherwise
+ *
+ * "valid" means:
+ * The saved state was either uninitialized, for another function,
+ * or from a previous command. (Commands can do updates, which
+ * may invalidate catalog entries for subsequent commands. This
+ * is overly pessimistic but since there is no smarter invalidation
+ * scheme...).
+ */
+static int
+valid_fp_info(Oid func_id, struct fp_info *fip)
+{
+ Assert(OidIsValid(func_id));
+ Assert(fip != (struct fp_info *) NULL);
+
+ return(OidIsValid(fip->funcid) &&
+ oideq(func_id, fip->funcid) &&
+ TransactionIdIsCurrentTransactionId(fip->xid) &&
+ CommandIdIsCurrentCommandId(fip->cid));
+}
+
+/*
+ * update_fp_info
+ *
+ * Performs catalog lookups to load a struct fp_info 'fip' for the
+ * function 'func_id'.
+ *
+ * RETURNS:
+ * The correct information in 'fip'. Sets 'fip->funcid' to
+ * InvalidOid if an exception occurs.
+ */
+static void
+update_fp_info(Oid func_id, struct fp_info *fip)
+{
+ Oid *argtypes; /* an oid8 */
+ Oid rettype;
+ HeapTuple func_htp, type_htp;
+ TypeTupleForm tp;
+ Form_pg_proc pp;
+ int i;
+
+ Assert(OidIsValid(func_id));
+ Assert(fip != (struct fp_info *) NULL);
+
+ /*
+ * Since the validity of this structure is determined by whether
+ * the funcid is OK, we clear the funcid here. It must not be
+ * set to the correct value until we are about to return with
+ * a good struct fp_info, since we can be interrupted (i.e., with
+ * an elog(WARN, ...)) at any time.
+ */
+ memset((char *) fip, 0, (int) sizeof(struct fp_info));
+ fip->funcid = InvalidOid;
+
+ func_htp = SearchSysCacheTuple(PROOID, ObjectIdGetDatum(func_id),
+ 0,0,0);
+ if (!HeapTupleIsValid(func_htp)) {
+ elog(WARN, "update_fp_info: cache lookup for function %d failed",
+ func_id);
+ }
+ pp = (Form_pg_proc) GETSTRUCT(func_htp);
+ fip->nargs = pp->pronargs;
+ rettype = pp->prorettype;
+ argtypes = pp->proargtypes;
+
+ for (i = 0; i < fip->nargs; ++i) {
+ if (OidIsValid(argtypes[i])) {
+ type_htp = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(argtypes[i]),
+ 0,0,0);
+ if (!HeapTupleIsValid(type_htp)) {
+ elog(WARN, "update_fp_info: bad argument type %d for %d",
+ argtypes[i], func_id);
+ }
+ tp = (TypeTupleForm) GETSTRUCT(type_htp);
+ fip->argbyval[i] = tp->typbyval;
+ fip->arglen[i] = tp->typlen;
+ } /* else it had better be VAR_LENGTH_ARG */
+ }
+
+ if (OidIsValid(rettype)) {
+ type_htp = SearchSysCacheTuple(TYPOID, ObjectIdGetDatum(rettype),
+ 0,0,0);
+ if (!HeapTupleIsValid(type_htp)) {
+ elog(WARN, "update_fp_info: bad return type %d for %d",
+ rettype, func_id);
+ }
+ tp = (TypeTupleForm) GETSTRUCT(type_htp);
+ fip->retbyval = tp->typbyval;
+ fip->retlen = tp->typlen;
+ } /* else it had better by VAR_LENGTH_RESULT */
+
+ fip->xid = GetCurrentTransactionId();
+ fip->cid = GetCurrentCommandId();
+
+ /*
+ * This must be last!
+ */
+ fip->funcid = func_id;
+}
+
+
+/*
+ * HandleFunctionRequest
+ *
+ * Server side of PQfn (fastpath function calls from the frontend).
+ * This corresponds to the libpq protocol symbol "F".
+ *
+ * RETURNS:
+ * nothing of significance.
+ * All errors result in elog(WARN,...).
+ */
+int
+HandleFunctionRequest()
+{
+ Oid fid;
+ int argsize;
+ int nargs;
+ char *arg[8];
+ char *retval;
+ int i;
+ uint32 palloced;
+ char *p;
+ struct fp_info *fip;
+
+ fid = (Oid) pq_getint(4); /* function oid */
+ nargs = pq_getint(4); /* # of arguments */
+
+ /*
+ * This is where the one-back caching is done.
+ * If you want to save more state, make this a loop around an array.
+ */
+ fip = &last_fp;
+ if (!valid_fp_info(fid, fip)) {
+ update_fp_info(fid, fip);
+ }
+
+ if (fip->nargs != nargs) {
+ elog(WARN, "HandleFunctionRequest: actual arguments (%d) != registered arguments (%d)",
+ nargs, fip->nargs);
+ }
+
+ /*
+ * Copy arguments into arg vector. If we palloc() an argument, we need
+ * to remember, so that we pfree() it after the call.
+ */
+ palloced = 0x0;
+ for (i = 0; i < 8; ++i) {
+ if (i >= nargs) {
+ arg[i] = (char *) NULL;
+ } else {
+ argsize = pq_getint(4);
+
+ Assert(argsize > 0);
+ if (fip->argbyval[i]) { /* by-value */
+ Assert(argsize <= 4);
+ arg[i] = (char *) pq_getint(argsize);
+ } else { /* by-reference ... */
+ if (fip->arglen[i] < 0) { /* ... varlena */
+ if (!(p = palloc(argsize + VARHDRSZ))) {
+ elog(WARN, "HandleFunctionRequest: palloc failed");
+ }
+ VARSIZE(p) = argsize + VARHDRSZ;
+ pq_getnchar(VARDATA(p), 0, argsize);
+ } else { /* ... fixed */
+ /* XXX cross our fingers and trust "argsize" */
+ if (!(p = palloc(argsize))) {
+ elog(WARN, "HandleFunctionRequest: palloc failed");
+ }
+ pq_getnchar(p, 0, argsize);
+ }
+ palloced |= (1 << i);
+ arg[i] = p;
+ }
+ }
+ }
+
+#ifndef NO_FASTPATH
+ retval = fmgr(fid,
+ arg[0], arg[1], arg[2], arg[3],
+ arg[4], arg[5], arg[6], arg[7]);
+
+#else
+ retval = NULL;
+#endif /* NO_FASTPATH */
+
+ /* free palloc'ed arguments */
+ for (i = 0; i < nargs; ++i) {
+ if (palloced & (1 << i))
+ pfree(arg[i]);
+ }
+
+ /*
+ * If this is an ordinary query (not a retrieve portal p ...), then
+ * we return the data to the user. If the return value was palloc'ed,
+ * then it must also be freed.
+ */
+#ifndef NO_FASTPATH
+ SendFunctionResult(fid, retval, fip->retbyval, fip->retlen);
+#else
+ SendFunctionResult(fid, retval, fip->retbyval, 0);
+#endif /* NO_FASTPATH */
+
+ if (!fip->retbyval)
+ pfree(retval);
+
+
+
+ return(0);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * fastpath.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: fastpath.h,v 1.1.1.1 1996/07/09 06:21:59 scrappy Exp $
+ *
+ * NOTES
+ * This information pulled out of tcop/fastpath.c and put
+ * here so that the PQfn() in be-pqexec.c could access it.
+ * -cim 2/26/91
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef FASTPATH_H
+#define FASTPATH_H
+
+/* ----------------
+ * fastpath #defines
+ * ----------------
+ */
+#define VAR_LENGTH_RESULT (-1)
+#define VAR_LENGTH_ARG (-5)
+#define MAX_STRING_LENGTH 256
+
+extern int HandleFunctionRequest(void);
+
+#endif /* FASTPATH_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * postgres.c--
+ * POSTGRES C Backend Interface
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.1.1.1 1996/07/09 06:22:00 scrappy Exp $
+ *
+ * NOTES
+ * this is the "main" module of the postgres backend and
+ * hence the main module of the "traffic cop".
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "libpq/pqsignal.h" /* substitute for */
+#if defined(PORTNAME_linux)
+#ifndef __USE_POSIX
+#define __USE_POSIX
+#endif
+#endif /* defined(PORTNAME_linux) */
+#include
+#include
+#include
+#include
+#include
+#include /* for MAXHOSTNAMELEN on most */
+#ifndef WIN32
+#include /* for MAXHOSTNAMELEN on some */
+#endif /* WIN32 */
+#include
+#ifdef PORTNAME_aix
+#include
+#endif /* PORTNAME_aix */
+
+
+#include "postgres.h"
+#include "miscadmin.h"
+#include "catalog/catname.h"
+#include "access/xact.h"
+
+#include "lib/dllist.h"
+
+#include "parser/catalog_utils.h"
+#include "parser/parse_query.h" /* for MakeTimeRange() */
+#include "commands/async.h"
+#include "tcop/tcopprot.h" /* where declarations for this file go */
+#include "optimizer/planner.h"
+
+#include "tcop/tcopdebug.h"
+
+#include "executor/execdebug.h"
+#include "executor/executor.h"
+#include "nodes/relation.h"
+
+#include "optimizer/cost.h"
+#include "optimizer/planner.h"
+#if 0
+#include "optimizer/xfunc.h"
+#endif
+#include "optimizer/prep.h"
+#include "nodes/plannodes.h"
+
+#include "storage/bufmgr.h"
+#include "fmgr.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/rel.h"
+
+#include "nodes/pg_list.h"
+#include "tcop/dest.h"
+#include "nodes/memnodes.h"
+#include "utils/mcxt.h"
+#include "tcop/pquery.h"
+#include "tcop/utility.h"
+#include "tcop/fastpath.h"
+
+#include "libpq/libpq.h"
+#include "rewrite/rewriteHandler.h" /* for QueryRewrite() */
+
+/* ----------------
+ * global variables
+ * ----------------
+ */
+static bool DebugPrintPlan = false;
+static bool DebugPrintParse = false;
+static bool DebugPrintRewrittenParsetree = false;
+/*static bool EnableRewrite = true; , never changes why have it*/
+CommandDest whereToSendOutput;
+
+extern int lockingOff;
+extern int NBuffers;
+
+int dontExecute = 0;
+static int ShowStats;
+static bool IsEmptyQuery = false;
+
+Relation reldesc; /* current relation descritor */
+char relname[80]; /* current relation name */
+
+#if defined(WIN32) || defined(PORTNAME_next)
+jmp_buf Warn_restart;
+#define sigsetjmp(x,y) setjmp(x)
+#define siglongjmp longjmp
+#else
+sigjmp_buf Warn_restart;
+#endif /*defined(WIN32) || defined(PORTNAME_next) */
+
+extern int NBuffers;
+
+static int EchoQuery = 0; /* default don't echo */
+time_t tim;
+char pg_pathname[256];
+static int ShowParserStats;
+static int ShowPlannerStats;
+int ShowExecutorStats;
+FILE *StatFp;
+
+typedef struct frontend {
+ bool fn_connected;
+ Port fn_port;
+ FILE *fn_Pfin; /* the input fd */
+ FILE *fn_Pfout; /* the output fd */
+ bool fn_done; /* set after the frontend closes its connection */
+} FrontEnd;
+
+static Dllist* frontendList;
+
+/* ----------------
+ * people who want to use EOF should #define DONTUSENEWLINE in
+ * tcop/tcopdebug.h
+ * ----------------
+ */
+#ifndef TCOP_DONTUSENEWLINE
+int UseNewLine = 1; /* Use newlines query delimiters (the default) */
+#else
+int UseNewLine = 0; /* Use EOF as query delimiters */
+#endif /* TCOP_DONTUSENEWLINE */
+
+/* ----------------
+ * bushy tree plan flag: if true planner will generate bushy-tree
+ * plans
+ * ----------------
+ */
+int BushyPlanFlag = 0; /* default to false -- consider only left-deep trees */
+
+/*
+** Flags for expensive function optimization -- JMH 3/9/92
+*/
+int XfuncMode = 0;
+
+/*
+ * ----------------
+ * Note: _exec_repeat_ defaults to 1 but may be changed
+ * by a DEBUG command. If you set this to a large
+ * number N, run a single query, and then set it
+ * back to 1 and run N queries, you can get an idea
+ * of how much time is being spent in the parser and
+ * planner b/c in the first case this overhead only
+ * happens once. -cim 6/9/91
+ * ----------------
+*/
+int _exec_repeat_ = 1;
+
+/* ----------------------------------------------------------------
+ * decls for routines only used in this file
+ * ----------------------------------------------------------------
+ */
+static char InteractiveBackend(char *inBuf);
+static char SocketBackend(char *inBuf, int multiplexedBackend);
+static char ReadCommand(char *inBuf, int multiplexedBackend);
+
+
+/* ----------------------------------------------------------------
+ * routines to obtain user input
+ * ----------------------------------------------------------------
+ */
+
+/* ----------------
+ * InteractiveBackend() is called for user interactive connections
+ * the string entered by the user is placed in its parameter inBuf.
+ * ----------------
+ */
+
+static char
+InteractiveBackend(char *inBuf)
+{
+ char *stuff = inBuf; /* current place in input buffer */
+ int c; /* character read from getc() */
+ bool end = false; /* end-of-input flag */
+ bool backslashSeen = false; /* have we seen a \ ? */
+
+ /* ----------------
+ * display a prompt and obtain input from the user
+ * ----------------
+ */
+ printf("> ");
+
+ for (;;) {
+ if (UseNewLine) {
+ /* ----------------
+ * if we are using \n as a delimiter, then read
+ * characters until the \n.
+ * ----------------
+ */
+ while ( (c = getc(stdin)) != EOF) {
+ if (c == '\n') {
+ if (backslashSeen) {
+ stuff--;
+ continue;
+ } else {
+ /* keep the newline character */
+ *stuff++ = '\n';
+ *stuff++ = '\0';
+ break;
+ }
+ } else if (c == '\\')
+ backslashSeen = true;
+ else
+ backslashSeen = false;
+
+ *stuff++ = (char)c;
+ }
+
+ if (c == EOF)
+ end = true;
+ } else {
+ /* ----------------
+ * otherwise read characters until EOF.
+ * ----------------
+ */
+ while ( (c = getc(stdin)) != EOF )
+ *stuff++ = (char)c;
+
+ if ( stuff == inBuf )
+ end = true;
+ }
+
+ if (end) {
+ if (!Quiet) puts("EOF");
+ IsEmptyQuery = true;
+ exitpg(0);
+ }
+
+ /* ----------------
+ * otherwise we have a user query so process it.
+ * ----------------
+ */
+ break;
+ }
+
+ /* ----------------
+ * if the query echo flag was given, print the query..
+ * ----------------
+ */
+ if (EchoQuery)
+ printf("query is: %s\n", inBuf);
+
+ return('Q');
+}
+
+/* ----------------
+ * SocketBackend() Is called for frontend-backend connections
+ *
+ * If the input is a query (case 'Q') then the string entered by
+ * the user is placed in its parameter inBuf.
+ *
+ * If the input is a fastpath function call (case 'F') then
+ * the function call is processed in HandleFunctionRequest().
+ * (now called from PostgresMain())
+ * ----------------
+ */
+
+static char
+SocketBackend(char *inBuf, int multiplexedBackend)
+{
+ char qtype[2];
+ char result;
+
+ /* ----------------
+ * get input from the frontend
+ * ----------------
+ */
+ (void) strcpy(qtype, "?");
+ if (pq_getnchar(qtype,0,1) == EOF) {
+ /* ------------
+ * when front-end applications quits/dies
+ * ------------
+ */
+ if (multiplexedBackend) {
+ return 'X';
+ }
+ else
+ exitpg(0);
+ }
+
+ switch(*qtype) {
+ /* ----------------
+ * 'Q': user entered a query
+ * ----------------
+ */
+ case 'Q':
+ pq_getstr(inBuf, MAX_PARSE_BUFFER);
+ result = 'Q';
+ break;
+
+ /* ----------------
+ * 'F': calling user/system functions
+ * ----------------
+ */
+ case 'F':
+ pq_getstr(inBuf, MAX_PARSE_BUFFER);/* ignore the rest of the line */
+ result = 'F';
+ break;
+
+ /* ----------------
+ * 'X': frontend is exiting
+ * ----------------
+ */
+ case 'X':
+ result = 'X';
+ break;
+
+ /* ----------------
+ * otherwise we got garbage from the frontend.
+ *
+ * XXX are we certain that we want to do an elog(FATAL) here?
+ * -cim 1/24/90
+ * ----------------
+ */
+ default:
+ elog(FATAL, "Socket command type %c unknown\n", *qtype);
+ break;
+ }
+ return result;
+}
+
+/* ----------------
+ * ReadCommand reads a command from either the frontend or
+ * standard input, places it in inBuf, and returns a char
+ * representing whether the string is a 'Q'uery or a 'F'astpath
+ * call.
+ * ----------------
+ */
+static char
+ReadCommand(char *inBuf, int multiplexedBackend)
+{
+ if (IsUnderPostmaster || multiplexedBackend)
+ return SocketBackend(inBuf, multiplexedBackend);
+ else
+ return InteractiveBackend(inBuf);
+}
+
+List *
+pg_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;
+ List *plan_list = NIL;
+ Plan *plan;
+ int j;
+ QueryTreeList *new_list;
+ List *rewritten = NIL;
+ Query* querytree;
+
+ /* ----------------
+ * (1) parse the request string into a list of parse trees
+ * ----------------
+ */
+ if (ShowParserStats)
+ ResetUsage();
+
+ querytree_list = parser(query_string, typev, nargs);
+
+ if (ShowParserStats) {
+ fprintf(stderr, "! Parser Stats:\n");
+ ShowUsage();
+ }
+
+ /* new_list holds the rewritten queries */
+ new_list = (QueryTreeList*)malloc(sizeof(QueryTreeList));
+ new_list->len = querytree_list->len;
+ new_list->qtrees = (Query**)malloc(new_list->len * sizeof(Query*));
+
+ /* ----------------
+ * (2) rewrite the queries, as necessary
+ * ----------------
+ */
+ j = 0; /* counter for the new_list, new_list can be longer than
+ old list as a result of rewrites */
+ for (i=0;ilen;i++) {
+ querytree = querytree_list->qtrees[i];
+
+
+ /* don't rewrite utilites */
+ if (querytree->commandType == CMD_UTILITY) {
+ new_list->qtrees[j++] = querytree;
+ continue;
+ }
+
+ if ( DebugPrintParse == true ) {
+ printf("\ninput string is \"%s\"\n",query_string);
+ printf("\n---- \tparser outputs :\n");
+ nodeDisplay(querytree);
+ printf("\n");
+ }
+
+ /* rewrite queries (retrieve, append, delete, replace) */
+ rewritten = QueryRewrite(querytree);
+ if (rewritten != NULL) {
+ int len, k;
+ len = length(rewritten);
+ if (len == 1)
+ new_list->qtrees[j++] = (Query*)lfirst(rewritten);
+ else {
+ /* rewritten queries are longer than original query */
+ /* grow the new_list to accommodate */
+ new_list->len += len - 1; /* - 1 because originally we
+ allocated one space for the query */
+ new_list->qtrees = realloc(new_list->qtrees,
+ new_list->len * sizeof(Query*));
+ for (k=0;k
+ new_list->qtrees[j++] = (Query*)nth(k, rewritten);
+ }
+ }
+ }
+
+ /* we're done with the original lists, free it */
+ free(querytree_list->qtrees);
+ free(querytree_list);
+
+ querytree_list = new_list;
+
+ /* ----------------
+ * Fix time range quals
+ * this _must_ go here, because it must take place after rewrites
+ * ( if they take place ) so that time quals are usable by the executor
+ *
+ * Also, need to frob the range table entries here to plan union
+ * queries for archived relations.
+ * ----------------
+ */
+ for (i=0;ilen;i++) {
+ List *l;
+ List *rt = NULL;
+
+ querytree = querytree_list->qtrees[i];
+
+ /* ----------------
+ * utilities don't have time ranges
+ * ----------------
+ */
+ if (querytree->commandType == CMD_UTILITY)
+ continue;
+
+ rt = querytree->rtable;
+
+ foreach (l, rt) {
+ RangeTblEntry *rte = lfirst(l);
+ TimeRange *timequal = rte->timeRange;
+
+ if (timequal) {
+ int timecode = (rte->timeRange->endDate == NULL)? 0 : 1;
+
+ rte->timeQual = makeTimeRange(rte->timeRange->startDate,
+ rte->timeRange->endDate,
+ timecode);
+ }else {
+ rte->timeQual = NULL;
+ }
+ }
+
+ /* check for archived relations */
+ plan_archive(rt);
+ }
+
+ if (DebugPrintRewrittenParsetree == true) {
+ printf("\n=================\n");
+ printf(" After Rewriting\n");
+ printf("=================\n");
+
+ for (i=0; ilen; i++) {
+ print(querytree_list->qtrees[i]);
+ printf("\n");
+ }
+ }
+
+ for (i=0; ilen;i++) {
+ querytree = querytree_list->qtrees[i];
+
+ /*
+ * For each query that isn't a utility invocation,
+ * generate a plan.
+ */
+
+ if (querytree->commandType != CMD_UTILITY) {
+
+ if (IsAbortedTransactionBlockState()) {
+ /* ----------------
+ * the EndCommand() stuff is to tell the frontend
+ * that the command ended. -cim 6/1/90
+ * ----------------
+ */
+ char *tag = "*ABORT STATE*";
+ EndCommand(tag, dest);
+
+ elog(NOTICE, "(transaction aborted): %s",
+ "queries ignored until END");
+
+ *queryListP = (QueryTreeList*)NULL;
+ return (List*)NULL;
+ }
+
+ if (ShowPlannerStats) ResetUsage();
+ plan = planner(querytree);
+ if (ShowPlannerStats) {
+ fprintf(stderr, "! Planner Stats:\n");
+ ShowUsage();
+ }
+ plan_list = lappend(plan_list, plan);
+ }
+ }
+
+ if (queryListP)
+ *queryListP = querytree_list;
+
+ return (plan_list);
+}
+
+/* ----------------------------------------------------------------
+ * pg_eval()
+ *
+ * Takes a querystring, runs the parser/utilities or
+ * parser/planner/executor over it as necessary
+ * Begin Transaction Should have been called before this
+ * and CommitTransaction After this is called
+ * This is strictly because we do not allow for nested xactions.
+ *
+ * NON-OBVIOUS-RESTRICTIONS
+ * this function _MUST_ allocate a new "parsetree" each time,
+ * since it may be stored in a named portal and should not
+ * change its value.
+ *
+ * ----------------------------------------------------------------
+ */
+
+void
+pg_eval(char *query_string, char *argv[], Oid *typev, int nargs)
+{
+ pg_eval_dest(query_string, argv, typev, nargs, whereToSendOutput);
+}
+
+void
+pg_eval_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;
+ Query *querytree;
+ int i,j;
+ QueryTreeList *querytree_list;
+
+ /* plan the queries */
+ plan_list = pg_plan(query_string, typev, nargs, &querytree_list, dest);
+
+ /* pg_plan could have failed */
+ if (querytree_list == NULL)
+ return;
+
+ for (i=0;ilen;i++) {
+ querytree = querytree_list->qtrees[i];
+
+ if (querytree->commandType == CMD_UTILITY) {
+ /* ----------------
+ * process utility functions (create, destroy, etc..)
+ *
+ * Note: we do not check for the transaction aborted state
+ * because that is done in ProcessUtility.
+ * ----------------
+ */
+ if (! Quiet) {
+ time(&tim);
+ printf("\tProcessUtility() at %s\n", ctime(&tim));
+ }
+
+ ProcessUtility(querytree->utilityStmt, dest);
+
+ } else {
+ plan = (Plan *) lfirst(plan_list);
+ plan_list = lnext(plan_list);
+
+ /* ----------------
+ * print plan if debugging
+ * ----------------
+ */
+ if ( DebugPrintPlan == true ) {
+ printf("\nPlan is :\n");
+ nodeDisplay(plan);
+ printf("\n");
+ }
+
+ /* ----------------
+ * execute the plan
+ *
+ */
+ if (ShowExecutorStats)
+ ResetUsage();
+
+ for (j = 0; j < _exec_repeat_; j++) {
+ if (! Quiet) {
+ time(&tim);
+ printf("\tProcessQuery() at %s\n", ctime(&tim));
+ }
+ ProcessQuery(querytree, plan, argv, typev, nargs, dest);
+ }
+
+ if (ShowExecutorStats) {
+ fprintf(stderr, "! Executor Stats:\n");
+ ShowUsage();
+ }
+ }
+ /*
+ * In a query block, we want to increment the command counter
+ * between queries so that the effects of early queries are
+ * visible to subsequent ones.
+ */
+
+ if (querytree_list)
+ CommandCounterIncrement();
+ }
+
+ free(querytree_list->qtrees);
+ free(querytree_list);
+}
+
+/* --------------------------------
+ * signal handler routines used in PostgresMain()
+ *
+ * handle_warn() is used to catch kill(getpid(),1) which
+ * occurs when elog(WARN) is called.
+ *
+ * quickdie() occurs when signalled by the postmaster, some backend
+ * has bought the farm we need to stop what we're doing and exit.
+ *
+ * die() preforms an orderly cleanup via ExitPostgres()
+ * --------------------------------
+ */
+
+void
+handle_warn()
+{
+ siglongjmp(Warn_restart, 1);
+}
+
+void
+quickdie()
+{
+ elog(NOTICE, "I have been signalled by the postmaster.");
+ elog(NOTICE, "Some backend process has died unexpectedly and possibly");
+ elog(NOTICE, "corrupted shared memory. The current transaction was");
+ elog(NOTICE, "aborted, and I am going to exit. Please resend the");
+ elog(NOTICE, "last query. -- The postgres backend");
+
+ /*
+ * DO NOT ExitPostgres(0) -- we're here because shared memory may be
+ * corrupted, so we don't want to flush any shared state to stable
+ * storage. Just nail the windows shut and get out of town.
+ */
+
+ exit (0);
+}
+
+void
+die()
+{
+ ExitPostgres(0);
+}
+
+/* signal handler for floating point exception */
+void
+FloatExceptionHandler()
+{
+ elog(WARN, "floating point exception! the last floating point operation eit\
+her exceeded legal ranges or was a divide by zero");
+}
+
+
+static void usage(char* progname)
+{
+ fprintf(stderr,
+ "Usage: %s [-B nbufs] [-d lvl] ] [-f plantype] \t[-m portno] [\t -o filename]\n",
+ progname);
+ fprintf(stderr,"\t[-P portno] [-t tracetype] [-x opttype] [-bCEiLNopQSs] [dbname]\n");
+ fprintf(stderr, " b: consider bushy plan trees during optimization\n");
+ fprintf(stderr, " B: set number of buffers in buffer pool\n");
+ fprintf(stderr, " C: supress version info\n");
+ fprintf(stderr, " d: set debug level\n");
+ fprintf(stderr, " E: echo query before execution\n");
+ fprintf(stderr, " f: forbid plantype generation\n");
+ fprintf(stderr, " i: don't execute the query, just show the plan tree\n");
+ fprintf(stderr, " L: turn off locking\n");
+ fprintf(stderr, " m: set up a listening backend at portno to support multiple front-ends\n");
+ fprintf(stderr, " M: start as postmaster\n");
+ fprintf(stderr, " N: don't use newline as query delimiter\n");
+ fprintf(stderr, " o: send stdout and stderr to given filename \n");
+ fprintf(stderr, " p: backend started by postmaster\n");
+ fprintf(stderr, " P: set port file descriptor\n");
+ fprintf(stderr, " Q: suppress informational messages\n");
+ fprintf(stderr, " S: assume stable main memory\n");
+ fprintf(stderr, " s: show stats after each query\n");
+ fprintf(stderr, " t: trace component execution times\n");
+ fprintf(stderr, " T: execute all possible plans for each query\n");
+ fprintf(stderr, " x: control expensive function optimization\n");
+}
+
+/* ----------------------------------------------------------------
+ * PostgresMain
+ * postgres main loop
+ * all backends, interactive or otherwise start here
+ * ----------------------------------------------------------------
+ */
+int
+PostgresMain(int argc, char *argv[])
+{
+ int flagC;
+ int flagQ;
+ int flagS;
+ int flagE;
+ int flag;
+
+ char *DBName;
+ int errs = 0;
+
+ char firstchar;
+ char parser_input[MAX_PARSE_BUFFER];
+ char *userName;
+
+ int multiplexedBackend = 0;
+ char* hostName; /* the host name of the backend server */
+ char hostbuf[MAXHOSTNAMELEN];
+ int serverSock;
+ int serverPortnum;
+ int nSelected; /* number of descriptors ready from select(); */
+ int maxFd; /* max file descriptor + 1 */
+ fd_set rmask, basemask;
+ FrontEnd *newFE, *currentFE;
+ int numFE = 0; /* keep track of number of active frontends */
+ Port *newPort;
+ int newFd;
+ Dlelem *curr;
+ int status;
+
+#ifdef WIN32
+ WSADATA WSAData;
+#endif /* WIN32 */
+
+ extern int optind;
+ extern char *optarg;
+ extern short DebugLvl;
+
+ /* ----------------
+ * register signal handlers.
+ * ----------------
+ */
+ signal(SIGINT, die);
+
+#ifndef WIN32
+ signal(SIGHUP, die);
+ signal(SIGTERM, die);
+ signal(SIGPIPE, die);
+ signal(SIGUSR1, quickdie);
+ signal(SIGUSR2, Async_NotifyHandler);
+ signal(SIGFPE, FloatExceptionHandler);
+#endif /* WIN32 */
+
+ /* --------------------
+ * initialize globals
+ * -------------------
+ */
+
+ InitGlobals();
+
+ /* ----------------
+ * parse command line arguments
+ * ----------------
+ */
+ flagC = flagQ = flagS = flagE = ShowStats = 0;
+ ShowParserStats = ShowPlannerStats = ShowExecutorStats = 0;
+
+ /* get hostname is either the environment variable PGHOST
+ or 'localhost' */
+ if (!(hostName = getenv("PGHOST"))) {
+ if (gethostname(hostbuf, MAXHOSTNAMELEN) < 0)
+ (void) strcpy(hostbuf, "localhost");
+ hostName = hostbuf;
+ }
+
+ while ((flag = getopt(argc, argv, "B:bCd:Ef:iLm:MNo:P:pQSst:x:")) != EOF)
+ switch (flag) {
+
+ case 'b':
+ /* ----------------
+ * set BushyPlanFlag to true.
+ * ----------------
+ */
+ BushyPlanFlag = 1;
+ break;
+ case 'B':
+ /* ----------------
+ * specify the size of buffer pool
+ * ----------------
+ */
+ NBuffers = atoi(optarg);
+ break;
+
+ case 'C':
+ /* ----------------
+ * don't print version string (don't know why this is 'C' --mao)
+ * ----------------
+ */
+ flagC = 1;
+ break;
+
+ /* ----------------
+ * -debug mode
+ * ----------------
+ */
+ case 'd':
+ /* DebugMode = true; */
+ flagQ = 0;
+ DebugPrintPlan = true;
+ DebugPrintParse = true;
+ DebugPrintRewrittenParsetree = true;
+ DebugLvl = (short)atoi(optarg);
+ break;
+
+ case 'E':
+ /* ----------------
+ * E - echo the query the user entered
+ * ----------------
+ */
+ flagE = 1;
+ break;
+
+ case 'f':
+ /* -----------------
+ * f - forbid generation of certain plans
+ * -----------------
+ */
+ switch (optarg[0]) {
+ case 's': /* seqscan */
+ _enable_seqscan_ = false;
+ break;
+ case 'i': /* indexscan */
+ _enable_indexscan_ = false;
+ break;
+ case 'n': /* nestloop */
+ _enable_nestloop_ = false;
+ break;
+ case 'm': /* mergejoin */
+ _enable_mergesort_ = false;
+ break;
+ case 'h': /* hashjoin */
+ _enable_hashjoin_ = false;
+ break;
+ default:
+ errs++;
+ }
+ break;
+
+ case 'i':
+ dontExecute = 1;
+ break;
+
+ case 'L':
+ /* --------------------
+ * turn off locking
+ * --------------------
+ */
+ lockingOff = 1;
+ break;
+
+ case 'm':
+ /* start up a listening backend that can respond to
+ multiple front-ends. (Note: all the front-end connections
+ are still connected to a single-threaded backend. Requests
+ are FCFS. Everything is in one transaction
+ */
+ multiplexedBackend = 1;
+ serverPortnum = atoi(optarg);
+#ifdef WIN32
+ /* There was no postmaster started so the shared memory
+ ** for the shared memory table hasn't been allocated so
+ ** do it now.
+ */
+ _nt_init();
+#endif /* WIN32 */
+ break;
+ case 'M':
+ exit(PostmasterMain(argc, argv));
+ break;
+ case 'N':
+ /* ----------------
+ * N - Don't use newline as a query delimiter
+ * ----------------
+ */
+ UseNewLine = 0;
+ break;
+
+ case 'o':
+ /* ----------------
+ * o - send output (stdout and stderr) to the given file
+ * ----------------
+ */
+ (void) strncpy(OutputFileName, optarg, MAXPGPATH);
+ break;
+
+ case 'p': /* started by postmaster */
+ /* ----------------
+ * p - special flag passed if backend was forked
+ * by a postmaster.
+ * ----------------
+ */
+ IsUnderPostmaster = true;
+ break;
+
+ case 'P':
+ /* ----------------
+ * P - Use the passed file descriptor number as the port
+ * on which to communicate with the user. This is ONLY
+ * useful for debugging when fired up by the postmaster.
+ * ----------------
+ */
+ Portfd = atoi(optarg);
+ break;
+
+ case 'Q':
+ /* ----------------
+ * Q - set Quiet mode (reduce debugging output)
+ * ----------------
+ */
+ flagQ = 1;
+ break;
+
+ case 'S':
+ /* ----------------
+ * S - assume stable main memory
+ * (don't flush all pages at end transaction)
+ * ----------------
+ */
+ flagS = 1;
+ SetTransactionFlushEnabled(false);
+ break;
+
+ case 's':
+ /* ----------------
+ * s - report usage statistics (timings) after each query
+ * ----------------
+ */
+ ShowStats = 1;
+ StatFp = stderr;
+ break;
+
+ case 't':
+ /* ----------------
+ * tell postgres to report usage statistics (timings) for
+ * each query
+ *
+ * -tpa[rser] = print stats for parser time of each query
+ * -tpl[anner] = print stats for planner time of each query
+ * -te[xecutor] = print stats for executor time of each query
+ * caution: -s can not be used together with -t.
+ * ----------------
+ */
+ StatFp = stderr;
+ switch (optarg[0]) {
+ case 'p': if (optarg[1] == 'a')
+ ShowParserStats = 1;
+ else if (optarg[1] == 'l')
+ ShowPlannerStats = 1;
+ else
+ errs++;
+ break;
+ case 'e': ShowExecutorStats = 1; break;
+ default: errs++; break;
+ }
+ break;
+
+ case 'x':
+#if 0 /* planner/xfunc.h */
+ /* control joey hellerstein's expensive function optimization */
+ if (XfuncMode != 0)
+ {
+ fprintf(stderr, "only one -x flag is allowed\n");
+ errs++;
+ break;
+ }
+ if (strcmp(optarg, "off") == 0)
+ XfuncMode = XFUNC_OFF;
+ else if (strcmp(optarg, "nor") == 0)
+ XfuncMode = XFUNC_NOR;
+ else if (strcmp(optarg, "nopull") == 0)
+ XfuncMode = XFUNC_NOPULL;
+ else if (strcmp(optarg, "nopm") == 0)
+ XfuncMode = XFUNC_NOPM;
+ else if (strcmp(optarg, "pullall") == 0)
+ XfuncMode = XFUNC_PULLALL;
+ else if (strcmp(optarg, "wait") == 0)
+ XfuncMode = XFUNC_WAIT;
+ else {
+ fprintf(stderr, "use -x {off,nor,nopull,nopm,pullall,wait}\n");
+ errs++;
+ }
+#endif
+ break;
+
+ default:
+ /* ----------------
+ * default: bad command line option
+ * ----------------
+ */
+ errs++;
+ }
+
+ /* ----------------
+ * get user name and pathname and check command line validity
+ * ----------------
+ */
+ SetPgUserName();
+ userName = GetPgUserName();
+
+ if (FindBackend(pg_pathname, argv[0]) < 0)
+ elog(FATAL, "%s: could not locate executable, bailing out...",
+ argv[0]);
+
+ if (errs || argc - optind > 1) {
+ usage (argv[0]);
+ exitpg(1);
+ } else if (argc - optind == 1) {
+ DBName = argv[optind];
+ } else if ((DBName = userName) == NULL) {
+ fprintf(stderr, "%s: USER undefined and no database specified\n",
+ argv[0]);
+ exitpg(1);
+ }
+
+ if (ShowStats &&
+ (ShowParserStats || ShowPlannerStats || ShowExecutorStats)) {
+ fprintf(stderr, "-s can not be used together with -t.\n");
+ exitpg(1);
+ }
+
+ Noversion = flagC;
+ Quiet = flagQ;
+ EchoQuery = flagE;
+
+ /* ----------------
+ * print flags
+ * ----------------
+ */
+ if (! Quiet) {
+ puts("\t---debug info---");
+ printf("\tQuiet = %c\n", Quiet ? 't' : 'f');
+ printf("\tNoversion = %c\n", Noversion ? 't' : 'f');
+ printf("\tstable = %c\n", flagS ? 't' : 'f');
+ printf("\ttimings = %c\n", ShowStats ? 't' : 'f');
+ printf("\tbufsize = %d\n", NBuffers);
+
+ printf("\tquery echo = %c\n", EchoQuery ? 't' : 'f');
+ printf("\tmultiplexed backend? = %c\n", multiplexedBackend ? 't' : 'f');
+ printf("\tDatabaseName = [%s]\n", DBName);
+ puts("\t----------------\n");
+ }
+
+ /* ----------------
+ * initialize portal file descriptors
+ * ----------------
+ */
+ if (IsUnderPostmaster == true) {
+ if (Portfd < 0) {
+ fprintf(stderr,
+ "Postmaster flag set: no port number specified, use /dev/null\n");
+ Portfd = open(NULL_DEV, O_RDWR, 0666);
+ }
+ pq_init(Portfd);
+ }
+
+#ifdef WIN32
+ if ((status = WSAStartup(MAKEWORD(1,1), &WSAData)) == 0)
+ (void) printf("%s\nInitializing WinSock: %s\n", WSAData.szDescription, WSAData.szSystemStatus);
+ else {
+ fprintf(stderr, "Error initializing WinSock: %d is the err", status);
+ exit(1);
+ }
+#endif /* WIN32 */
+
+ if (multiplexedBackend) {
+ if (StreamServerPort(hostName, serverPortnum, &serverSock) != STATUS_OK)
+ {
+ fprintf(stderr, "Postgres: cannot create stream port %d\n", serverPortnum);
+ exit(1);
+ }
+/*
+{
+ char buf[100];
+ sprintf(buf, "stream port %d created, socket = %d\n", serverPortnum, serverSock);
+ puts(buf);
+}
+*/
+ FD_ZERO(&rmask);
+ FD_ZERO(&basemask);
+ FD_SET(serverSock, &basemask);
+
+ frontendList = DLNewList();
+ /* add the original FrontEnd to the list */
+ if (IsUnderPostmaster == true) {
+ FrontEnd *fe = malloc(sizeof(FrontEnd));
+
+ FD_SET(Portfd, &basemask);
+ maxFd = Max(serverSock,Portfd) + 1;
+
+ fe->fn_connected = true;
+ fe->fn_Pfin = Pfin;
+ fe->fn_Pfout = Pfout;
+ fe->fn_done = false;
+ (fe->fn_port).sock = Portfd;
+ DLAddHead(frontendList, DLNewElem(fe));
+ numFE++;
+ } else {
+ numFE = 1;
+ maxFd = serverSock + 1;
+ }
+ }
+
+ if (IsUnderPostmaster || multiplexedBackend)
+ whereToSendOutput = Remote;
+ else
+ whereToSendOutput = Debug;
+
+ SetProcessingMode(InitProcessing);
+
+ /* initialize */
+ if (! Quiet) {
+ puts("\tInitPostgres()..");
+ }
+
+#if WIN32
+ _nt_attach();
+#endif /* WIN32 */
+
+ InitPostgres(DBName);
+
+ /* ----------------
+ * if an exception is encountered, processing resumes here
+ * so we abort the current transaction and start a new one.
+ * This must be done after we initialize the slave backends
+ * so that the slaves signal the master to abort the transaction
+ * rather than calling AbortCurrentTransaction() themselves.
+ *
+ * Note: elog(WARN) causes a kill(getpid(),1) to occur sending
+ * us back here.
+ * ----------------
+ */
+
+#ifndef WIN32
+ signal(SIGHUP, handle_warn);
+
+ if (sigsetjmp(Warn_restart, 1) != 0) {
+#else
+ if (setjmp(Warn_restart) != 0) {
+#endif /* WIN32 */
+
+ time(&tim);
+
+ if (! Quiet)
+ printf("\tAbortCurrentTransaction() at %s\n", ctime(&tim));
+
+ memset(parser_input, 0, MAX_PARSE_BUFFER);
+
+ AbortCurrentTransaction();
+ }
+
+ /* ----------------
+ * POSTGRES main processing loop begins here
+ * ----------------
+ */
+ if (IsUnderPostmaster == false) {
+ puts("\nPOSTGRES backend interactive interface");
+ puts("$Revision: 1.1.1.1 $ $Date: 1996/07/09 06:22:00 $");
+ }
+
+ /* ----------------
+ * if stable main memory is assumed (-S flag is set), it is necessary
+ * to flush all dirty shared buffers before exit
+ * plai 8/7/90
+ * ----------------
+ */
+ if (!TransactionFlushEnabled())
+ on_exitpg(FlushBufferPool, (caddr_t) 0);
+
+ for (;;) {
+
+ if (multiplexedBackend) {
+ if (numFE == 0)
+ break;
+
+ memmove((char *) &rmask, (char *) &basemask, sizeof(fd_set));
+ nSelected = select(maxFd, &rmask,0,0,0);
+
+ if (nSelected < 0) {
+
+ if (errno == EINTR) continue;
+ fprintf(stderr,"postgres: multiplexed backend select failed\n");
+ exitpg(1);
+ }
+ if (FD_ISSET(serverSock, &rmask)) {
+ /* new connection pending on our well-known port's socket */
+ newFE = (FrontEnd*) malloc (sizeof(FrontEnd));
+ memset(newFE, sizeof(FrontEnd),0);
+ newFE->fn_connected = false;
+ newFE->fn_done = false;
+ newPort = &(newFE->fn_port);
+ if (StreamConnection(serverSock,newPort) != STATUS_OK) {
+ StreamClose(newPort->sock);
+ newFd = -1;
+ }
+ else {
+ DLAddHead(frontendList, DLNewElem(newFE));
+ numFE++;
+ newFd = newPort->sock;
+ if (newFd >= maxFd) maxFd = newFd + 1;
+ FD_SET(newFd, &rmask);
+ FD_SET(newFd, &basemask);
+ --nSelected;
+ FD_CLR(serverSock, &rmask);
+ }
+ continue;
+ } /* if FD_ISSET(serverSock) */
+
+ /* if we get here, it means that the serverSocket was not the one
+ selected. Instead, one of the front ends was selected.
+ find which one */
+ curr = DLGetHead(frontendList);
+ while (curr) {
+ FrontEnd *fe = (FrontEnd*)DLE_VAL(curr);
+ Port *port = &(fe->fn_port);
+
+ /* this is lifted from postmaster.c */
+ if (FD_ISSET(port->sock, &rmask)) {
+ if (fe->fn_connected == false) {
+ /* we have a message from a new frontEnd */
+ status = PacketReceive(port, &port->buf, NON_BLOCKING);
+ if (status == STATUS_OK) {
+ fe->fn_connected = true;
+ pq_init(port->sock);
+ fe->fn_Pfin = Pfin;
+ fe->fn_Pfout = Pfout;
+ }
+ else
+ fprintf(stderr,"Multiplexed backend: error in reading packets from %d\n", port->sock);
+ }
+ else /* we have a query from an existing, active FrontEnd */
+ {
+ Pfin = fe->fn_Pfin;
+ Pfout = fe->fn_Pfout;
+ currentFE = fe;
+ }
+ if (fe->fn_done)
+ {
+ Dlelem *c = curr;
+ curr = DLGetSucc(curr);
+ DLRemove(c);
+ }
+ break;
+ }
+ else
+ curr = DLGetSucc(curr);
+ }
+ }
+ /* ----------------
+ * (1) read a command.
+ * ----------------
+ */
+ memset(parser_input, 0, MAX_PARSE_BUFFER);
+
+ firstchar = ReadCommand(parser_input, multiplexedBackend);
+ /* process the command */
+ switch (firstchar) {
+ /* ----------------
+ * 'F' indicates a fastpath call.
+ * XXX HandleFunctionRequest
+ * ----------------
+ */
+ case 'F':
+ IsEmptyQuery = false;
+
+ /* start an xact for this function invocation */
+ if (! Quiet) {
+ time(&tim);
+ printf("\tStartTransactionCommand() at %s\n", ctime(&tim));
+ }
+
+ StartTransactionCommand();
+ HandleFunctionRequest();
+ break;
+
+ /* ----------------
+ * 'Q' indicates a user query
+ * ----------------
+ */
+ case 'Q':
+ fflush(stdout);
+
+ if ( parser_input[0] == ' ' && parser_input[1] == '\0' ) {
+ /* ----------------
+ * if there is nothing in the input buffer, don't bother
+ * trying to parse and execute anything..
+ * ----------------
+ */
+ IsEmptyQuery = true;
+ } else {
+ /* ----------------
+ * otherwise, process the input string.
+ * ----------------
+ */
+ IsEmptyQuery = false;
+ if (ShowStats)
+ ResetUsage();
+
+ /* start an xact for this query */
+ if (! Quiet) {
+ time(&tim);
+ printf("\tStartTransactionCommand() at %s\n", ctime(&tim));
+ }
+ StartTransactionCommand();
+
+ pg_eval(parser_input, (char **) NULL, (Oid *) NULL, 0);
+
+ if (ShowStats)
+ ShowUsage();
+ }
+ break;
+
+ /* ----------------
+ * 'X' means that the frontend is closing down the socket
+ * ----------------
+ */
+ case 'X':
+ IsEmptyQuery = true;
+ if (multiplexedBackend) {
+ FD_CLR(currentFE->fn_port.sock, &basemask);
+ currentFE->fn_done = true;
+ numFE--;
+ }
+ pq_close();
+ break;
+
+ default:
+ elog(WARN,"unknown frontend message was recieved");
+ }
+
+ /* ----------------
+ * (3) commit the current transaction
+ *
+ * Note: if we had an empty input buffer, then we didn't
+ * call pg_eval, so we don't bother to commit this transaction.
+ * ----------------
+ */
+ if (! IsEmptyQuery) {
+ if (! Quiet) {
+ time(&tim);
+ printf("\tCommitTransactionCommand() at %s\n", ctime(&tim));
+ }
+ CommitTransactionCommand();
+
+ } else {
+ if (IsUnderPostmaster || multiplexedBackend)
+ NullCommand(Remote);
+ }
+
+} /* infinite for-loop */
+ exitpg(0);
+ return 1;
+}
+
+#ifndef WIN32
+#ifdef NEED_RUSAGE
+#include "rusagestub.h"
+#else /* NEED_RUSAGE */
+#include
+#endif /* NEED_RUSAGE */
+
+struct rusage Save_r;
+struct timeval Save_t;
+
+void
+ResetUsage()
+{
+ struct timezone tz;
+ getrusage(RUSAGE_SELF, &Save_r);
+ gettimeofday(&Save_t, &tz);
+ ResetBufferUsage();
+/* ResetTupleCount(); */
+}
+
+void
+ShowUsage()
+{
+ struct timeval user, sys;
+ struct timeval elapse_t;
+ struct timezone tz;
+ struct rusage r;
+
+ getrusage(RUSAGE_SELF, &r);
+ gettimeofday(&elapse_t, &tz);
+ memmove((char *)&user, (char *)&r.ru_utime, sizeof(user));
+ memmove((char *)&sys, (char *)&r.ru_stime,sizeof(sys));
+ if (elapse_t.tv_usec < Save_t.tv_usec) {
+ elapse_t.tv_sec--;
+ elapse_t.tv_usec += 1000000;
+ }
+ if (r.ru_utime.tv_usec < Save_r.ru_utime.tv_usec) {
+ r.ru_utime.tv_sec--;
+ r.ru_utime.tv_usec += 1000000;
+ }
+ if (r.ru_stime.tv_usec < Save_r.ru_stime.tv_usec) {
+ r.ru_stime.tv_sec--;
+ r.ru_stime.tv_usec += 1000000;
+ }
+
+ /*
+ * the only stats we don't show here are for memory usage -- i can't
+ * figure out how to interpret the relevant fields in the rusage
+ * struct, and they change names across o/s platforms, anyway.
+ * if you can figure out what the entries mean, you can somehow
+ * extract resident set size, shared text size, and unshared data
+ * and stack sizes.
+ */
+
+ fprintf(StatFp, "! system usage stats:\n");
+ fprintf(StatFp,
+ "!\t%d.%06d elapsed %d.%06d user %d.%06d system sec\n",
+ elapse_t.tv_sec - Save_t.tv_sec,
+ elapse_t.tv_usec - Save_t.tv_usec,
+ r.ru_utime.tv_sec - Save_r.ru_utime.tv_sec,
+ r.ru_utime.tv_usec - Save_r.ru_utime.tv_usec,
+ r.ru_stime.tv_sec - Save_r.ru_stime.tv_sec,
+ r.ru_stime.tv_usec - Save_r.ru_stime.tv_usec);
+ fprintf(StatFp,
+ "!\t[%d.%06d user %d.%06d sys total]\n",
+ user.tv_sec, user.tv_usec, sys.tv_sec, sys.tv_usec);
+#ifndef NEED_RUSAGE
+ fprintf(StatFp,
+ "!\t%ld/%ld [%ld/%ld] filesystem blocks in/out\n",
+ r.ru_inblock - Save_r.ru_inblock,
+ /* they only drink coffee at dec */
+ r.ru_oublock - Save_r.ru_oublock,
+ r.ru_inblock, r.ru_oublock);
+ fprintf(StatFp,
+ "!\t%ld/%ld [%ld/%ld] page faults/reclaims, %ld [%ld] swaps\n",
+ r.ru_majflt - Save_r.ru_majflt,
+ r.ru_minflt - Save_r.ru_minflt,
+ r.ru_majflt, r.ru_minflt,
+ r.ru_nswap - Save_r.ru_nswap,
+ r.ru_nswap);
+ fprintf(StatFp,
+ "!\t%ld [%ld] signals rcvd, %ld/%ld [%ld/%ld] messages rcvd/sent\n",
+ r.ru_nsignals - Save_r.ru_nsignals,
+ r.ru_nsignals,
+ r.ru_msgrcv - Save_r.ru_msgrcv,
+ r.ru_msgsnd - Save_r.ru_msgsnd,
+ r.ru_msgrcv, r.ru_msgsnd);
+ fprintf(StatFp,
+ "!\t%ld/%ld [%ld/%ld] voluntary/involuntary context switches\n",
+ r.ru_nvcsw - Save_r.ru_nvcsw,
+ r.ru_nivcsw - Save_r.ru_nivcsw,
+ r.ru_nvcsw, r.ru_nivcsw);
+#endif /* NEED_RUSAGE */
+ fprintf(StatFp, "! postgres usage stats:\n");
+ PrintBufferUsage(StatFp);
+/* DisplayTupleCount(StatFp); */
+}
+#else
+void
+ShowUsage()
+{}
+
+void
+ResetUsage()
+{}
+#endif /* WIN32 */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * pquery.c--
+ * POSTGRES process query command code
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/tcop/pquery.c,v 1.1.1.1 1996/07/09 06:22:00 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "tcop/tcopdebug.h"
+
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/mcxt.h"
+#include "miscadmin.h"
+#include "utils/portal.h"
+
+#include "nodes/pg_list.h"
+#include "nodes/primnodes.h"
+#include "nodes/plannodes.h"
+#include "nodes/execnodes.h"
+#include "nodes/memnodes.h"
+
+#include "tcop/dest.h"
+
+#include "executor/execdefs.h"
+#include "executor/execdesc.h"
+#include "executor/executor.h"
+#include "tcop/pquery.h"
+
+#include "commands/command.h"
+
+static char* CreateOperationTag(int operationType);
+
+/* ----------------------------------------------------------------
+ * CreateQueryDesc
+ * ----------------------------------------------------------------
+ */
+QueryDesc *
+CreateQueryDesc(Query *parsetree,
+ Plan *plantree,
+ CommandDest dest)
+{
+ QueryDesc *qd = (QueryDesc *)palloc(sizeof(QueryDesc));
+
+ qd->operation = parsetree->commandType; /* operation */
+ qd->parsetree = parsetree; /* parse tree */
+ qd->plantree = plantree; /* plan */
+ qd->dest = dest; /* output dest */
+ return qd;
+}
+
+/* ----------------------------------------------------------------
+ * CreateExecutorState
+ *
+ * Note: this may someday take parameters -cim 9/18/89
+ * ----------------------------------------------------------------
+ */
+EState *
+CreateExecutorState()
+{
+ EState *state;
+ extern int NBuffers;
+ long *refcount;
+
+ /* ----------------
+ * create a new executor state
+ * ----------------
+ */
+ state = makeNode(EState);
+
+ /* ----------------
+ * initialize the Executor State structure
+ * ----------------
+ */
+ state->es_direction = EXEC_FRWD;
+ state->es_range_table = NIL;
+
+ state->es_into_relation_descriptor = NULL;
+ state->es_result_relation_info = NULL;
+
+ state->es_param_list_info = NULL;
+
+ state->es_BaseId = 0;
+ state->es_tupleTable = NULL;
+
+ state->es_junkFilter = NULL;
+
+ refcount = (long *) palloc(NBuffers * sizeof(long));
+ memset((char *) refcount, 0, NBuffers * sizeof(long));
+ state->es_refcount = (int *) refcount;
+
+ /* ----------------
+ * return the executor state structure
+ * ----------------
+ */
+ return state;
+}
+
+/* ----------------------------------------------------------------
+ * CreateOperationTag
+ *
+ * utility to get a string representation of the
+ * query operation.
+ * ----------------------------------------------------------------
+ */
+static char*
+CreateOperationTag(int operationType)
+{
+ char* tag;
+
+ switch (operationType) {
+ case CMD_SELECT:
+ tag = "SELECT";
+ break;
+ case CMD_INSERT:
+ tag = "INSERT";
+ break;
+ case CMD_DELETE:
+ tag = "DELETE";
+ break;
+ case CMD_UPDATE:
+ tag = "UPDATE";
+ break;
+ default:
+ elog(DEBUG, "CreateOperationTag: unknown operation type %d",
+ operationType);
+ tag = NULL;
+ break;
+ }
+
+ return tag;
+}
+
+/* ----------------
+ * ProcessPortal
+ * ----------------
+ */
+
+void
+ProcessPortal(char* portalName,
+ Query *parseTree,
+ Plan *plan,
+ EState *state,
+ TupleDesc attinfo,
+ CommandDest dest)
+{
+ Portal portal;
+ MemoryContext portalContext;
+
+ /* ----------------
+ * convert the current blank portal into the user-specified
+ * portal and initialize the state and query descriptor.
+ * ----------------
+ */
+
+ if (PortalNameIsSpecial(portalName))
+ elog(WARN,
+ "The portal name %s is reserved for internal use",
+ portalName);
+
+ portal = BlankPortalAssignName(portalName);
+
+ PortalSetQuery(portal,
+ CreateQueryDesc(parseTree, plan, dest),
+ attinfo,
+ state,
+ PortalCleanup);
+
+ /* ----------------
+ * now create a new blank portal and switch to it.
+ * Otherwise, the new named portal will be cleaned.
+ *
+ * Note: portals will only be supported within a BEGIN...END
+ * block in the near future. Later, someone will fix it to
+ * do what is possible across transaction boundries. -hirohama
+ * ----------------
+ */
+ portalContext = (MemoryContext)
+ PortalGetHeapMemory(GetPortalByName(NULL));
+
+ MemoryContextSwitchTo(portalContext);
+
+ StartPortalAllocMode(DefaultAllocMode, 0);
+}
+
+
+/* ----------------------------------------------------------------
+ * ProcessQueryDesc
+ *
+ * Read the comments for ProcessQuery() below...
+ * ----------------------------------------------------------------
+ */
+void
+ProcessQueryDesc(QueryDesc *queryDesc)
+{
+ Query *parseTree;
+ Plan *plan;
+ int operation;
+ char* tag;
+ EState *state;
+ TupleDesc attinfo;
+
+ bool isRetrieveIntoPortal;
+ bool isRetrieveIntoRelation;
+ char* intoName;
+ CommandDest dest;
+
+ /* ----------------
+ * get info from the query desc
+ * ----------------
+ */
+ parseTree = queryDesc->parsetree;
+ plan = queryDesc->plantree;
+
+ operation = queryDesc->operation;
+ tag = CreateOperationTag(operation);
+ dest = queryDesc->dest;
+
+ /* ----------------
+ * initialize portal/into relation status
+ * ----------------
+ */
+ isRetrieveIntoPortal = false;
+ isRetrieveIntoRelation = false;
+
+ if (operation == CMD_SELECT) {
+ if (parseTree->isPortal) {
+ isRetrieveIntoPortal = true;
+ intoName = parseTree->into;
+ if (parseTree->isBinary) {
+ /*
+ * For internal format portals, we change Remote
+ * (externalized form) to RemoteInternal (internalized
+ * form)
+ */
+ dest = queryDesc->dest = RemoteInternal;
+ }
+ } else if (parseTree->into != NULL) {
+ /* select into table */
+ isRetrieveIntoRelation = true;
+ }
+
+ }
+
+ /* ----------------
+ * when performing a retrieve into, we override the normal
+ * communication destination during the processing of the
+ * the query. This only affects the tuple-output function
+ * - the correct destination will still see BeginCommand()
+ * and EndCommand() messages.
+ * ----------------
+ */
+ if (isRetrieveIntoRelation)
+ queryDesc->dest = (int) None;
+
+ /* ----------------
+ * create a default executor state..
+ * ----------------
+ */
+ state = CreateExecutorState();
+
+ /* ----------------
+ * call ExecStart to prepare the plan for execution
+ * ----------------
+ */
+ attinfo = ExecutorStart(queryDesc, state);
+
+ /* ----------------
+ * report the query's result type information
+ * back to the front end or to whatever destination
+ * we're dealing with.
+ * ----------------
+ */
+ BeginCommand(NULL,
+ operation,
+ attinfo,
+ isRetrieveIntoRelation,
+ isRetrieveIntoPortal,
+ tag,
+ dest);
+
+ /* ----------------
+ * Named portals do not do a "fetch all" initially, so now
+ * we return since ExecMain has been called with EXEC_START
+ * to initialize the query plan.
+ *
+ * Note: ProcessPortal transforms the current "blank" portal
+ * into a named portal and creates a new blank portal so
+ * everything we allocated in the current "blank" memory
+ * context will be preserved across queries. -cim 2/22/91
+ * ----------------
+ */
+ if (isRetrieveIntoPortal) {
+ PortalExecutorHeapMemory = NULL;
+
+ ProcessPortal(intoName,
+ parseTree,
+ plan,
+ state,
+ attinfo,
+ dest);
+
+ EndCommand(tag, dest);
+ return;
+ }
+
+ /* ----------------
+ * Now we get to the important call to ExecutorRun() where we
+ * actually run the plan..
+ * ----------------
+ */
+ ExecutorRun(queryDesc, state, EXEC_RUN, 0);
+
+ /* ----------------
+ * now, we close down all the scans and free allocated resources...
+ * with ExecutorEnd()
+ * ----------------
+ */
+ ExecutorEnd(queryDesc, state);
+
+ /* ----------------
+ * Notify the destination of end of processing.
+ * ----------------
+ */
+ EndCommand(tag, dest);
+}
+
+/* ----------------------------------------------------------------
+ * ProcessQuery
+ *
+ * Execute a plan, the non-parallel version
+ * ----------------------------------------------------------------
+ */
+
+void
+ProcessQuery(Query *parsetree,
+ Plan *plan,
+ char *argv[],
+ Oid *typev,
+ int nargs,
+ CommandDest dest)
+{
+ QueryDesc *queryDesc;
+ extern int dontExecute; /* from postgres.c */
+ extern void print_plan (Plan* p, Query* parsetree); /* from print.c */
+
+ queryDesc = CreateQueryDesc(parsetree, plan, dest);
+
+ if (dontExecute) {
+ /* don't execute it, just show the query plan */
+ print_plan(plan, parsetree);
+ } else
+ ProcessQueryDesc(queryDesc);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * pquery.h--
+ * prototypes for pquery.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: pquery.h,v 1.1.1.1 1996/07/09 06:22:00 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PQUERY_H
+#define PQUERY_H
+
+#include "executor/execdesc.h"
+#include "tcop/dest.h"
+
+/* moved to execdesc.h
+extern QueryDesc *CreateQueryDesc(Query *parsetree, Plan *plantree,
+ CommandDest dest);
+
+*/
+extern EState *CreateExecutorState();
+
+
+extern void ProcessPortal(char *portalName, Query *parseTree,
+ Plan *plan, EState *state, TupleDesc attinfo,
+ CommandDest dest);
+
+extern void ProcessQueryDesc(QueryDesc *queryDesc);
+
+extern void ProcessQuery(Query *parsetree, Plan *plan, char *argv[],
+ Oid *typev, int nargs, CommandDest dest);
+
+#endif /* pqueryIncluded */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * tcopdebug.h--
+ * #defines governing debugging behaviour in the traffic cop
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: tcopdebug.h,v 1.1.1.1 1996/07/09 06:22:00 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef TCOPDEBUG_H
+#define TCOPDEBUG_H
+
+/* ----------------------------------------------------------------
+ * debugging defines.
+ *
+ * If you want certain debugging behaviour, then #define
+ * the variable to 1, else #undef it. -cim 10/26/89
+ * ----------------------------------------------------------------
+ */
+
+/* ----------------
+ * TCOP_SHOWSTATS controls whether or not buffer and
+ * access method statistics are shown for each query. -cim 2/9/89
+ * ----------------
+ */
+#undef TCOP_SHOWSTATS
+
+/* ----------------
+ * TCOP_DONTUSENEWLINE controls the default setting of
+ * the UseNewLine variable in postgres.c
+ * ----------------
+ */
+#undef TCOP_DONTUSENEWLINE
+
+/* ----------------------------------------------------------------
+ * #defines controlled by above definitions
+ * ----------------------------------------------------------------
+ */
+
+#endif /* TCOPDEBUG_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * tcopprot.h--
+ * prototypes for postgres.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: tcopprot.h,v 1.1.1.1 1996/07/09 06:22:00 scrappy Exp $
+ *
+ * OLD COMMENTS
+ * This file was created so that other c files could get the two
+ * function prototypes without having to include tcop.h which single
+ * handedly includes the whole f*cking tree -- mer 5 Nov. 1991
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef TCOPPROT_H
+#define TCOPPROT_H
+
+#include "tcop/dest.h"
+#include "nodes/pg_list.h"
+#include "parser/parse_query.h"
+
+#ifndef BOOTSTRAP_INCLUDE
+extern List *pg_plan(char *query_string, Oid *typev, int nargs,
+ QueryTreeList **queryListP, CommandDest dest);
+extern void pg_eval(char *query_string, char *argv[], Oid *typev, int nargs);
+extern void pg_eval_dest(char *query_string, char *argv[], Oid *typev,
+ int nargs, CommandDest dest);
+#endif /* BOOTSTRAP_HEADER */
+
+extern void handle_warn();
+extern void quickdie();
+extern void die();
+extern int PostgresMain(int argc, char *argv[]);
+extern void ResetUsage();
+extern void ShowUsage();
+
+#endif /* tcopprotIncluded */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * utility.c--
+ * Contains functions which control the execution of the POSTGRES utility
+ * commands. At one time acted as an interface between the Lisp and C
+ * systems.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/tcop/utility.c,v 1.1.1.1 1996/07/09 06:22:00 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+#include "parser/dbcommands.h"
+#include "access/xact.h"
+#include "catalog/catalog.h"
+#include "catalog/pg_type.h"
+
+#include "commands/async.h"
+#include "commands/cluster.h"
+#include "commands/command.h"
+#include "commands/copy.h"
+#include "commands/creatinh.h"
+#include "commands/defrem.h"
+#include "commands/purge.h"
+#include "commands/rename.h"
+#include "commands/view.h"
+#include "commands/version.h"
+#include "commands/vacuum.h"
+#include "commands/recipe.h"
+#include "commands/explain.h"
+
+#include "nodes/parsenodes.h"
+#include "parse.h"
+#include "utils/elog.h"
+#include "utils/builtins.h"
+#include "utils/acl.h"
+#include "utils/palloc.h"
+#include "rewrite/rewriteRemove.h"
+#include "rewrite/rewriteDefine.h"
+#include "tcop/tcopdebug.h"
+#include "tcop/dest.h"
+
+#ifndef NO_SECURITY
+#include "miscadmin.h"
+#include "utils/acl.h"
+#include "utils/syscache.h"
+#endif
+
+
+/* ----------------
+ * CHECK_IF_ABORTED() is used to avoid doing unnecessary
+ * processing within an aborted transaction block.
+ * ----------------
+ */
+#define CHECK_IF_ABORTED() \
+ if (IsAbortedTransactionBlockState()) { \
+ elog(NOTICE, "(transaction aborted): %s", \
+ "queries ignored until END"); \
+ commandTag = "*ABORT STATE*"; \
+ break; \
+ } \
+
+/* ----------------
+ * general utility function invoker
+ * ----------------
+ */
+void
+ProcessUtility(Node *parsetree,
+ CommandDest dest)
+{
+ char *commandTag = NULL;
+ char *relname;
+ char *relationName;
+ char *userName;
+
+ userName = GetPgUserName();
+
+ switch (nodeTag(parsetree)) {
+ /* ********************************
+ * transactions
+ * ********************************
+ */
+ case T_TransactionStmt:
+ {
+ TransactionStmt *stmt = (TransactionStmt *)parsetree;
+ switch (stmt->command) {
+ case BEGIN_TRANS:
+ commandTag = "BEGIN";
+ CHECK_IF_ABORTED();
+ BeginTransactionBlock();
+ break;
+
+ case END_TRANS:
+ commandTag = "END";
+ EndTransactionBlock();
+ break;
+
+ case ABORT_TRANS:
+ commandTag = "ABORT";
+ UserAbortTransactionBlock();
+ break;
+ }
+ }
+ break;
+
+ /* ********************************
+ * portal manipulation
+ * ********************************
+ */
+ case T_ClosePortalStmt:
+ {
+ ClosePortalStmt *stmt = (ClosePortalStmt *)parsetree;
+
+ commandTag = "CLOSE";
+ CHECK_IF_ABORTED();
+
+ PerformPortalClose(stmt->portalname, dest);
+ }
+ break;
+
+ case T_FetchStmt:
+ {
+ FetchStmt *stmt = (FetchStmt *)parsetree;
+ char *portalName = stmt->portalname;
+ bool forward;
+ int count;
+
+ commandTag = "FETCH";
+ CHECK_IF_ABORTED();
+
+ forward = (bool)(stmt->direction == FORWARD);
+
+ /* parser ensures that count is >= 0 and
+ 'fetch ALL' -> 0 */
+
+ count = stmt->howMany;
+ PerformPortalFetch(portalName, forward, count, commandTag, dest);
+ }
+ break;
+
+ /* ********************************
+ * relation and attribute manipulation
+ * ********************************
+ */
+ case T_CreateStmt:
+ commandTag = "CREATE";
+ CHECK_IF_ABORTED();
+
+ DefineRelation((CreateStmt *)parsetree);
+ break;
+
+ case T_DestroyStmt:
+ {
+ DestroyStmt *stmt = (DestroyStmt *)parsetree;
+ List *arg;
+ List *args = stmt->relNames;
+
+ commandTag = "DROP";
+ CHECK_IF_ABORTED();
+
+ foreach (arg, args) {
+ relname = strVal(lfirst(arg));
+ if (IsSystemRelationName(relname))
+ elog(WARN, "class \"%-.*s\" is a system catalog",
+ NAMEDATALEN, relname);
+#ifndef NO_SECURITY
+ if (!pg_ownercheck(userName, relname, RELNAME))
+ elog(WARN, "you do not own class \"%-.*s\"",
+ NAMEDATALEN, relname);
+#endif
+ }
+ foreach (arg, args) {
+ relname = strVal(lfirst(arg));
+ RemoveRelation(relname);
+ }
+ }
+ break;
+
+ case T_PurgeStmt:
+ {
+ PurgeStmt *stmt = (PurgeStmt *)parsetree;
+
+ commandTag = "PURGE";
+ CHECK_IF_ABORTED();
+
+ RelationPurge(stmt->relname,
+ stmt->beforeDate, /* absolute time string */
+ stmt->afterDate); /* relative time string */
+ }
+ break;
+
+ case T_CopyStmt:
+ {
+ CopyStmt *stmt = (CopyStmt *)parsetree;
+ char *filename;
+ char *delim;
+ bool isBinary;
+ bool isFrom;
+ bool pipe = false;
+
+ commandTag = "COPY";
+ CHECK_IF_ABORTED();
+
+ relname = stmt->relname;
+ isBinary = stmt->binary;
+
+ isFrom = (bool)(stmt->direction == FROM);
+ filename = stmt->filename;
+ delim = stmt->delimiter;
+
+#ifndef NO_SECURITY
+ if (isFrom) {
+ if (!pg_aclcheck(relname, userName, ACL_RD))
+ elog(WARN, "%s %s", relname, ACL_NO_PRIV_WARNING);
+ } else {
+ if (!pg_aclcheck(relname, userName, ACL_WR))
+ elog(WARN, "%s %s", relname, ACL_NO_PRIV_WARNING);
+ }
+#endif
+
+ /* Free up file descriptors - going to do a read... */
+
+ closeOneVfd();
+
+ /*
+ * use stdin/stdout if filename is null.
+ */
+ if (filename == NULL)
+ pipe = true;
+
+ if (pipe && IsUnderPostmaster) dest = CopyEnd;
+
+ DoCopy(relname, isBinary, isFrom, pipe, filename, delim);
+ }
+ break;
+
+ case T_AddAttrStmt:
+ {
+ AddAttrStmt *stmt = (AddAttrStmt *)parsetree;
+
+ commandTag = "ADD";
+ CHECK_IF_ABORTED();
+
+ /* owner checking done in PerformAddAttribute (now recursive) */
+ PerformAddAttribute(stmt->relname,
+ userName,
+ stmt->inh,
+ stmt->colDef);
+ }
+ break;
+
+ /*
+ * schema
+ */
+ case T_RenameStmt:
+ {
+ RenameStmt *stmt = (RenameStmt *)parsetree;
+
+ commandTag = "RENAME";
+ CHECK_IF_ABORTED();
+
+ relname = stmt->relname;
+ if (IsSystemRelationName(relname))
+ elog(WARN, "class \"%s\" is a system catalog",
+ relname);
+#ifndef NO_SECURITY
+ if (!pg_ownercheck(userName, relname, RELNAME))
+ elog(WARN, "you do not own class \"%s\"",
+ relname);
+#endif
+
+ /* ----------------
+ * XXX using len == 3 to tell the difference
+ * between "rename rel to newrel" and
+ * "rename att in rel to newatt" will not
+ * work soon because "rename type/operator/rule"
+ * stuff is being added. - cim 10/24/90
+ * ----------------
+ * [another piece of amuzing but useless anecdote -- ay]
+ */
+ if (stmt->column == NULL) {
+ /* ----------------
+ * rename relation
+ *
+ * Note: we also rename the "type" tuple
+ * corresponding to the relation.
+ * ----------------
+ */
+ renamerel(relname, /* old name */
+ stmt->newname); /* new name */
+ TypeRename(relname, /* old name */
+ stmt->newname); /* new name */
+ } else {
+ /* ----------------
+ * rename attribute
+ * ----------------
+ */
+ renameatt(relname, /* relname */
+ stmt->column, /* old att name */
+ stmt->newname, /* new att name */
+ userName,
+ stmt->inh); /* recursive? */
+ }
+ }
+ break;
+
+ case T_ChangeACLStmt:
+ {
+ ChangeACLStmt *stmt = (ChangeACLStmt *)parsetree;
+ List *i;
+ AclItem *aip;
+ unsigned modechg;
+
+ commandTag = "CHANGE";
+ CHECK_IF_ABORTED();
+
+ aip = stmt->aclitem;
+ modechg = stmt->modechg;
+#ifndef NO_SECURITY
+ foreach (i, stmt->relNames) {
+ relname = strVal(lfirst(i));
+ if (!pg_ownercheck(userName, relname, RELNAME))
+ elog(WARN, "you do not own class \"%-.*s\"",
+ NAMEDATALEN, relname);
+ }
+#endif
+ foreach (i, stmt->relNames) {
+ relname = strVal(lfirst(i));
+ ChangeAcl(relname, aip, modechg);
+ }
+
+ }
+ break;
+
+ /* ********************************
+ * object creation / destruction
+ * ********************************
+ */
+ case T_DefineStmt:
+ {
+ DefineStmt *stmt = (DefineStmt *)parsetree;
+
+ commandTag = "CREATE";
+ CHECK_IF_ABORTED();
+
+ switch(stmt->defType) {
+ case OPERATOR:
+ DefineOperator(stmt->defname, /* operator name */
+ stmt->definition); /* rest */
+ break;
+ case P_TYPE:
+ {
+ DefineType (stmt->defname, stmt->definition);
+ }
+ break;
+ case AGGREGATE:
+ DefineAggregate(stmt->defname, /*aggregate name */
+ stmt->definition); /* rest */
+ break;
+ }
+ }
+ break;
+
+ case T_ViewStmt: /* VIEW */
+ {
+ ViewStmt *stmt = (ViewStmt *)parsetree;
+
+ commandTag = "CREATE";
+ CHECK_IF_ABORTED();
+ DefineView (stmt->viewname, stmt->query); /* retrieve parsetree */
+ }
+ break;
+
+ case T_ProcedureStmt: /* FUNCTION */
+ commandTag = "CREATE";
+ CHECK_IF_ABORTED();
+ DefineFunction((ProcedureStmt *)parsetree, dest); /* everything */
+ break;
+
+ case T_IndexStmt:
+ {
+ IndexStmt *stmt = (IndexStmt *)parsetree;
+
+ commandTag = "CREATE";
+ CHECK_IF_ABORTED();
+ /* XXX no support for ARCHIVE indices, yet */
+ DefineIndex(stmt->relname, /* relation name */
+ stmt->idxname, /* index name */
+ stmt->accessMethod, /* am name */
+ stmt->indexParams, /* parameters */
+ stmt->withClause,
+ (Expr*)stmt->whereClause,
+ stmt->rangetable);
+ }
+ break;
+
+ case T_RuleStmt:
+ {
+ RuleStmt *stmt = (RuleStmt *)parsetree;
+#ifndef NO_SECURITY
+ relname = stmt->object->relname;
+ if (!pg_aclcheck(relname, userName, ACL_RU))
+ elog(WARN, "%s %s", relname, ACL_NO_PRIV_WARNING);
+#endif
+ commandTag = "CREATE";
+ CHECK_IF_ABORTED();
+ DefineQueryRewrite(stmt);
+ }
+ break;
+
+ case T_ExtendStmt:
+ {
+ ExtendStmt *stmt = (ExtendStmt *)parsetree;
+
+ commandTag = "EXTEND";
+ CHECK_IF_ABORTED();
+
+ ExtendIndex(stmt->idxname, /* index name */
+ (Expr*)stmt->whereClause, /* where */
+ stmt->rangetable);
+ }
+ break;
+
+ case T_RemoveStmt:
+ {
+ RemoveStmt *stmt = (RemoveStmt *)parsetree;
+
+ commandTag = "DROP";
+ CHECK_IF_ABORTED();
+
+ switch(stmt->removeType) {
+ case AGGREGATE:
+ RemoveAggregate(stmt->name);
+ break;
+ case INDEX:
+ relname = stmt->name;
+ if (IsSystemRelationName(relname))
+ elog(WARN, "class \"%s\" is a system catalog index",
+ relname);
+#ifndef NO_SECURITY
+ if (!pg_ownercheck(userName, relname, RELNAME))
+ elog(WARN, "you do not own class \"%s\"",
+ relname);
+#endif
+ RemoveIndex(relname);
+ break;
+ case RULE:
+ {
+ char *rulename = stmt->name;
+#ifndef NO_SECURITY
+
+ relationName = RewriteGetRuleEventRel(rulename);
+ if (!pg_aclcheck(relationName, userName, ACL_RU))
+ elog(WARN, "%s %s", relationName, ACL_NO_PRIV_WARNING);
+#endif
+ RemoveRewriteRule(rulename);
+ }
+ break;
+ case P_TYPE:
+#ifndef NO_SECURITY
+ /* XXX moved to remove.c */
+#endif
+ RemoveType(stmt->name);
+ break;
+ case VIEW:
+ {
+ char *viewName = stmt->name;
+ char *ruleName;
+ extern char *RewriteGetRuleEventRel();
+
+#ifndef NO_SECURITY
+
+ ruleName = MakeRetrieveViewRuleName(viewName);
+ relationName = RewriteGetRuleEventRel(ruleName);
+ if (!pg_ownercheck(userName, relationName, RELNAME))
+ elog(WARN, "%s %s", relationName, ACL_NO_PRIV_WARNING);
+ pfree(ruleName);
+#endif
+ RemoveView(viewName);
+ }
+ break;
+ }
+ break;
+ }
+ break;
+ case T_RemoveFuncStmt:
+ {
+ RemoveFuncStmt *stmt = (RemoveFuncStmt *)parsetree;
+ commandTag = "DROP";
+ CHECK_IF_ABORTED();
+ RemoveFunction(stmt->funcname,
+ length(stmt->args),
+ stmt->args);
+ }
+ break;
+
+ case T_RemoveOperStmt:
+ {
+ RemoveOperStmt *stmt = (RemoveOperStmt *)parsetree;
+ char* type1 = (char*) NULL;
+ char *type2 = (char*) NULL;
+
+ commandTag = "DROP";
+ CHECK_IF_ABORTED();
+
+ if (lfirst(stmt->args)!=NULL)
+ type1 = strVal(lfirst(stmt->args));
+ if (lsecond(stmt->args)!=NULL)
+ type2 = strVal(lsecond(stmt->args));
+ RemoveOperator(stmt->opname, type1, type2);
+ }
+ break;
+
+ case T_VersionStmt:
+ {
+ elog(WARN, "CREATE VERSION is not currently implemented");
+ }
+ break;
+
+ case T_CreatedbStmt:
+ {
+ CreatedbStmt *stmt = (CreatedbStmt *)parsetree;
+
+ commandTag = "CREATEDB";
+ CHECK_IF_ABORTED();
+ createdb(stmt->dbname);
+ }
+ break;
+
+ case T_DestroydbStmt:
+ {
+ DestroydbStmt *stmt = (DestroydbStmt *)parsetree;
+
+ commandTag = "DESTROYDB";
+ CHECK_IF_ABORTED();
+ destroydb(stmt->dbname);
+ }
+ break;
+
+ /* Query-level asynchronous notification */
+ case T_NotifyStmt:
+ {
+ NotifyStmt *stmt = (NotifyStmt *)parsetree;
+
+ commandTag = "NOTIFY";
+ CHECK_IF_ABORTED();
+
+ Async_Notify(stmt->relname);
+ }
+ break;
+
+ case T_ListenStmt:
+ {
+ ListenStmt *stmt = (ListenStmt *)parsetree;
+
+ commandTag = "LISTEN";
+ CHECK_IF_ABORTED();
+
+ Async_Listen(stmt->relname,MasterPid);
+ }
+ break;
+
+ /* ********************************
+ * dynamic loader
+ * ********************************
+ */
+ case T_LoadStmt:
+ {
+ LoadStmt *stmt = (LoadStmt *)parsetree;
+ FILE *fp, *fopen();
+ char *filename;
+
+ commandTag = "LOAD";
+ CHECK_IF_ABORTED();
+
+ filename = stmt->filename;
+ closeAllVfds();
+ if ((fp = fopen(filename, "r")) == NULL)
+ elog(WARN, "LOAD: could not open file %s", filename);
+ fclose(fp);
+ load_file(filename);
+ }
+ break;
+
+ case T_ClusterStmt:
+ {
+ ClusterStmt *stmt = (ClusterStmt *)parsetree;
+
+ commandTag = "CLUSTER";
+ CHECK_IF_ABORTED();
+
+ cluster(stmt->relname, stmt->indexname);
+ }
+ break;
+
+ case T_VacuumStmt:
+ commandTag = "VACUUM";
+ CHECK_IF_ABORTED();
+ vacuum(((VacuumStmt *) parsetree)->vacrel);
+ break;
+
+ case T_ExplainStmt:
+ {
+ ExplainStmt *stmt = (ExplainStmt *)parsetree;
+
+ commandTag = "EXPLAIN";
+ CHECK_IF_ABORTED();
+
+ ExplainQuery(stmt->query, stmt->options, dest);
+ }
+ break;
+
+ /* ********************************
+ Tioga-related statements
+ *********************************/
+ case T_RecipeStmt:
+ {
+ RecipeStmt* stmt = (RecipeStmt*)parsetree;
+ commandTag="EXECUTE RECIPE";
+ CHECK_IF_ABORTED();
+ beginRecipe(stmt);
+ }
+ break;
+
+
+ /* ********************************
+ * default
+ * ********************************
+ */
+ default:
+ elog(WARN, "ProcessUtility: command #%d unsupported",
+ nodeTag(parsetree));
+ break;
+ }
+
+ /* ----------------
+ * tell fe/be or whatever that we're done.
+ * ----------------
+ */
+ EndCommand(commandTag, dest);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * utility.h--
+ * prototypes for utility.c.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: utility.h,v 1.1.1.1 1996/07/09 06:22:00 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef UTILITY_H
+#define UTILITY_H
+
+extern void ProcessUtility(Node *parsetree, CommandDest dest);
+
+#endif /* UTILITY_H */
--- /dev/null
+#include "tioga/Varray.h"
+
+/* Modify the following size macros to suit your need. */
+
+#ifndef Arr_TgString_INITIAL_SIZE
+#define Arr_TgString_INITIAL_SIZE 32
+#endif
+
+#ifndef Arr_TgElementPtr_INITIAL_SIZE
+#define Arr_TgElementPtr_INITIAL_SIZE 32
+#endif
+
+#ifndef Arr_TgNodePtr_INITIAL_SIZE
+#define Arr_TgNodePtr_INITIAL_SIZE 32
+#endif
+/***************************************************************/
+/* Do not modify anything below this line. */
+/***************************************************************/
+
+/* -- Defining types and function for Arr_TgString type -- */
+/* -- the following must be supplied by the user:
+
+ void copyTgString(TgString* from, TgString* to); - make a copy of TgString.
+*/
+
+#ifndef _ARR_TgString_
+#define _ARR_TgString_
+
+#ifndef ARR_TgString_INITIAL_SIZE
+#define ARR_TgString_INITIAL_SIZE 32 /* change this size to suit your need */
+#endif /* ARR_TgString_INITIAL_SIZE */
+
+typedef struct Arr_TgString {
+ size_t num;
+ size_t size;
+ size_t valSize;
+ TgString *val;
+} Arr_TgString;
+
+#define newArr_TgString() \
+ (Arr_TgString *) NewVarray(ARR_TgString_INITIAL_SIZE, sizeof(TgString))
+
+#define enlargeArr_TgString(A, I) \
+ (A)->size += (I); \
+ (A)->val = (TgString *) realloc((A)->val, (A)->valSize * (A)->size)
+
+#define addArr_TgString(A, V) \
+ AppendVarray((Varray *) (A), (void *) (V), (CopyingFunct) copyTgString)
+
+#define deleteArr_TgString(A) FreeVarray(A)
+
+#endif /* _ARR_TgString_ */
+
+/* -- Defining types and function for Arr_TgElementPtr type -- */
+/* -- the following must be supplied by the user:
+
+ void copyTgElementPtr(TgElementPtr* from, TgElementPtr* to); - make a copy of TgElementPtr.
+*/
+
+#ifndef _ARR_TgElementPtr_
+#define _ARR_TgElementPtr_
+
+#ifndef ARR_TgElementPtr_INITIAL_SIZE
+#define ARR_TgElementPtr_INITIAL_SIZE 32 /* change this size to suit your need */
+#endif /* ARR_TgElementPtr_INITIAL_SIZE */
+
+typedef struct Arr_TgElementPtr {
+ size_t num;
+ size_t size;
+ size_t valSize;
+ TgElementPtr *val;
+} Arr_TgElementPtr;
+
+#define newArr_TgElementPtr() \
+ (Arr_TgElementPtr *) NewVarray(ARR_TgElementPtr_INITIAL_SIZE, sizeof(TgElementPtr))
+
+#define enlargeArr_TgElementPtr(A, I) \
+ (A)->size += (I); \
+ (A)->val = (TgElementPtr *) realloc((A)->val, (A)->valSize * (A)->size)
+
+#define addArr_TgElementPtr(A, V) \
+ AppendVarray((Varray *) (A), (void *) (V), (CopyingFunct) copyTgElementPtr)
+
+#define deleteArr_TgElementPtr(A) FreeVarray(A)
+
+#endif /* _ARR_TgElementPtr_ */
+
+/* -- Defining types and function for Arr_TgNodePtr type -- */
+/* -- the following must be supplied by the user:
+
+ void copyTgNodePtr(TgNodePtr* from, TgNodePtr* to); - make a copy of TgNodePtr.
+*/
+
+#ifndef _ARR_TgNodePtr_
+#define _ARR_TgNodePtr_
+
+#ifndef ARR_TgNodePtr_INITIAL_SIZE
+#define ARR_TgNodePtr_INITIAL_SIZE 32 /* change this size to suit your need */
+#endif /* ARR_TgNodePtr_INITIAL_SIZE */
+
+typedef struct Arr_TgNodePtr {
+ size_t num;
+ size_t size;
+ size_t valSize;
+ TgNodePtr *val;
+} Arr_TgNodePtr;
+
+#define newArr_TgNodePtr() \
+ (Arr_TgNodePtr *) NewVarray(ARR_TgNodePtr_INITIAL_SIZE, sizeof(TgNodePtr))
+
+#define enlargeArr_TgNodePtr(A, I) \
+ (A)->size += (I); \
+ (A)->val = (TgNodePtr *) realloc((A)->val, (A)->valSize * (A)->size)
+
+#define addArr_TgNodePtr(A, V) \
+ AppendVarray((Varray *) (A), (void *) (V), (CopyingFunct) copyTgNodePtr)
+
+#define deleteArr_TgNodePtr(A) FreeVarray(A)
+
+#endif /* _ARR_TgNodePtr_ */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for the Tioga module
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/tioga/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:22:00 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+VPATH:= $(VPATH):$(CURDIR)/tioga
+
+SRCS_TIOGA= tgRecipe.c Varray.c
+
+HEADERS+= tgRecipe.h Arr_TgRecipe.h Varray.h
+
+
+
--- /dev/null
+/* ************************************************************************
+ *
+ * Varray.c --
+ *
+ * routines to provide a generic set of functions to handle variable sized
+ * arrays. originally by Jiang Wu
+ * ************************************************************************/
+
+#include
+#include
+#include "Varray.h"
+
+Varray *NewVarray(size_t nobj, size_t size)
+/*
+ * NewVarray -- allocate a Varray to contain an array of val each of which
+ * is size valSize. Returns the Varray if successful,
+ * returns NULL otherwise.
+ */
+{
+ Varray *result;
+
+ if (nobj == 0)
+ nobj = VARRAY_INITIAL_SIZE;
+ result = (Varray *) malloc(sizeof(Varray));
+ result->val = (void *) calloc(nobj, size);
+ if (result == NULL)
+ return NULL;
+ result->size = size;
+ result->nobj = 0;
+ result->maxObj = nobj;
+ return result;
+}
+
+int AppendVarray(Varray *array, void *value, CopyingFunct copy)
+/*
+ * AppendVarray -- append value to the end of array. This function
+ * returns the size of the array after the addition of
+ * the new element.
+ */
+{
+ copy(value, VARRAY_NTH(array->val, array->size, array->nobj));
+ array->nobj++;
+ if (array->nobj >= array->maxObj) {
+ ENLARGE_VARRAY(array, array->maxObj / 2);
+ }
+ return array->nobj;
+}
+
--- /dev/null
+/* ********************************************************************
+ *
+ * Varray.h -- header file for varray.c which provides a generic
+ * set of functions to handle variable sized arrays.
+ *
+ * originally by Jiang Wu
+ * ********************************************************************/
+
+#ifndef _VARRAY_H_
+#define _VARRAY_H_
+
+typedef struct _varray {
+ size_t nobj; /* number of objects in this array */
+ size_t maxObj; /* max. number of objects in this array */
+ size_t size; /* size of each element in the array */
+ void *val; /* array of elements */
+} Varray;
+
+/* type for custom copying function */
+typedef void (*CopyingFunct) (void *from, void *to);
+
+#define VARRAY_INITIAL_SIZE 32
+
+#define ENLARGE_VARRAY(ARRAY, INC) \
+ (ARRAY)->maxObj += (INC); \
+ (ARRAY)->val = (void *) realloc((ARRAY)->val, \
+ (ARRAY)->size * (ARRAY)->maxObj)
+
+#define VARRAY_NTH(VAL, SIZE, N) (((char *) (VAL)) + (SIZE) * (N))
+
+#define FreeVarray(ARRAY) \
+ if ((ARRAY) != NULL) { free((ARRAY)->val); free((ARRAY)); (ARRAY) = NULL ; }
+
+#define ModifyVarray(ARRAY, N, NEW, COPY) \
+ if ((N) < (ARRAY)->nobj) \
+ (COPY)(VARRAY_NTH((ARRAY)->val, (ARRAY)->size, (N)), (NEW))
+
+#define GetVarray(ARRAY, N) \
+ ((N) < (ARRAY)->nobj ? VARRAY_NTH((ARRAY)->val, (ARRAY)->size, (N)) \
+ : NULL)
+
+extern Varray *NewVarray(size_t nobj, size_t size);
+extern int AppendVarray(Varray *array, void *value, CopyingFunct copy);
+
+#endif /* _VARRAY_H_ */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * tgRecipe.c--
+ * Tioga recipe-related definitions
+ * these functions can be used in both the frontend and the
+ * backend
+ *
+ * this file must be kept current with recipe-schema.sql
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/tioga/Attic/tgRecipe.c,v 1.1.1.1 1996/07/09 06:22:00 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include
+#include "tioga/tgRecipe.h"
+
+#include "catalog/catalog.h" /*for newoid() */
+
+static Arr_TgString *TextArray2ArrTgString(char *str);
+
+#define ARRAY_LEFT_DELIM '{'
+#define ARRAY_RIGHT_DELIM '}'
+#define ARRAY_ELEM_LEFT '"'
+#define ARRAY_ELEM_RIGHT '"'
+#define ARRAY_ELEM_SEPARATOR ','
+
+/* maximum length of query string */
+#define MAX_QBUF_LENGTH 2048
+
+/**** the queries being used ********/
+#define Q_RETRIEVE_RECIPE_BYNAME \
+ "select * from Recipes where Recipes.elemName = '%s';"
+#define Q_RETRIEVE_ELEMENTS_IN_RECIPE \
+ "select e.* from Element e, Node n where n.belongsTo = '%s' and n.nodeElem = e.elemName;"
+#define Q_RETRIEVE_NODES_IN_RECIPE \
+ "select * from Node n where n.belongsTo = '%s'"
+#define Q_LOOKUP_EDGES_IN_RECIPE \
+ "select * from Edge e where e.belongsTo = '%s'"
+
+/* static functions only used here */
+static void fillTgElement(TgElement *elem, PortalBuffer *pbuf, int tupno);
+static void fillTgNode(TgRecipe *r, TgNode *node, PortalBuffer *pbuf, int tupno);
+static TgRecipe* fillTgRecipe(PortalBuffer* pbuf, int tupno);
+static void lookupEdges(TgRecipe *r, char* name);
+static void fillAllNodes(TgRecipe *r, char* name);
+static void fillAllElements(TgRecipe *r, char* name);
+static TgNode* connectTee(TgRecipe *r, TgNodePtr fromNode, TgNodePtr toNode,
+ int fromPort, int toPort);
+
+/*
+ * TextArray2ArrTgString -- take a string of the form:
+ * {"fooo", "bar", "xxxxx"} (for postgres)
+ * and parse it into a Array of TgString's
+ *
+ * always returns a valid Arr_TgString. It could be a newly initialized one with
+ * zero elements
+ */
+Arr_TgString*
+TextArray2ArrTgString(char *str)
+{
+ Arr_TgString *result;
+
+ char* beginQuote;
+ char* endQuote;
+ int nextlen;
+ char* word;
+
+ result = newArr_TgString();
+
+ if ((str == NULL) || (str[0] == '\0'))
+ return result;
+
+ if (*str != ARRAY_LEFT_DELIM) {
+ elog(NOTICE,"TextArray2ArrTgString: badly formed string, must have %c as \
+first character\n", ARRAY_LEFT_DELIM);
+ return result;
+ }
+
+ str++; /* skip the first { */
+ while ( *str != '}' ) {
+ if (*str == '\0') {
+ elog(NOTICE,"TextArray2ArrTgString: text string ended prematurely\n");
+ return result;
+ }
+
+ if ((beginQuote = index(str, ARRAY_ELEM_LEFT)) == NULL) {
+ elog(NOTICE,"textArray2ArrTgString: missing a begin quote\n");
+ return result;
+ }
+ if ( (endQuote = index(beginQuote+1,'"')) == NULL) {
+ elog(NOTICE,"textArray2ArrTgString: missing an end quote\n");
+ return result;
+ }
+ nextlen = endQuote - beginQuote; /* don't subtract one here because we
+ need the extra character for \0 anyway */
+ word = (char*) malloc(nextlen);
+ strncpy(word, beginQuote+1, nextlen-1);
+ word[nextlen-1] ='\0';
+ addArr_TgString(result, (TgString*)&word);
+ free (word);
+ str = endQuote + 1;
+ }
+ return result;
+}
+
+/* -------------------------------------
+findElemInRecipe()
+ given an element name, find that element in the TgRecipe structure and return it.
+
+ XXX Currently, this is done by linear search. Change to using a hash table.
+-------------------------------------- */
+
+TgElement*
+findElemInRecipe(TgRecipe *r, char* elemName)
+{
+ int i;
+ Arr_TgElementPtr* arr = r->elements;
+ TgElement* e;
+
+ e = (TgElement*)arr->val[i];
+ if (strcmp(e->elemName, elemName) == 0)
+ return e;
+ }
+ elog (NOTICE, "Element named %s not found in recipe named %s", elemName, r->elmValue.elemName);
+ return NULL;
+}
+
+/* -------------------------------------
+findNodeInRecipe()
+ given an node name, find that node in the TgRecipe structure and return it.
+
+ XXX Currently, this is done by linear search. Change to using a hash table.
+-------------------------------------- */
+
+TgNode*
+findNodeInRecipe(TgRecipe *r, char* nodeName)
+{
+ int i;
+ Arr_TgNodePtr* arr = r->allNodes;
+ TgNode *n;
+
+ n = (TgNode*)arr->val[i];
+ if (strcmp(n->nodeName, nodeName) == 0)
+ return n;
+ }
+ elog (NOTICE, "Node named %s not found in recipe named %s", nodeName, r->elmValue.elemName);
+ return NULL;
+}
+
+
+/* -------------------------------------
+fillTgNode
+ takes a query result in the PortalBuffer containing a Node
+ and converts it to a C Node strcture.
+ The Node structure passed in is 'filled' appropriately
+
+-------------------------------------- */
+
+void
+fillTgNode(TgRecipe* r, TgNode *node, PortalBuffer *pbuf, int tupno)
+{
+ char* nodeType;
+ char* nodeElem;
+ char* locString; /* ascii string rep of the point */
+ static int attnums_initialized = 0;
+ static int nodeName_attnum;
+ static int nodeElem_attnum;
+ static int nodeType_attnum;
+ static int loc_attnum;
+ TgNodePtr BlankNodePtr;
+ int i;
+
+ if (!attnums_initialized) {
+ /* the first time fillTgNode is called,
+ we find out all the relevant attribute numbers in a TgNode
+ so subsequent calls are speeded up,
+ the assumption is that the schema won't change between calls*/
+ nodeName_attnum = PQfnumber(pbuf, tupno, "nodeName");
+ nodeElem_attnum = PQfnumber(pbuf, tupno, "nodeElem");
+ nodeType_attnum = PQfnumber(pbuf, tupno, "nodeType");
+ loc_attnum = PQfnumber(pbuf, tupno, "loc");
+ attnums_initialized = 1;
+ }
+ node->nodeName = PQgetAttr(pbuf, tupno, nodeName_attnum);
+ locString = PQgetvalue(pbuf, tupno, loc_attnum);
+ if (locString == NULL || locString[0] == '\0') {
+ node->loc.x = 0; node->loc.y = 0; /* assign to zero for default */
+ }
+ else
+ {
+ float x,y;
+ sscanf(locString, "(%f, %f)", &x, &y);
+ node->loc.x = x;
+ node->loc.y = y;
+ }
+ nodeElem = PQgetvalue(pbuf, tupno, nodeElem_attnum);
+ node->nodeElem = findElemInRecipe(r,nodeElem);
+ node->inNodes = newArr_TgNodePtr();
+ node->outNodes = newArr_TgNodePtr();
+
+ /* fill the inNodes array with as many NULL's are there are inPorts in
+ * the underlying element */
+ BlankNodePtr = (TgNodePtr)NULL;
+ for (i = 0 ; i < node->nodeElem->inPorts->num ; i++)
+ addArr_TgNodePtr(node->inNodes, &BlankNodePtr);
+
+ /* fill the outNodes array with as many NULL's are there are inPorts in
+ * the underlying element */
+ for (i = 0 ; i < node->nodeElem->outPorts->num ; i++)
+ addArr_TgNodePtr(node->outNodes, &BlankNodePtr);
+
+ nodeType = PQgetvalue(pbuf, tupno, nodeType_attnum);
+
+ if (strcmp(nodeType, "Ingred") == 0)
+ node->nodeType = TG_INGRED_NODE;
+ else if (strcmp(nodeType, "Eye") == 0)
+ node->nodeType = TG_EYE_NODE;
+ else if (strcmp(nodeType, "Recipe") == 0)
+ node->nodeType = TG_RECIPE_NODE;
+ else
+ elog(NOTICE, "fillTgNode: unknown nodeType field value : %s\n", nodeType);
+
+}
+
+/* -------------------------------------
+fillTgElement
+ takes a query result in the PortalBuffer containing a Element
+ and converts it to a C TgElement strcture.
+ The TgElement structure passed in is 'filled' appropriately
+ ------------------------------------ */
+
+void
+fillTgElement(TgElement *elem, PortalBuffer *pbuf, int tupno)
+{
+ char* srcLang, *elemType;
+ static int attnums_initialized = 0;
+ static int elemName_attnum;
+ static int elemType_attnum;
+ static int inPorts_attnum;
+ static int inTypes_attnum;
+ static int outPorts_attnum;
+ static int outTypes_attnum;
+ static int doc_attnum;
+ static int keywords_attnum;
+ static int icon_attnum;
+ static int srcLang_attnum;
+ static int src_attnum;
+ static int owner_attnum;
+
+ if (!attnums_initialized) {
+ /* the first time fillTgElement is called,
+ we find out all the relevant attribute numbers in a TgElement
+ so subsequent calls are speeded up,
+ the assumption is that the schema won't change between calls*/
+ elemName_attnum = PQfnumber(pbuf, tupno, "elemName");
+ elemType_attnum = PQfnumber(pbuf, tupno, "elemType");
+ inPorts_attnum = PQfnumber(pbuf, tupno, "inPorts");
+ inTypes_attnum = PQfnumber(pbuf, tupno, "inTypes");
+ outPorts_attnum = PQfnumber(pbuf, tupno, "outPorts");
+ outTypes_attnum = PQfnumber(pbuf, tupno, "outTypes");
+ doc_attnum = PQfnumber(pbuf, tupno, "doc");
+ keywords_attnum = PQfnumber(pbuf, tupno, "keywords");
+ icon_attnum = PQfnumber(pbuf, tupno, "icon");
+ srcLang_attnum = PQfnumber(pbuf, tupno, "srcLang");
+ src_attnum = PQfnumber(pbuf, tupno, "src");
+ attnums_initialized = 1;
+ }
+
+ elem->elemName = PQgetAttr(pbuf, tupno, elemName_attnum);
+ elem->inPorts = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, inPorts_attnum));
+ elem->inTypes = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, inTypes_attnum));
+ elem->outPorts = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, outPorts_attnum));
+ elem->outTypes = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, outTypes_attnum));
+ elem->doc = PQgetAttr(pbuf, tupno, doc_attnum);
+ elem->keywords = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, keywords_attnum));
+ elem->icon = PQgetAttr(pbuf,tupno, icon_attnum);
+ elem->src = PQgetAttr(pbuf,tupno, src_attnum);
+ elem->owner = PQgetAttr(pbuf,tupno, owner_attnum);
+
+ /* we don't need to keep the value returned so use PQgetvalue()
+ instead of PQgetAttr() */
+ srcLang = PQgetvalue(pbuf,tupno, srcLang_attnum);
+
+ if (strcmp(srcLang, "SQL") == 0)
+ elem->srcLang = TG_SQL;
+ else
+ if (strcmp(srcLang, "C") == 0)
+ elem->srcLang = TG_C;
+ else
+ if (strcmp(srcLang, "RecipeGraph") == 0)
+ elem->srcLang = TG_RECIPE_GRAPH;
+ else
+ if (strcmp(srcLang, "Compiled") == 0)
+ elem->srcLang = TG_COMPILED;
+ else
+ elog(NOTICE, "fillTgElement(): unknown srcLang field value : %s\n", srcLang);
+
+ elemType = PQgetvalue(pbuf, tupno, elemType_attnum);
+ if (strcmp(elemType, "Ingred") == 0)
+ elem->elemType = TG_INGRED;
+ else if (strcmp(elemType, "Eye") == 0)
+ elem->elemType = TG_EYE;
+ else if (strcmp(elemType, "Recipe") == 0)
+ elem->elemType = TG_RECIPE;
+ else
+ elog(NOTICE, "fillTgElement(): unknown elemType field value : %s\n", elemType);
+
+
+}
+/* -------------------------------------
+lookupEdges -
+ look up the edges of a recipe and fill in the inNodes
+ and outNodes of each node.
+ In the process of connecting edges, we detect tee's and create
+ teeNodes. We add the teeNodes to the allNodes field of r as well
+------------------------------------ */
+void
+lookupEdges(TgRecipe *r, char* name)
+{
+ char qbuf[MAX_QBUF_LENGTH];
+ int i;
+ char *pqres;
+ char *pbufname;
+ PortalBuffer *pbuf;
+ int ntups;
+ int fromNode_attnum;
+ int fromPort_attnum;
+ int toPort_attnum;
+ int toNode_attnum;
+ char *toNode, *fromNode;
+ char *toPortStr, *fromPortStr;
+ int toPort, fromPort;
+
+ TgNodePtr fromNodePtr, toNodePtr;
+
+ sprintf(qbuf, Q_LOOKUP_EDGES_IN_RECIPE, name);
+ pqres = PQexec(qbuf);
+ pqres = PQexec(qbuf);
+ if (*pqres == 'R' || *pqres == 'E') {
+ elog(NOTICE, "lookupEdges(): Error while executing query : %s\n", qbuf);
+ elog(NOTICE, "result = %s, error is %s\n", pqres, PQerrormsg);
+ return;
+ }
+ pbufname = ++pqres;
+ pbuf = PQparray(pbufname);
+ ntups = PQntuplesGroup(pbuf,0);
+
+ if (ntups == 0) { return; }
+
+ fromNode_attnum = PQfnumber(pbuf, 0, "fromNode");
+ fromPort_attnum = PQfnumber(pbuf, 0, "fromPort");
+ toNode_attnum = PQfnumber(pbuf, 0, "toNode");
+ toPort_attnum = PQfnumber(pbuf, 0, "toPort");
+
+ for (i=0;i
+
+ fromNode = PQgetvalue(pbuf, i, fromNode_attnum);
+ toNode = PQgetvalue(pbuf, i, toNode_attnum);
+ fromPortStr = PQgetvalue(pbuf, i, fromPort_attnum);
+ toPortStr = PQgetvalue(pbuf, i, toPort_attnum);
+
+ if (!fromPortStr || fromPortStr[0] == '\0') {
+ elog(NOTICE, "lookupEdges(): SANITY CHECK failed. Edge with invalid fromPort value!");
+ return;
+ }
+ if (!toPortStr || toPortStr[0] == '\0') {
+ elog(NOTICE, "lookupEdges(): SANITY CHECK failed. Edge with invalid toPort value!!");
+ return;
+ }
+ fromPort = atoi(fromPortStr);
+ toPort = atoi(toPortStr);
+
+ fromNodePtr = findNodeInRecipe(r, fromNode);
+ if (!fromNodePtr) {
+ elog(NOTICE, "lookupEdges(): SANITY CHECK failed. Edge with bad fromNode value!");
+ return;
+ }
+ toNodePtr = findNodeInRecipe(r, toNode);
+ if (!toNodePtr) {
+ elog(NOTICE, "lookupEdges(): SANITY CHECK failed. Edge with bad toNode value!");
+ return;
+ }
+
+ /* check to see if the from port is already connected.
+ if it is, then this means we should construct a Tee node
+ */
+ if (fromNodePtr->outNodes->val[fromPort-1] != NULL) {
+ TgNodePtr tn;
+
+ tn = connectTee(r,fromNodePtr, toNodePtr, fromPort, toPort);
+ addArr_TgNodePtr(r->allNodes,&tn);
+ } else {
+ fromNodePtr->outNodes->val[fromPort-1] = toNodePtr;
+ toNodePtr->inNodes->val[toPort-1] = fromNodePtr;
+ }
+ }
+
+ PQclear(pbufname);
+}
+
+/*
+ handle tee connections here
+ Everytime an output port is connected multiply,
+ we explicitly insert TgTeeNode
+
+ returns the teeNode created
+*/
+static TgNode*
+connectTee(TgRecipe *r, TgNodePtr fromNode, TgNodePtr toNode,
+ int fromPort, int toPort)
+{
+ TgNodePtr origToNode;
+ TgNodePtr tn;
+ TgNodePtr BlankNodePtr;
+ int origToPort;
+ int i;
+
+ /* the toNode formerly pointed to */
+ origToNode = fromNode->outNodes->val[fromPort-1];
+
+ if (origToNode == NULL) {
+ elog(NOTICE,"Internal Error: connectTee() called with a null origToNode");
+ return;
+ }
+
+ for (i=0;iinNodes->num;i++) {
+ if (origToNode->inNodes->val[i] == fromNode)
+ break;
+ }
+
+ /* the inport of the former toNode */
+ /* ports start with 1, array indices start from 0 */
+ origToPort = i + 1;
+
+ /* add a tee node now. */
+ tn = malloc(sizeof(TgNode));
+ /* generate a name for the tee node table */
+ tn->nodeName = malloc(50);
+ sprintf(tn->nodeName, "tee_%d", newoid());
+/* tn->nodeName = NULL; */
+
+ tn->nodeType = TG_TEE_NODE;
+ tn->nodeElem = NULL;
+ tn->inNodes = newArr_TgNodePtr();
+ tn->outNodes = newArr_TgNodePtr();
+
+ BlankNodePtr = (TgNodePtr)NULL;
+ /* each TgTeeNode has one input and two outputs, NULL them initiallly */
+ addArr_TgNodePtr(tn->inNodes, &BlankNodePtr);
+ addArr_TgNodePtr(tn->outNodes, &BlankNodePtr);
+ addArr_TgNodePtr(tn->outNodes, &BlankNodePtr);
+
+ /* make the old toNode the left parent of the tee node
+ add the new toNode as the right parent of the tee node */
+ tn->outNodes->val[0] = origToNode;
+ origToNode->inNodes->val[origToPort-1] = tn;
+
+ tn->outNodes->val[1] = toNode;
+ toNode->inNodes->val[toPort-1] = tn;
+
+ /* connect the fromNode to the new tee node */
+ fromNode->outNodes->val[fromPort-1] = tn;
+ tn->inNodes->val[0] = fromNode;
+
+ return tn;
+}
+
+/* -------------------------------------
+fillAllNodes
+ fill out the nodes of a recipe
+ ------------------------------------ */
+void
+fillAllNodes(TgRecipe *r, char* name)
+{
+ char qbuf[MAX_QBUF_LENGTH];
+ int i;
+ char *pqres;
+ char *pbufname;
+ PortalBuffer *pbuf;
+ int ntups;
+ TgElement *elem;
+ TgNode *node;
+
+ /* 1) fill out the elements that are in the recipe */
+ sprintf(qbuf, Q_RETRIEVE_ELEMENTS_IN_RECIPE, name);
+ pqres = PQexec(qbuf);
+ if (*pqres == 'R' || *pqres == 'E') {
+ elog(NOTICE, "fillAllNodes(): Error while executing query : %s\n", qbuf);
+ elog(NOTICE, "result = %s, error is %s\n", pqres, PQerrormsg);
+ return;
+ }
+ pbufname = ++pqres;
+ pbuf = PQparray(pbufname);
+ ntups = PQntuplesGroup(pbuf,0);
+ for (i=0;i
+ elem = malloc(sizeof(TgElement));
+ fillTgElement(elem, pbuf, i);
+ addArr_TgElementPtr(r->elements, &elem);
+ }
+ PQclear(pbufname);
+
+ sprintf(qbuf, Q_RETRIEVE_NODES_IN_RECIPE, name);
+ pqres = PQexec(qbuf);
+ if (*pqres == 'R' || *pqres == 'E') {
+ elog(NOTICE, "fillAllNodes(): Error while executing query : %s\n", qbuf);
+ elog(NOTICE, "result = %s, error is %s\n", pqres, PQerrormsg);
+ return;
+ }
+ pbufname = ++pqres;
+ pbuf = PQparray(pbufname);
+ ntups = PQntuplesGroup(pbuf,0);
+ for (i=0;i
+ node = malloc(sizeof(TgNode));
+ fillTgNode(r, node, pbuf, i);
+ addArr_TgNodePtr(r->allNodes, &node);
+ }
+ PQclear(pbufname);
+
+}
+
+
+/* -------------------------------------
+fillAllElements
+ fill out the elements of a recipe
+ ------------------------------------ */
+void
+fillAllElements(TgRecipe *r, char* name)
+{
+ char qbuf[MAX_QBUF_LENGTH];
+ int i;
+ char *pqres;
+ char *pbufname;
+ PortalBuffer *pbuf;
+ int ntups;
+ TgElement *elem;
+
+ sprintf(qbuf, Q_RETRIEVE_ELEMENTS_IN_RECIPE, name);
+ pqres = PQexec(qbuf);
+ if (*pqres == 'R' || *pqres == 'E') {
+ elog(NOTICE, "fillAllElements(): Error while executing query : %s\n", qbuf);
+ elog(NOTICE, "result = %s, error is %s\n", pqres, PQerrormsg);
+ return;
+ }
+ pbufname = ++pqres;
+ pbuf = PQparray(pbufname);
+ ntups = PQntuplesGroup(pbuf,0);
+ for (i=0;i
+ elem = malloc(sizeof(TgElement));
+ fillTgElement(elem, pbuf, i);
+ addArr_TgElementPtr(r->elements, &elem);
+ }
+ PQclear(pbufname);
+
+}
+
+
+/* -------------------------------------
+fillTgRecipe
+ takes a query result in the PortalBuffer containing a Recipe
+ and converts it to a C TgRecipe strcture
+ ------------------------------------ */
+TgRecipe*
+fillTgRecipe(PortalBuffer* pbuf, int tupno)
+{
+ TgRecipe* r;
+ int i,j;
+
+ /* 1) set up the recipe structure */
+ r = (TgRecipe*)malloc(sizeof(TgRecipe));
+ fillTgElement(&r->elmValue, pbuf, 0);
+ r->elmValue.elemType = TG_RECIPE;
+ r->allNodes = newArr_TgNodePtr();
+ r->rootNodes = newArr_TgNodePtr();
+ r->eyes = newArr_TgNodePtr();
+ r->tees = newArr_TgNodePtr();
+ r->elements = newArr_TgElementPtr();
+
+ /* 2) find all the elements. There may be less elements than nodes
+ because you can have multiple instantiations of an element
+ in a recipe*/
+ fillAllElements(r, r->elmValue.elemName);
+
+ /* 3) find all the nodes in the recipe*/
+ fillAllNodes(r, r->elmValue.elemName);
+
+ /* 4) find all the edges, and connect the nodes,
+ may also add tee nodes to the allNodes field*/
+ lookupEdges(r, r->elmValue.elemName);
+
+ /* 5) find all the rootNodes in the recipe */
+ /* root nodes are nodes with no incoming nodes or
+ whose incoming nodes are all null */
+ /* 6) find all the eyes in the recipe */
+ /* eye nodes are nodes with the node type TG_EYE_NODE */
+ /* 7) find all the tee nodes in the recipe */
+ /* tee nodes are nodes with the node type TG_TEE_NODE */
+ for (i=0;iallNodes->num;i++) {
+ TgNode* nptr = r->allNodes->val[i];
+
+ if (nptr->nodeType == TG_EYE_NODE)
+ addArr_TgNodePtr(r->eyes, &nptr);
+ else
+ if (nptr->nodeType == TG_TEE_NODE)
+ addArr_TgNodePtr(r->tees, &nptr);
+
+ if (nptr->inNodes->num == 0)
+ addArr_TgNodePtr(r->rootNodes, &nptr);
+ else {
+ for (j=0;
+ jinNodes->num && (nptr->inNodes->val[j] == NULL);
+ j++);
+ if (j == nptr->inNodes->num)
+ addArr_TgNodePtr(r->rootNodes, &nptr);
+ }
+ }
+
+ return r;
+
+}
+
+
+/* -------------------------------------
+retrieveRecipe
+ find the recipe with the given name
+ ------------------------------------ */
+TgRecipe*
+retrieveRecipe(char* name)
+{
+ char qbuf[MAX_QBUF_LENGTH];
+ TgRecipe* recipe;
+ char *pqres;
+ char *pbufname;
+ PortalBuffer *pbuf;
+ int ntups;
+
+ sprintf(qbuf, Q_RETRIEVE_RECIPE_BYNAME, name);
+
+ pqres = PQexec(qbuf);
+ if (*pqres == 'R' || *pqres == 'E') {
+ elog(NOTICE, "retrieveRecipe: Error while executing query : %s\n", qbuf);
+ elog(NOTICE, "result = %s, error is %s\n", pqres, PQerrormsg);
+ return NULL;
+ }
+ pbufname = ++pqres;
+ pbuf = PQparray(pbufname);
+ ntups = PQntuplesGroup(pbuf,0);
+ if (ntups == 0) {
+ elog(NOTICE, "retrieveRecipe(): No recipe named %s exists\n", name);
+ return NULL;
+ }
+ if (ntups != 1) {
+ elog(NOTICE, "retrieveRecipe(): Multiple (%d) recipes named %s exists\n", ntups, name);
+ return NULL;
+ }
+
+ recipe = fillTgRecipe(pbuf,0);
+
+ PQclear(pbufname);
+ return recipe;
+
+}
+
+/* -------------------- copyXXX functions ----------------------- */
+void copyTgElementPtr(TgElementPtr* from, TgElementPtr* to)
+{
+ *to = *from;
+}
+
+void copyTgNodePtr(TgNodePtr* from, TgNodePtr* to)
+{
+ *to = *from;
+}
+
+void copyTgRecipePtr(TgRecipePtr* from, TgRecipePtr* to)
+{
+ *to = *from;
+}
+
+void copyTgString(TgString* from, TgString* to)
+{
+ TgString fromTgString = *from;
+ TgString toTgString;
+ toTgString = (TgString)malloc(strlen(fromTgString)+1);
+ strcpy(toTgString, fromTgString);
+ *to = toTgString;
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * tgRecipe.h--
+ * Tioga recipe-related definitions and declarations
+ * these functions can be used in both the frontend and the
+ * backend
+ *
+ * to use this header, you must also include
+ * "utils/geo-decls.h"
+ * and "libpq/libpq.h"
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: tgRecipe.h,v 1.1.1.1 1996/07/09 06:22:00 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "libpq/libpq.h"
+#ifndef TIOGA_FRONTEND
+#include "libpq/libpq-be.h"
+#include "utils/elog.h"
+#include "utils/geo-decls.h"
+#else
+#include "libpq-fe.h"
+typedef struct {
+ double x, y;
+} Point; /* this should match whatever is in geo-decls.h*/
+#endif /* TIOGA_FRONTEND */
+
+typedef enum {TG_INGRED,
+ TG_EYE,
+ TG_RECIPE} TgElemType;
+
+typedef enum { TG_SQL,
+ TG_C,
+ TG_RECIPE_GRAPH,
+ TG_COMPILED
+ } TgSrcLangType;
+
+typedef enum { TG_INGRED_NODE,
+ TG_EYE_NODE,
+ TG_RECIPE_NODE,
+ TG_TEE_NODE /* tee nodes are not stored in the db
+ we create them when we read the recipe
+ back */
+ } TgNodeType;
+
+/* -- type definition for setting up in memory Tioga recipe structure -- */
+/* -- see 'recipe-schema.sql' for their corresponding database types -- */
+
+typedef char *TgString;
+
+typedef struct _tgelement *TgElementPtr;
+typedef struct _tgnode *TgNodePtr;
+typedef struct _tgrecipe *TgRecipePtr;
+
+/* auto-generated header containing Arr_TgString, Arr_TgElementPtr,
+ and Arr_TgNodePtr */
+#include "tioga/Arr_TgRecipe.h"
+
+/* C structure representation of a Tioga Element */
+typedef struct _tgelement {
+ char *elemName; /* name of function this element represent */
+ TgElemType elemType; /* type of this element */
+ Arr_TgString *inPorts; /* names of inputs */
+ Arr_TgString *inTypes; /* name of input types */
+ Arr_TgString *outPorts; /* type of output */
+ Arr_TgString *outTypes; /* name of output types */
+ char *doc; /* description of this element */
+ Arr_TgString *keywords; /* keywords used to search for this element */
+ char *icon; /* iconic representation */
+ char *src; /* source code for this element */
+ TgSrcLangType srcLang; /* source language */
+ char *owner; /* owner recipe name */
+} TgElement;
+
+
+/* C structure representation of a Tioga Node */
+typedef struct _tgnode {
+ char *nodeName; /* name of this node */
+ TgNodeType nodeType; /* type of this node */
+ Point loc; /* screen location of the node. */
+ TgElement *nodeElem; /* the underlying element of this node */
+ Arr_TgNodePtr *inNodes; /* variable array of in node pointers
+ * a NULL TgNodePtr indicates a run-time
+ * parameter*/
+ Arr_TgNodePtr *outNodes; /* variable array of out node pointers. */
+} TgNode;
+
+/* C structure representation of a Tioga Recipe */
+typedef struct _tgrecipe {
+ TgElement elmValue; /* "inherits" TgElement attributes. */
+ Arr_TgNodePtr *allNodes; /* array of all nodes for this recipe. */
+ Arr_TgNodePtr *rootNodes; /* array of root nodes for this recipe. --
+ root nodes are nodes with no parents */
+ Arr_TgNodePtr *eyes; /* array of pointers for the browser nodes
+ * recipe, execution of recipe starts
+ * by traversing the recipe C structure
+ * from the eye nodes pointed by these
+ * pointers. */
+ Arr_TgNodePtr *tees; /* array of pointers of all the tee nodes */
+ Arr_TgElementPtr *elements; /* array of all the elements in this recipe,
+ * elements may be shared by multiple nodes */
+
+} TgRecipe;
+
+/* functions defined in tgRecipe.c */
+extern TgRecipe* retrieveRecipe(char* name);
+extern TgElement* findElemInRecipe(TgRecipe *r, char* elemName);
+extern TgNode* findNodeInRecipe(TgRecipe *r, char* nodeName);
+
+/* ---- copyXXX functions ---- */
+extern void copyTgElementPtr(TgElementPtr *, TgElementPtr *);
+extern void copyTgNodePtr(TgNodePtr *, TgNodePtr *);
+extern void copyTgRecipePtr(TgRecipePtr *, TgRecipePtr *);
+extern void copyTgString(TgString *, TgString *);
+
+
+
+
--- /dev/null
+#!/bin/sh
+#-------------------------------------------------------------------------
+#
+# Gen_fmgrtab.sh--
+# shell script to generate fmgr.h and fmgrtab.c from pg_proc.h
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/utils/Attic/Gen_fmgrtab.sh,v 1.1.1.1 1996/07/09 06:22:00 scrappy Exp $
+#
+# NOTES
+# Passes any -D options on to cpp prior to generating the list
+# of internal functions. These come from BKIOPTS.
+#
+#-------------------------------------------------------------------------
+
+# cpp is usually in one of these places...
+PATH=/usr/lib:/lib:/usr/ccs/lib:$PATH
+
+BKIOPTS=''
+if [ $? != 0 ]
+then
+ echo `basename $0`: Bad option
+ exit 1
+fi
+
+#
+# Pass on any -D declarations, throwing away any other command
+# line switches.
+#
+for opt in $*
+do
+ case $opt in
+ -D) BKIOPTS="$BKIOPTS -D$2"; shift; shift;;
+ -D*) BKIOPTS="$BKIOPTS $1";shift;;
+ --) shift; break;;
+ -*) shift;;
+ esac
+done
+
+INFILE=$1
+RAWFILE=fmgr.raw
+HFILE=fmgr.h
+TABCFILE=fmgrtab.c
+
+#
+# Generate the file containing raw pg_proc tuple data
+# (but only for "internal" language procedures...).
+#
+# Unlike genbki.sh, which can run through cpp last, we have to
+# deal with preprocessor statements first (before we sort the
+# function table by oid).
+#
+awk '
+BEGIN { raw = 0; }
+/^DATA/ { print; next; }
+/^BKI_BEGIN/ { raw = 1; next; }
+/^BKI_END/ { raw = 0; next; }
+raw == 1 { print; next; }' $INFILE | \
+sed -e 's/^.*OID[^=]*=[^0-9]*//' \
+ -e 's/(//g' \
+ -e 's/[ ]*).*$//' | \
+awk '
+/^#/ { print; next; }
+$4 == "11" { print; next; }' | \
+cpp $BKIOPTS | \
+egrep '^[0-9]' | \
+sort -n > $RAWFILE
+
+#
+# Generate fmgr.h
+#
+cat > $HFILE <
+/*-------------------------------------------------------------------------
+ *
+ * $HFILE--
+ * Definitions for using internal procedures.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: Gen_fmgrtab.sh,v 1.1.1.1 1996/07/09 06:22:00 scrappy Exp $
+ *
+ * NOTES
+ * ******************************
+ * *** DO NOT EDIT THIS FILE! ***
+ * ******************************
+ *
+ * It has been GENERATED by $0
+ * from $1
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef FMGR_H
+#define FMGR_H
+
+#include "postgres.h" /* for some prototype typedefs */
+
+/*
+ * Maximum number of arguments for a built-in function.
+ *
+ * XXX note that you cannot call a function with more than 8
+ * arguments from the user level since the catalogs only
+ * store 8 argument type values for type-checking ...
+ */
+#define MAXFMGRARGS 9
+
+typedef struct {
+ char *data[MAXFMGRARGS];
+} FmgrValues;
+
+/*
+ * defined in fmgr.c
+ */
+extern char *fmgr_c(func_ptr user_fn, Oid func_id, int n_arguments,
+ FmgrValues *values, bool *isNull);
+extern void fmgr_info(Oid procedureId, func_ptr *function, int *nargs);
+extern char *fmgr(Oid procedureId, ... );
+extern char *fmgr_ptr(func_ptr user_fn, Oid func_id, ... );
+extern char *fmgr_array_args(Oid procedureId, int nargs,
+ char *args[], bool *isNull);
+
+/*
+ * defined in dfmgr.c
+ */
+extern func_ptr fmgr_dynamic(Oid procedureId, int *pronargs);
+extern void load_file(char *filename);
+
+
+/*
+ * For performance reasons, we often want to simply jump through a
+ * a function pointer (if it's valid, that is). These calls have
+ * been macroized so we can run them through a routine that does
+ * sanity-checking (and so we can track them down more easily when
+ * we must).
+ */
+#ifdef TRACE_FMGR_PTR
+#define FMGR_PTR2(FP, FID, ARG1, ARG2) \
+ fmgr_ptr(FP, FID, 2, ARG1, ARG2)
+#else
+#define FMGR_PTR2(FP, FID, ARG1, ARG2) \
+ ((FP) ? (*((func_ptr)(FP)))(ARG1, ARG2) : fmgr(FID, ARG1, ARG2))
+#endif
+
+/*
+ * Flags for the builtin oprrest selectivity routines.
+ */
+#define SEL_CONSTANT 1 /* constant does not vary (not a parameter) */
+#define SEL_RIGHT 2 /* constant appears to right of operator */
+
+FuNkYfMgRsTuFf
+awk '{ print $2, $1; }' $RAWFILE | \
+tr '[a-z]' '[A-Z]' | \
+sed -e 's/^/#define F_/' >> $HFILE
+cat >> $HFILE <
+
+#endif /* FMGR_H */
+FuNkYfMgRsTuFf
+
+#
+# Generate fmgr function table file.
+#
+# Print out the bogus function declarations, then the table that
+# refers to them.
+#
+cat > $TABCFILE <
+/*-------------------------------------------------------------------------
+ *
+ * $TABCFILE--
+ * The function manager's table of internal functions.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/Attic/Gen_fmgrtab.sh,v 1.1.1.1 1996/07/09 06:22:00 scrappy Exp $
+ *
+ * NOTES
+ *
+ * ******************************
+ * *** DO NOT EDIT THIS FILE! ***
+ * ******************************
+ *
+ * It has been GENERATED by $0
+ * from $1
+ *
+ * We lie here to cc about the return type and arguments of the
+ * builtin functions; all ld cares about is the fact that it
+ * will need to resolve an external function reference.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifdef WIN32
+#include
+#else
+# if defined(PORTNAME_BSD44_derived) || defined(PORTNAME_bsdi)
+# include
+# define MAXINT INT_MAX
+# else
+# include /* for MAXINT */
+# endif /* PORTNAME_BSD44_derived || PORTNAME_bsdi */
+#endif /* WIN32 */
+
+#include "utils/fmgrtab.h"
+
+FuNkYfMgRtAbStUfF
+awk '{ print "extern char *" $2 "();"; }' $RAWFILE >> $TABCFILE
+cat >> $TABCFILE <
+
+static FmgrCall fmgr_builtins[] = {
+FuNkYfMgRtAbStUfF
+awk '{ printf (" {%d , %d , %s, \"%s\" },\n"), $1, $8, $2, $2 }' $RAWFILE >> $TABCFILE
+cat >> $TABCFILE <
+ /* guardian value */
+#ifndef WIN32
+ { MAXINT, 0, (func_ptr) NULL }
+#else
+ { INT_MAX, 0, (func_ptr) NULL }
+#endif /* WIN32 */
+};
+
+static int fmgr_nbuiltins = (sizeof(fmgr_builtins) / sizeof(FmgrCall)) - 1;
+
+FmgrCall *fmgr_isbuiltin(Oid id)
+{
+ register int i;
+ int low = 0;
+ int high = fmgr_nbuiltins;
+
+ low = 0;
+ high = fmgr_nbuiltins;
+ while (low <= high) {
+ i = low + (high - low) / 2;
+ if (id == fmgr_builtins[i].proid)
+ break;
+ else if (id > fmgr_builtins[i].proid)
+ low = i + 1;
+ else
+ high = i - 1;
+ }
+ if (id == fmgr_builtins[i].proid)
+ return(&fmgr_builtins[i]);
+ return((FmgrCall *) NULL);
+}
+
+func_ptr fmgr_lookupByName(char *name)
+{
+ int i;
+ for (i=0;i
+ if (strcmp(name,fmgr_builtins[i].funcName) == 0)
+ return(fmgr_builtins[i].func);
+ }
+ return((func_ptr) NULL);
+}
+
+FuNkYfMgRtAbStUfF
+
+rm -f $RAWFILE
+
+# ----------------
+# all done
+# ----------------
+exit 0
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for the utilities modules
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/utils/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:22:01 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+utilsdir= $(CURDIR)/utils
+VPATH:= $(VPATH):$(utilsdir):\
+ $(utilsdir)/adt:$(utilsdir)/cache:$(utilsdir)/error:$(utilsdir)/fmgr:\
+ $(utilsdir)/hash:$(utilsdir)/init:$(utilsdir)/mmgr:$(utilsdir)/sort:\
+ $(utilsdir)/time
+
+SUBSRCS=
+include $(utilsdir)/adt/Makefile.inc
+include $(utilsdir)/cache/Makefile.inc
+include $(utilsdir)/error/Makefile.inc
+include $(utilsdir)/fmgr/Makefile.inc
+include $(utilsdir)/hash/Makefile.inc
+include $(utilsdir)/init/Makefile.inc
+include $(utilsdir)/mmgr/Makefile.inc
+include $(utilsdir)/sort/Makefile.inc
+include $(utilsdir)/time/Makefile.inc
+SRCS_UTILS:= $(SUBSRCS) fmgrtab.c
+
+GENFMGRTAB= $(utilsdir)/Gen_fmgrtab.sh
+#GENFMGRTABFILES= fmgr.h fmgrtab.c
+GENFMGRTABFILES= fmgrtab.c
+
+#
+# BKIOPTS is set in ../catalog/Makefile.inc and sets the -D flags for
+# the DATA(...); statements. Hence, ../catalog/Makefile.inc had better
+# get slurped in prior to this Makefile.inc, or BKIOPTS should be set
+# in a higher directory level.
+#
+$(GENFMGRTABFILES): $(GENFMGRTAB) $(catdir)/pg_proc.h
+ cd $(objdir); \
+ sh $(SHOPTS) $(GENFMGRTAB) $(BKIOPTS) $(catdir)/pg_proc.h
+
+$(objdir)/fmgrtab.o: fmgrtab.c
+ $(cc_inobjdir)
+
+POSTGRES_DEPEND+= ${GENFMGRTABFILES}
+
+#
+#${PROG}: ${GENFMGRTABFILES}
+#
+
+CLEANFILES+= $(GENFMGRTABFILES)
+
+HEADERS+= acl.h array.h bit.h builtins.h catcache.h datum.h \
+ dynamic_loader.h elog.h exc.h excid.h fcache.h fmgrtab.h \
+ geo-decls.h hsearch.h inval.h lselect.h lsyscache.h mcxt.h \
+ memutils.h module.h nabstime.h oidcompos.h palloc.h \
+ portal.h psort.h rel.h rel2.h relcache.h sets.h \
+ syscache.h tqual.h
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * acl.h--
+ * Definition of (and support for) access control list data structures.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: acl.h,v 1.1.1.1 1996/07/09 06:22:01 scrappy Exp $
+ *
+ * NOTES
+ * For backward-compatability purposes we have to allow there
+ * to be a null ACL in a pg_class tuple. This will be defined as
+ * meaning "no protection" (i.e., old catalogs get old semantics).
+ *
+ * The AclItems in an ACL array are currently kept in sorted order.
+ * Things will break hard if you change that without changing the
+ * code wherever this is included.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ACL_H
+#define ACL_H
+
+#include "postgres.h"
+#include "utils/array.h"
+#include "nodes/parsenodes.h" /* for ChangeACLStmt */
+
+/*
+ * AclId system identifier for the user, group, etc.
+ * XXX currently UNIX uid for users...
+ */
+typedef uint32 AclId;
+#define ACL_ID_WORLD 0 /* XXX only idtype should be checked */
+
+/*
+ * AclIdType tag that describes if the AclId is a user, group, etc.
+ */
+typedef uint8 AclIdType;
+#define ACL_IDTYPE_WORLD 0x00
+#define ACL_IDTYPE_UID 0x01 /* user id - from pg_user */
+#define ACL_IDTYPE_GID 0x02 /* group id - from pg_group */
+
+/*
+ * AclMode the actual permissions
+ * XXX should probably use bit.h routines.
+ * XXX should probably also stuff the modechg cruft in the
+ * high bits, too.
+ */
+typedef uint8 AclMode;
+#define ACL_NO 0 /* no permissions */
+#define ACL_AP (1<<0) /* append */
+#define ACL_RD (1<<1) /* read */
+#define ACL_WR (1<<2) /* write (append/delete/replace) */
+#define ACL_RU (1<<3) /* place rules */
+#define N_ACL_MODES 4
+
+#define ACL_MODECHG_ADD 1
+#define ACL_MODECHG_DEL 2
+#define ACL_MODECHG_EQL 3
+
+/* change this line if you want to set the default acl permission */
+#define ACL_WORLD_DEFAULT (ACL_RD)
+/* #define ACL_WORLD_DEFAULT (ACL_RD|ACL_WR|ACL_AP|ACL_RU) */
+#define ACL_OWNER_DEFAULT (ACL_RD|ACL_WR|ACL_AP|ACL_RU)
+
+/*
+ * AclItem
+ */
+typedef struct AclItem {
+ AclId ai_id;
+ AclIdType ai_idtype;
+ AclMode ai_mode;
+} AclItem;
+/* Note: if the size of AclItem changes,
+ change the aclitem typlen in pg_type.h */
+
+/*
+ * The value of the first dimension-array element. Since these arrays
+ * always have a lower-bound of 0, this is the same as the number of
+ * elements in the array.
+ */
+#define ARR_DIM0(a) (((unsigned *) (((char *) a) + sizeof(ArrayType)))[0])
+
+/*
+ * Acl a one-dimensional POSTGRES array of AclItem
+ */
+typedef ArrayType Acl;
+#define ACL_NUM(ACL) ARR_DIM0(ACL)
+#define ACL_DAT(ACL) ((AclItem *) ARR_DATA_PTR(ACL))
+#define ACL_N_SIZE(N) \
+ ((unsigned) (ARR_OVERHEAD(1) + ((N) * sizeof(AclItem))))
+#define ACL_SIZE(ACL) ARR_SIZE(ACL)
+
+/*
+ * IdList a one-dimensional POSTGRES array of AclId
+ */
+typedef ArrayType IdList;
+#define IDLIST_NUM(IDL) ARR_DIM0(IDL)
+#define IDLIST_DAT(IDL) ((AclId *) ARR_DATA_PTR(IDL))
+#define IDLIST_N_SIZE(N) \
+ ((unsigned) (ARR_OVERHEAD(1) + ((N) * sizeof(AclId))))
+#define IDLIST_SIZE(IDL) ARR_SIZE(IDL)
+
+#define ACL_MODECHG_STR "+-=" /* list of valid characters */
+#define ACL_MODECHG_ADD_CHR '+'
+#define ACL_MODECHG_DEL_CHR '-'
+#define ACL_MODECHG_EQL_CHR '='
+#define ACL_MODE_STR "arwR" /* list of valid characters */
+#define ACL_MODE_AP_CHR 'a'
+#define ACL_MODE_RD_CHR 'r'
+#define ACL_MODE_WR_CHR 'w'
+#define ACL_MODE_RU_CHR 'R'
+
+/* we use this warning string both for non-existent tables and
+ insufficient privilege so non-privileged users cannot ascertain whether
+ the class exists or not */
+#define ACL_NO_PRIV_WARNING "Either no such class or insufficient privilege"
+
+/*
+ * Enable ACL execution tracing and table dumps
+ */
+/*#define ACLDEBUG_TRACE*/
+
+/*
+ * routines used internally (parser, etc.)
+ */
+extern char *aclparse(char *s, AclItem *aip, unsigned *modechg);
+extern Acl *aclownerdefault(AclId ownerid);
+extern Acl *acldefault();
+extern Acl *aclinsert3(Acl *old_acl, AclItem *mod_aip, unsigned modechg);
+
+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,
+ char grant_or_revoke);
+
+/*
+ * exported routines (from acl.c)
+ */
+extern Acl *makeacl(int n);
+extern AclItem *aclitemin(char *s);
+extern char *aclitemout(AclItem *aip);
+extern Acl *aclinsert(Acl *old_acl, AclItem *mod_aip);
+extern Acl *aclremove(Acl *old_acl, AclItem *mod_aip);
+extern int32 aclcontains(Acl *acl, AclItem *aip);
+
+/*
+ * prototypes for functions in aclchk.c
+ */
+extern void ChangeAcl(char *relname, AclItem *mod_aip, unsigned modechg);
+extern AclId get_grosysid(char *groname);
+extern char *get_groname(AclId grosysid);
+extern int32 aclcheck(Acl *acl, AclId id, AclIdType idtype, AclMode mode);
+
+/* XXX move these elsewhere -pma */
+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,
+ int nargs, Oid *arglist);
+
+#endif /* ACL_H */
+
--- /dev/null
+
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for utils/adt
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= acl.c arrayfuncs.c arrayutils.c bool.c char.c chunk.c date.c \
+ datum.c dt.c filename.c float.c geo-ops.c geo-selfuncs.c int.c \
+ misc.c nabstime.c name.c not_in.c numutils.c oid.c \
+ oidname.c oidint2.c oidint4.c regexp.c regproc.c selfuncs.c \
+ tid.c varchar.c varlena.c sets.c datetimes.c like.c
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * acl.c--
+ * Basic access control list data structures manipulation routines.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include "postgres.h"
+#include "c.h"
+#include "utils/acl.h"
+#include "access/htup.h"
+#include "catalog/pg_user.h"
+#include "utils/syscache.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+static char *getid(char *s, char *n);
+static int32 aclitemeq(AclItem *a1, AclItem *a2);
+static int32 aclitemgt(AclItem *a1, AclItem *a2);
+
+#define ACL_IDTYPE_GID_KEYWORD "group"
+#define ACL_IDTYPE_UID_KEYWORD "user"
+
+
+/*
+ * getid
+ * Consumes the first alphanumeric string (identifier) found in string
+ * 's', ignoring any leading white space.
+ *
+ * RETURNS:
+ * the string position in 's' that points to the next non-space character
+ * in 's'. Also:
+ * - loads the identifier into 'name'. (If no identifier is found, 'name'
+ * contains an empty string).
+ */
+static char *
+getid(char *s, char *n)
+{
+ unsigned len;
+ char *id;
+
+ Assert(s && n);
+
+ while (isspace(*s))
+ ++s;
+ for (id = s, len = 0; isalnum(*s); ++len, ++s)
+ ;
+ if (len > sizeof(NameData))
+ elog(WARN, "getid: identifier cannot be >%d characters",
+ sizeof(NameData));
+ if (len > 0)
+ memmove(n, id, len);
+ n[len] = '\0';
+ while (isspace(*s))
+ ++s;
+ return(s);
+}
+
+/*
+ * aclparse
+ * Consumes and parses an ACL specification of the form:
+ * [group|user] [A-Za-z0-9]*[+-=][rwaR]*
+ * from string 's', ignoring any leading white space or white space
+ * between the optional id type keyword (group|user) and the actual
+ * ACL specification.
+ *
+ * This routine is called by the parser as well as aclitemin(), hence
+ * the added generality.
+ *
+ * RETURNS:
+ * the string position in 's' immediately following the ACL
+ * specification. Also:
+ * - loads the structure pointed to by 'aip' with the appropriate
+ * UID/GID, id type identifier and mode type values.
+ * - loads 'modechg' with the mode change flag.
+ */
+char *
+aclparse(char *s, AclItem *aip, unsigned *modechg)
+{
+ HeapTuple htp;
+ char name[NAMEDATALEN+1];
+ extern AclId get_grosysid();
+
+ Assert(s && aip && modechg);
+
+ aip->ai_idtype = ACL_IDTYPE_UID;
+ s = getid(s, name);
+ if (*s != ACL_MODECHG_ADD_CHR &&
+ *s != ACL_MODECHG_DEL_CHR &&
+ *s != ACL_MODECHG_EQL_CHR)
+ { /* we just read a keyword, not a name */
+ if (!strcmp(name, ACL_IDTYPE_GID_KEYWORD)) {
+ aip->ai_idtype = ACL_IDTYPE_GID;
+ } else if (strcmp(name, ACL_IDTYPE_UID_KEYWORD)) {
+ elog(WARN, "aclparse: bad keyword, must be [group|user]");
+ }
+ s = getid(s, name); /* move s to the name beyond the keyword */
+ if (name[0] == '\0')
+ elog(WARN, "aclparse: a name must follow the [group|user] keyword");
+ }
+ if (name[0] == '\0')
+ aip->ai_idtype = ACL_IDTYPE_WORLD;
+
+ switch (*s) {
+ case ACL_MODECHG_ADD_CHR: *modechg = ACL_MODECHG_ADD; break;
+ case ACL_MODECHG_DEL_CHR: *modechg = ACL_MODECHG_DEL; break;
+ case ACL_MODECHG_EQL_CHR: *modechg = ACL_MODECHG_EQL; break;
+ default: elog(WARN, "aclparse: mode change flag must use \"%s\"",
+ ACL_MODECHG_STR);
+ }
+
+ aip->ai_mode = ACL_NO;
+ while (isalpha(*++s)) {
+ switch (*s) {
+ case ACL_MODE_AP_CHR: aip->ai_mode |= ACL_AP; break;
+ case ACL_MODE_RD_CHR: aip->ai_mode |= ACL_RD; break;
+ case ACL_MODE_WR_CHR: aip->ai_mode |= ACL_WR; break;
+ case ACL_MODE_RU_CHR: aip->ai_mode |= ACL_RU; break;
+ default: elog(WARN, "aclparse: mode flags must use \"%s\"",
+ ACL_MODE_STR);
+ }
+ }
+
+ switch (aip->ai_idtype) {
+ case ACL_IDTYPE_UID:
+ htp = SearchSysCacheTuple(USENAME, PointerGetDatum(name),
+ 0,0,0);
+ if (!HeapTupleIsValid(htp))
+ elog(WARN, "aclparse: non-existent user \"%s\"", name);
+ aip->ai_id = ((Form_pg_user) GETSTRUCT(htp))->usesysid;
+ break;
+ case ACL_IDTYPE_GID:
+ aip->ai_id = get_grosysid(name);
+ break;
+ case ACL_IDTYPE_WORLD:
+ aip->ai_id = ACL_ID_WORLD;
+ break;
+ }
+
+#ifdef ACLDEBUG_TRACE
+ elog(DEBUG, "aclparse: correctly read [%x %d %x], modechg=%x",
+ aip->ai_idtype, aip->ai_id, aip->ai_mode, *modechg);
+#endif
+ return(s);
+}
+
+/*
+ * makeacl
+ * Allocates storage for a new Acl with 'n' entries.
+ *
+ * RETURNS:
+ * the new Acl
+ */
+Acl *
+makeacl(int n)
+{
+ Acl *new_acl;
+ Size size;
+
+ if (n < 0)
+ elog(WARN, "makeacl: invalid size: %d\n", n);
+ size = ACL_N_SIZE(n);
+ if (!(new_acl = (Acl *) palloc(size)))
+ elog(WARN, "makeacl: palloc failed on %d\n", size);
+ memset((char *) new_acl, 0, size);
+ new_acl->size = size;
+ new_acl->ndim = 1;
+ new_acl->flags = 0;
+ ARR_LBOUND(new_acl)[0] = 0;
+ ARR_DIMS(new_acl)[0] = n;
+ return(new_acl);
+}
+
+/*
+ * aclitemin
+ * Allocates storage for, and fills in, a new AclItem given a string
+ * 's' that contains an ACL specification. See aclparse for details.
+ *
+ * RETURNS:
+ * the new AclItem
+ */
+AclItem *
+aclitemin(char *s)
+{
+ unsigned modechg;
+ AclItem *aip;
+
+ if (!s)
+ elog(WARN, "aclitemin: null string");
+
+ aip = (AclItem *) palloc(sizeof(AclItem));
+ if (!aip)
+ elog(WARN, "aclitemin: palloc failed");
+ s = aclparse(s, aip, &modechg);
+ if (modechg != ACL_MODECHG_EQL)
+ elog(WARN, "aclitemin: cannot accept anything but = ACLs");
+ while (isspace(*s))
+ ++s;
+ if (*s)
+ elog(WARN, "aclitemin: extra garbage at end of specification");
+ return(aip);
+}
+
+/*
+ * aclitemout
+ * Allocates storage for, and fills in, a new null-delimited string
+ * containing a formatted ACL specification. See aclparse for details.
+ *
+ * RETURNS:
+ * the new string
+ */
+char *
+aclitemout(AclItem *aip)
+{
+ register char *p;
+ char *out;
+ HeapTuple htp;
+ unsigned i;
+ static AclItem default_aclitem = { ACL_ID_WORLD,
+ ACL_IDTYPE_WORLD,
+ ACL_WORLD_DEFAULT };
+ extern char *int2out();
+ char *tmpname;
+
+ if (!aip)
+ aip = &default_aclitem;
+
+ p = out = palloc(strlen("group =arwR ") + 1 + NAMEDATALEN);
+ if (!out)
+ elog(WARN, "aclitemout: palloc failed");
+ *p = '\0';
+
+ switch (aip->ai_idtype) {
+ case ACL_IDTYPE_UID:
+ htp = SearchSysCacheTuple(USESYSID, ObjectIdGetDatum(aip->ai_id),
+ 0,0,0);
+ if (!HeapTupleIsValid(htp)) {
+ char *tmp = int2out(aip->ai_id);
+
+ elog(NOTICE, "aclitemout: usesysid %d not found",
+ aip->ai_id);
+ (void) strcat(p, tmp);
+ pfree(tmp);
+ } else
+ (void) strncat(p, (char *) &((Form_pg_user)
+ GETSTRUCT(htp))->usename,
+ sizeof(NameData));
+ break;
+ case ACL_IDTYPE_GID:
+ (void) strcat(p, "group ");
+ tmpname = get_groname(aip->ai_id);
+ (void) strncat(p, tmpname, NAMEDATALEN);
+ pfree(tmpname);
+ break;
+ case ACL_IDTYPE_WORLD:
+ break;
+ default:
+ elog(WARN, "aclitemout: bad ai_idtype: %d", aip->ai_idtype);
+ break;
+ }
+ while (*p)
+ ++p;
+ *p++ = '=';
+ for (i = 0; i < N_ACL_MODES; ++i)
+ if ((aip->ai_mode >> i) & 01)
+ *p++ = ACL_MODE_STR[i];
+ *p = '\0';
+
+ return(out);
+}
+
+/*
+ * aclitemeq
+ * aclitemgt
+ * AclItem equality and greater-than comparison routines.
+ * Two AclItems are equal iff they are both NULL or they have the
+ * same identifier (and identifier type).
+ *
+ * RETURNS:
+ * a boolean value indicating = or >
+ */
+static int32
+aclitemeq(AclItem *a1, AclItem *a2)
+{
+ if (!a1 && !a2)
+ return(1);
+ if (!a1 || !a2)
+ return(0);
+ return(a1->ai_idtype == a2->ai_idtype && a1->ai_id == a2->ai_id);
+}
+
+static int32
+aclitemgt(AclItem *a1, AclItem *a2)
+{
+ if (a1 && !a2)
+ return(1);
+ if (!a1 || !a2)
+ return(0);
+ return((a1->ai_idtype > a2->ai_idtype) ||
+ (a1->ai_idtype == a2->ai_idtype && a1->ai_id > a2->ai_id));
+}
+
+Acl *
+aclownerdefault(AclId ownerid)
+{
+ Acl *acl;
+ AclItem *aip;
+
+ acl = makeacl(2);
+ aip = ACL_DAT(acl);
+ aip[0].ai_idtype = ACL_IDTYPE_WORLD;
+ aip[0].ai_id = ACL_ID_WORLD;
+ aip[0].ai_mode = ACL_WORLD_DEFAULT;
+ aip[1].ai_idtype = ACL_IDTYPE_UID;
+ aip[1].ai_id = ownerid;
+ aip[1].ai_mode = ACL_OWNER_DEFAULT;
+ return(acl);
+}
+
+Acl *
+acldefault()
+{
+ Acl *acl;
+ AclItem *aip;
+
+ acl = makeacl(1);
+ aip = ACL_DAT(acl);
+ aip[0].ai_idtype = ACL_IDTYPE_WORLD;
+ aip[0].ai_id = ACL_ID_WORLD;
+ aip[0].ai_mode = ACL_WORLD_DEFAULT;
+ return(acl);
+}
+
+Acl *
+aclinsert3(Acl *old_acl, AclItem *mod_aip, unsigned modechg)
+{
+ Acl *new_acl;
+ AclItem *old_aip, *new_aip;
+ unsigned src, dst, num;
+
+ if (!old_acl || ACL_NUM(old_acl) < 1) {
+ new_acl = makeacl(0);
+ return(new_acl);
+ }
+ if (!mod_aip) {
+ new_acl = makeacl(ACL_NUM(old_acl));
+ memmove((char *) new_acl, (char *) old_acl, ACL_SIZE(old_acl));
+ return(new_acl);
+ }
+
+ num = ACL_NUM(old_acl);
+ old_aip = ACL_DAT(old_acl);
+
+ /*
+ * Search the ACL for an existing entry for 'id'. If one exists,
+ * just modify the entry in-place (well, in the same position, since
+ * we actually return a copy); otherwise, insert the new entry in
+ * sort-order.
+ */
+ /* find the first element not less than the element to be inserted */
+ for (dst = 0; dst < num && aclitemgt(mod_aip, old_aip+dst); ++dst)
+ ;
+ if (dst < num && aclitemeq(mod_aip, old_aip+dst)) {
+ /* modify in-place */
+ new_acl = makeacl(ACL_NUM(old_acl));
+ memmove((char *) new_acl, (char *) old_acl, ACL_SIZE(old_acl));
+ new_aip = ACL_DAT(new_acl);
+ src = dst;
+ } else {
+ new_acl = makeacl(num + 1);
+ new_aip = ACL_DAT(new_acl);
+ if (dst == 0) { /* start */
+ elog(WARN, "aclinsert3: insertion before world ACL??");
+ } else if (dst >= num) { /* end */
+ memmove((char *) new_aip,
+ (char *) old_aip,
+ num * sizeof(AclItem));
+ } else { /* middle */
+ memmove((char *) new_aip,
+ (char *) old_aip,
+ dst * sizeof(AclItem));
+ memmove((char *) (new_aip+dst+1),
+ (char *) (old_aip+dst),
+ (num - dst) * sizeof(AclItem));
+ }
+ new_aip[dst].ai_id = mod_aip->ai_id;
+ new_aip[dst].ai_idtype = mod_aip->ai_idtype;
+ num++; /* set num to the size of new_acl */
+ src = 0; /* world entry */
+ }
+ switch (modechg) {
+ case ACL_MODECHG_ADD: new_aip[dst].ai_mode =
+ old_aip[src].ai_mode | mod_aip->ai_mode;
+ break;
+ case ACL_MODECHG_DEL: new_aip[dst].ai_mode =
+ old_aip[src].ai_mode & ~mod_aip->ai_mode;
+ break;
+ case ACL_MODECHG_EQL: new_aip[dst].ai_mode =
+ mod_aip->ai_mode;
+ break;
+ }
+ /* if the newly added entry has no permissions, delete it from
+ the list. For example, this helps in removing entries for users who
+ no longer exists...*/
+ for (dst = 1; dst < num; dst++) {
+ if (new_aip[dst].ai_mode == 0) {
+ int i;
+ for (i=dst+1; i
+ new_aip[i-1].ai_id = new_aip[i].ai_id;
+ new_aip[i-1].ai_idtype = new_aip[i].ai_idtype;
+ new_aip[i-1].ai_mode = new_aip[i].ai_mode;
+ }
+ ARR_DIMS(new_acl)[0] = num -1 ;
+ break;
+ }
+ }
+
+ return(new_acl);
+}
+
+/*
+ * aclinsert
+ *
+ */
+Acl *
+aclinsert(Acl *old_acl, AclItem *mod_aip)
+{
+ return(aclinsert3(old_acl, mod_aip, ACL_MODECHG_EQL));
+}
+
+Acl *
+aclremove(Acl *old_acl, AclItem *mod_aip)
+{
+ Acl *new_acl;
+ AclItem *old_aip, *new_aip;
+ unsigned dst, old_num, new_num;
+
+ if (!old_acl || ACL_NUM(old_acl) < 1) {
+ new_acl = makeacl(0);
+ return(new_acl);
+ }
+ if (!mod_aip) {
+ new_acl = makeacl(ACL_NUM(old_acl));
+ memmove((char *) new_acl, (char *) old_acl, ACL_SIZE(old_acl));
+ return(new_acl);
+ }
+
+ old_num = ACL_NUM(old_acl);
+ old_aip = ACL_DAT(old_acl);
+
+ for (dst = 0; dst < old_num && !aclitemeq(mod_aip, old_aip+dst); ++dst)
+ ;
+ if (dst >= old_num) { /* not found or empty */
+ new_acl = makeacl(ACL_NUM(old_acl));
+ memmove((char *) new_acl, (char *) old_acl, ACL_SIZE(old_acl));
+ } else {
+ new_num = old_num - 1;
+ new_acl = makeacl(ACL_NUM(old_acl) - 1);
+ new_aip = ACL_DAT(new_acl);
+ if (dst == 0) { /* start */
+ elog(WARN, "aclremove: removal of the world ACL??");
+ } else if (dst == old_num - 1) {/* end */
+ memmove((char *) new_aip,
+ (char *) old_aip,
+ new_num * sizeof(AclItem));
+ } else { /* middle */
+ memmove((char *) new_aip,
+ (char *) old_aip,
+ dst * sizeof(AclItem));
+ memmove((char *) (new_aip+dst),
+ (char *) (old_aip+dst+1),
+ (new_num - dst) * sizeof(AclItem));
+ }
+ }
+ return(new_acl);
+}
+
+int32
+aclcontains(Acl *acl, AclItem *aip)
+{
+ unsigned i, num;
+ AclItem *aidat;
+
+ if (!acl || !aip || ((num = ACL_NUM(acl)) < 1))
+ return(0);
+ aidat = ACL_DAT(acl);
+ for (i = 0; i < num; ++i)
+ if (aclitemeq(aip, aidat+i))
+ return(1);
+ return(0);
+}
+
+/* parser support routines */
+
+/*
+ * aclmakepriv
+ * make a acl privilege string out of an existing privilege string
+ * and a new privilege
+ *
+ * does not add duplicate privileges
+ *
+ * the CALLER is reponsible for free'ing the string returned
+ */
+
+char*
+aclmakepriv(char* old_privlist, char new_priv)
+{
+ char* priv;
+ int i;
+ int l;
+
+ Assert(strlen(old_privlist)<5);
+ priv = malloc(5); /* at most "rwaR" */;
+
+ if (old_privlist == NULL || old_privlist[0] == '\0') {
+ priv[0] = new_priv;
+ priv[1] = '\0';
+ return priv;
+ }
+
+ strcpy(priv,old_privlist);
+
+ l = strlen(old_privlist);
+
+ if (l == 4) { /* can't add any more privileges */
+ return priv;
+ }
+
+ /* check to see if the new privilege is already in the old string */
+ for (i=0;i
+ if (priv[i] == new_priv)
+ break;
+ }
+ if (i == l) { /* we really have a new privilege*/
+ priv[l] = new_priv;
+ priv[l+1] = '\0';
+ }
+
+ return priv;
+}
+
+/*
+ * aclmakeuser
+ * user_type must be "A" - all users
+ * "G" - group
+ * "U" - user
+ *
+ * concatentates the two strings together with a space in between
+ *
+ * this routine is used in the parser
+ *
+ * the CALLER is responsible for freeing the memory allocated
+ */
+
+char*
+aclmakeuser(char* user_type, char* user)
+{
+ char* user_list;
+
+ user_list = malloc(strlen(user) + 3);
+ sprintf(user_list, "%s %s", user_type, user);
+ return user_list;
+}
+
+
+/*
+ * makeAclStmt:
+ * this is a helper routine called by the parser
+ * create a ChangeAclStmt
+ * we take in the privilegs, relation_name_list, and grantee
+ * as well as a single character '+' or '-' to indicate grant or revoke
+ *
+ * returns a new ChangeACLStmt*
+ *
+ * this routines works by creating a old-style changle acl string and
+ * then calling aclparse;
+ */
+
+ChangeACLStmt*
+makeAclStmt(char* privileges, List* rel_list, char* grantee,
+ char grant_or_revoke)
+{
+ ChangeACLStmt *n = makeNode(ChangeACLStmt);
+ char str[MAX_PARSE_BUFFER];
+
+ n->aclitem = (AclItem*)palloc(sizeof(AclItem));
+ /* the grantee string is "G ", "U ", or "ALL" */
+ if (grantee[0] == 'G') /* group permissions */
+ {
+ sprintf(str,"%s %s%c%s",
+ ACL_IDTYPE_GID_KEYWORD,
+ grantee+2, grant_or_revoke,privileges);
+ }
+ else if (grantee[0] == 'U') /* user permission */
+ {
+ sprintf(str,"%s %s%c%s",
+ ACL_IDTYPE_UID_KEYWORD,
+ grantee+2, grant_or_revoke,privileges);
+ }
+ else /* all permission */
+ {
+ sprintf(str,"%c%s",
+ grant_or_revoke,privileges);
+ }
+ n->relNames = rel_list;
+ aclparse(str, n->aclitem, (unsigned*)&n->modechg);
+ return n;
+}
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * arrayfuncs.c--
+ * Special functions for arrays.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.1.1.1 1996/07/09 06:22:03 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+
+#include "postgres.h"
+
+#include "catalog/catalog.h"
+#include "catalog/pg_type.h"
+
+#include "utils/syscache.h"
+#include "utils/palloc.h"
+#include "utils/memutils.h"
+#include "storage/fd.h" /* for SEEK_ */
+#include "fmgr.h"
+#include "utils/elog.h"
+#include "utils/array.h"
+
+#include "libpq/libpq-fs.h"
+#include "libpq/be-fsstubs.h"
+
+#define ASSGN "="
+
+/* An array has the following internal structure:
+ * - total number of bytes
+ * - number of dimensions of the array
+ * - bit mask of flags
+ * - size of each array axis
+ * - lower boundary of each dimension
+ *
- whatever is the stored data+*/
+
+/*-=-=--=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-*/
+static int _ArrayCount(char *str, int dim[], int typdelim);
+static char *_ReadArrayStr(char *arrayStr, int nitems, int ndim, int dim[],
+ func_ptr inputproc, Oid typelem, char typdelim,
+ int typlen, bool typbyval, char typalign,
+ int *nbytes);
+static char *_ReadLOArray(char *str, int *nbytes, int *fd, bool *chunkFlag,
+ int ndim, int dim[], int baseSize);
+static void _CopyArrayEls(char **values, char *p, int nitems, int typlen,
+ char typalign, bool typbyval);
+static void system_cache_lookup(Oid element_type, bool input, int *typlen,
+ bool *typbyval, char *typdelim, Oid *typelem, Oid *proc,
+ char *typalign);
+static Datum _ArrayCast(char *value, bool byval, int len);
+static char *_AdvanceBy1word(char *str, char **word);
+static void _ArrayRange(int st[], int endp[], int bsize, char *destPtr,
+ ArrayType *array, int from);
+static int _ArrayClipCount(int stI[], int endpI[], ArrayType *array);
+static void _LOArrayRange(int st[], int endp[], int bsize, int srcfd,
+ int destfd, ArrayType *array, int isSrcLO, bool *isNull);
+static void _ReadArray (int st[], int endp[], int bsize, int srcfd, int destfd,
+ ArrayType *array, int isDestLO, bool *isNull);
+static char *_array_set(ArrayType *array, struct varlena *indx_str,
+ struct varlena *dataPtr);
+static ArrayCastAndSet(char *src, bool typbyval, int typlen, char *dest);
+
+
+/*---------------------------------------------------------------------
+ * array_in :
+ * converts an array from the external format in "string" to
+ * it internal format.
+ * return value :
+ * the internal representation of the input array
+ *--------------------------------------------------------------------
+ */
+char *
+array_in(char *string, /* input array in external form */
+ Oid element_type) /* type OID of an array element */
+{
+ int typlen;
+ bool typbyval, done;
+ char typdelim;
+ Oid typinput;
+ Oid typelem;
+ char *string_save, *p, *q, *r;
+ func_ptr inputproc;
+ int i, nitems, dummy;
+ int32 nbytes;
+ char *dataPtr;
+ ArrayType *retval;
+ int ndim, dim[MAXDIM], lBound[MAXDIM];
+ char typalign;
+
+ system_cache_lookup(element_type, true, &typlen, &typbyval, &typdelim,
+ &typelem, &typinput, &typalign);
+
+ fmgr_info(typinput, &inputproc, &dummy);
+
+ string_save = (char *) palloc(strlen(string) + 3);
+ strcpy(string_save, string);
+
+ /* --- read array dimensions ---------- */
+ p = q = string_save; done = false;
+ for ( ndim = 0; !done; ) {
+ while (isspace(*p)) p++;
+ if (*p == '[' ) {
+ p++;
+ if ((r = (char *)strchr(p, ':')) == (char *)NULL)
+ lBound[ndim] = 1;
+ else {
+ *r = '\0';
+ lBound[ndim] = atoi(p);
+ p = r + 1;
+ }
+ for (q = p; isdigit(*q); q++);
+ if (*q != ']')
+ elog(WARN, "array_in: missing ']' in array declaration");
+ *q = '\0';
+ dim[ndim] = atoi(p);
+ if ((dim[ndim] < 0) || (lBound[ndim] < 0))
+ elog(WARN,"array_in: array dimensions need to be positive");
+ dim[ndim] = dim[ndim] - lBound[ndim] + 1;
+ if (dim[ndim] < 0)
+ elog(WARN, "array_in: upper_bound cannot be < lower_bound");
+ p = q + 1; ndim++;
+ } else {
+ done = true;
+ }
+ }
+
+ if (ndim == 0) {
+ if (*p == '{') {
+ ndim = _ArrayCount(p, dim, typdelim);
+ for (i = 0; i < ndim; lBound[i++] = 1);
+ } else {
+ elog(WARN,"array_in: Need to specify dimension");
+ }
+ } else {
+ while (isspace(*p)) p++;
+ if (strncmp(p, ASSGN, strlen(ASSGN)))
+ elog(WARN, "array_in: missing assignment operator");
+ p+= strlen(ASSGN);
+ while (isspace(*p)) p++;
+ }
+
+ nitems = getNitems( ndim, dim);
+ if (nitems == 0) {
+ char *emptyArray = palloc(sizeof(ArrayType));
+ memset(emptyArray, 0, sizeof(ArrayType));
+ * (int32 *) emptyArray = sizeof(ArrayType);
+ return emptyArray;
+ }
+
+ if (*p == '{') {
+ /* array not a large object */
+ dataPtr =
+ (char *) _ReadArrayStr(p, nitems, ndim, dim, inputproc, typelem,
+ typdelim, typlen, typbyval, typalign,
+ &nbytes );
+ nbytes += ARR_OVERHEAD(ndim);
+ retval = (ArrayType *) palloc(nbytes);
+ memset(retval,0, nbytes);
+ memmove(retval, (char *)&nbytes, sizeof(int));
+ memmove((char*)ARR_NDIM_PTR(retval), (char *)&ndim, sizeof(int));
+ SET_LO_FLAG (false, retval);
+ memmove((char *)ARR_DIMS(retval), (char *)dim, ndim*sizeof(int));
+ memmove((char *)ARR_LBOUND(retval), (char *)lBound,
+ ndim*sizeof(int));
+ /* dataPtr is an array of arbitraystuff even though its type is char*
+ cast to char** to pass to _CopyArrayEls for now - jolly */
+ _CopyArrayEls((char**)dataPtr,
+ ARR_DATA_PTR(retval), nitems,
+ typlen, typalign, typbyval);
+ } else {
+#ifdef LOARRAY
+ int dummy, bytes;
+ bool chunked = false;
+
+ dataPtr = _ReadLOArray(p, &bytes, &dummy, &chunked, ndim,
+ dim, typlen );
+ nbytes = bytes + ARR_OVERHEAD(ndim);
+ retval = (ArrayType *) palloc(nbytes);
+ memset(retval, 0,nbytes);
+ memmove(retval, (char *)&nbytes, sizeof(int));
+ memmove((char *)ARR_NDIM_PTR(retval), (char *)&ndim, sizeof(int));
+ SET_LO_FLAG (true, retval);
+ SET_CHUNK_FLAG (chunked, retval);
+ memmove((char *)ARR_DIMS(retval), (char *)dim, ndim*sizeof(int));
+ memmove((char *)ARR_LBOUND(retval),(char *)lBound, ndim*sizeof(int));
+ memmove(ARR_DATA_PTR(retval), dataPtr, bytes);
+#endif
+ elog(WARN, "large object arrays not supported");
+ }
+ pfree(string_save);
+ return((char *)retval);
+}
+
+/*-----------------------------------------------------------------------------
+ * _ArrayCount --
+ * Counts the number of dimensions and the dim[] array for an array string.
+ * The syntax for array input is C-like nested curly braces
+ *-----------------------------------------------------------------------------
+ */
+static int
+_ArrayCount(char *str, int dim[], int typdelim)
+{
+ int nest_level = 0, i;
+ int ndim = 0, temp[MAXDIM];
+ bool scanning_string = false;
+ bool eoArray = false;
+ char *q;
+
+ for (i = 0; i < MAXDIM; ++i) {
+ temp[i] = dim[i] = 0;
+ }
+
+ if (strncmp (str, "{}", 2) == 0) return(0);
+
+ q = str;
+ while (eoArray != true) {
+ bool done = false;
+ while (!done) {
+ switch (*q) {
+ case '\"':
+ scanning_string = ! scanning_string;
+ break;
+ case '{':
+ if (!scanning_string) {
+ temp[nest_level] = 0;
+ nest_level++;
+ }
+ break;
+ case '}':
+ if (!scanning_string) {
+ if (!ndim) ndim = nest_level;
+ nest_level--;
+ if (nest_level) temp[nest_level-1]++;
+ if (nest_level == 0) eoArray = done = true;
+ }
+ break;
+ default:
+ if (!ndim) ndim = nest_level;
+ if (*q == typdelim && !scanning_string )
+ done = true;
+ break;
+ }
+ if (!done) q++;
+ }
+ temp[ndim-1]++;
+ q++;
+ if (!eoArray)
+ while (isspace(*q)) q++;
+ }
+ for (i = 0; i < ndim; ++i) {
+ dim[i] = temp[i];
+ }
+
+ return(ndim);
+}
+
+/*---------------------------------------------------------------------------
+ * _ReadArrayStr :
+ * parses the array string pointed by "arrayStr" and converts it in the
+ * internal format. The external format expected is like C array
+ * declaration. Unspecified elements are initialized to zero for fixed length
+ * base types and to empty varlena structures for variable length base
+ * types.
+ * result :
+ * returns the internal representation of the array elements
+ * nbytes is set to the size of the array in its internal representation.
+ *---------------------------------------------------------------------------
+ */
+static char *
+_ReadArrayStr(char *arrayStr,
+ int nitems,
+ int ndim,
+ int dim[],
+ func_ptr inputproc, /* function used for the conversion */
+ Oid typelem,
+ char typdelim,
+ int typlen,
+ bool typbyval,
+ char typalign,
+ int *nbytes)
+{
+ int i, nest_level = 0;
+ char *p, *q, *r, **values;
+ bool scanning_string = false;
+ int indx[MAXDIM], prod[MAXDIM];
+ bool eoArray = false;
+
+ mda_get_prod(ndim, dim, prod);
+ for (i = 0; i < ndim; indx[i++] = 0);
+ /* read array enclosed within {} */
+ values = (char **) palloc(nitems * sizeof(char *));
+ memset(values, 0, nitems * sizeof(char *));
+ q = p = arrayStr;
+
+ while ( ! eoArray ) {
+ bool done = false;
+ int i = -1;
+
+ while (!done) {
+ switch (*q) {
+ case '\\':
+ /* Crunch the string on top of the backslash. */
+ for (r = q; *r != '\0'; r++) *r = *(r+1);
+ break;
+ case '\"':
+ if (!scanning_string ) {
+ while (p != q) p++;
+ p++; /* get p past first doublequote */
+ } else
+ *q = '\0';
+ scanning_string = ! scanning_string;
+ break;
+ case '{':
+ if (!scanning_string) {
+ p++;
+ nest_level++;
+ if (nest_level > ndim)
+ elog(WARN, "array_in: illformed array constant");
+ indx[nest_level - 1] = 0;
+ indx[ndim - 1] = 0;
+ }
+ break;
+ case '}':
+ if (!scanning_string) {
+ if (i == -1)
+ i = tuple2linear(ndim, indx, prod);
+ nest_level--;
+ if (nest_level == 0)
+ eoArray = done = true;
+ else {
+ *q = '\0';
+ indx[nest_level - 1]++;
+ }
+ }
+ break;
+ default:
+ if (*q == typdelim && !scanning_string ) {
+ if (i == -1)
+ i = tuple2linear(ndim, indx, prod);
+ done = true;
+ indx[ndim - 1]++;
+ }
+ break;
+ }
+ if (!done)
+ q++;
+ }
+ *q = '\0';
+ if (i >= nitems)
+ elog(WARN, "array_in: illformed array constant");
+ values[i] = (*inputproc) (p, typelem);
+ p = ++q;
+ if (!eoArray)
+ /*
+ * if not at the end of the array skip white space
+ */
+ while (isspace(*q)) {
+ p++;
+ q++;
+ }
+ }
+ if (typlen > 0) {
+ *nbytes = nitems * typlen;
+ if (!typbyval)
+ for (i = 0; i < nitems; i++)
+ if (!values[i]) {
+ values[i] = palloc(typlen);
+ memset(values[i], 0, typlen);
+ }
+ } else {
+ for (i = 0, *nbytes = 0; i < nitems; i++) {
+ if (values[i]) {
+ if (typalign=='d') {
+ *nbytes += DOUBLEALIGN(* (int32 *) values[i]);
+ } else {
+ *nbytes += INTALIGN(* (int32 *) values[i]);
+ }
+ } else {
+ *nbytes += sizeof(int32);
+ values[i] = palloc(sizeof(int32));
+ *(int32 *)values[i] = sizeof(int32);
+ }
+ }
+ }
+ return((char *)values);
+}
+
+
+/*----------------------------------------------------------------------------
+ * Read data about an array to be stored as a large object
+ *----------------------------------------------------------------------------
+ */
+static char *
+_ReadLOArray(char *str,
+ int *nbytes,
+ int *fd,
+ bool *chunkFlag,
+ int ndim,
+ int dim[],
+ int baseSize)
+{
+ char *inputfile, *accessfile = NULL, *chunkfile = NULL;
+ char *retStr, *_AdvanceBy1word();
+ Oid lobjId;
+
+ str = _AdvanceBy1word(str, &inputfile);
+
+ while (str != NULL) {
+ char *word;
+
+ str = _AdvanceBy1word(str, &word);
+
+ if (!strcmp (word, "-chunk")) {
+ if (str == NULL)
+ elog(WARN, "array_in: access pattern file required");
+ str = _AdvanceBy1word(str, &accessfile);
+ }
+ else if (!strcmp (word, "-noreorg")) {
+ if (str == NULL)
+ elog(WARN, "array_in: chunk file required");
+ str = _AdvanceBy1word(str, &chunkfile);
+ } else {
+ elog(WARN, "usage:
-chunk DEFAULT/ -invert/-native [-noreorg ]");+ }
+ }
+
+ if (inputfile == NULL)
+ elog(WARN, "array_in: missing file name");
+ lobjId = lo_creat(0);
+ *fd = lo_open(lobjId, INV_READ);
+ if ( *fd < 0 )
+ elog(WARN, "Large object create failed");
+ retStr = inputfile;
+ *nbytes = strlen(retStr) + 2;
+
+ if ( accessfile ) {
+ FILE *afd;
+ if ((afd = fopen (accessfile, "r")) == NULL)
+ elog(WARN, "unable to open access pattern file");
+ *chunkFlag = true;
+ retStr = _ChunkArray(*fd, afd, ndim, dim, baseSize, nbytes,
+ chunkfile);
+ }
+ return(retStr);
+}
+
+static void
+_CopyArrayEls(char **values,
+ char *p,
+ int nitems,
+ int typlen,
+ char typalign,
+ bool typbyval)
+{
+ int i;
+
+ for (i = 0; i < nitems; i++) {
+ int inc;
+ inc = ArrayCastAndSet(values[i], typbyval, typlen, p);
+ p += inc;
+ if (!typbyval)
+ pfree(values[i]);
+ }
+ pfree(values);
+}
+
+/*-------------------------------------------------------------------------
+ * array_out :
+ * takes the internal representation of an array and returns a string
+ * containing the array in its external format.
+ *-------------------------------------------------------------------------
+ */
+char *
+array_out(ArrayType *v, Oid element_type)
+{
+ int typlen;
+ bool typbyval;
+ char typdelim;
+ Oid typoutput, typelem;
+ func_ptr outputproc;
+ char typalign;
+
+ char *p, *retval, **values, delim[2];
+ int nitems, overall_length, i, j, k, indx[MAXDIM];
+ bool dummy_bool;
+ int dummy_int;
+ int ndim, *dim;
+
+ if (v == (ArrayType *) NULL)
+ return ((char *) NULL);
+
+ if (ARR_IS_LO(v) == true) {
+ char *p, *save_p;
+ int nbytes;
+
+ /* get a wide string to print to */
+ p = array_dims(v, &dummy_bool);
+ nbytes = strlen(ARR_DATA_PTR(v)) + 4 + *(int *)p;
+
+ save_p = (char *) palloc(nbytes);
+
+ strcpy(save_p, p + sizeof(int));
+ strcat(save_p, ASSGN);
+ strcat(save_p, ARR_DATA_PTR(v));
+ pfree(p);
+ return (save_p);
+ }
+
+ system_cache_lookup(element_type, false, &typlen, &typbyval,
+ &typdelim, &typelem, &typoutput, &typalign);
+ fmgr_info(typoutput, & outputproc, &dummy_int);
+ sprintf(delim, "%c", typdelim);
+ ndim = ARR_NDIM(v);
+ dim = ARR_DIMS(v);
+ nitems = getNitems(ndim, dim);
+
+ if (nitems == 0) {
+ char *emptyArray = palloc(3);
+ emptyArray[0] = '{';
+ emptyArray[1] = '}';
+ emptyArray[2] = '\0';
+ return emptyArray;
+ }
+
+ p = ARR_DATA_PTR(v);
+ overall_length = 1; /* [TRH] don't forget to count \0 at end. */
+ values = (char **) palloc(nitems * sizeof (char *));
+ for (i = 0; i < nitems; i++) {
+ if (typbyval) {
+ switch(typlen) {
+ case 1:
+ values[i] = (*outputproc) (*p, typelem);
+ break;
+ case 2:
+ values[i] = (*outputproc) (* (int16 *) p, typelem);
+ break;
+ case 3:
+ case 4:
+ values[i] = (*outputproc) (* (int32 *) p, typelem);
+ break;
+ }
+ p += typlen;
+ } else {
+ values[i] = (*outputproc) (p, typelem);
+ if (typlen > 0)
+ p += typlen;
+ else
+ p += INTALIGN(* (int32 *) p);
+ /*
+ * For the pair of double quotes
+ */
+ overall_length += 2;
+ }
+ overall_length += (strlen(values[i]) + 1);
+ }
+
+ /*
+ * count total number of curly braces in output string
+ */
+ for (i = j = 0, k = 1; i < ndim; k *= dim[i++], j += k);
+
+ p = (char *) palloc(overall_length + 2*j);
+ retval = p;
+
+ strcpy(p, "{");
+ for (i = 0; i < ndim; indx[i++] = 0);
+ j = 0; k = 0;
+ do {
+ for (i = j; i < ndim - 1; i++)
+ strcat(p, "{");
+ /*
+ * Surround anything that is not passed by value in double quotes.
+ * See above for more details.
+ */
+ if (!typbyval) {
+ strcat(p, "\"");
+ strcat(p, values[k]);
+ strcat(p, "\"");
+ } else
+ strcat(p, values[k]);
+ pfree(values[k++]);
+
+ for (i = ndim - 1; i >= 0; i--) {
+ indx[i] = (indx[i] + 1)%dim[i];
+ if (indx[i]) {
+ strcat (p, delim);
+ break;
+ } else
+ strcat (p, "}");
+ }
+ j = i;
+ } while (j != -1);
+
+ pfree(values);
+ return(retval);
+}
+
+/*-----------------------------------------------------------------------------
+ * array_dims :
+ * returns the dimension of the array pointed to by "v"
+ *----------------------------------------------------------------------------
+ */
+char *
+array_dims(ArrayType *v, bool *isNull)
+{
+ char *p, *save_p;
+ int nbytes, i;
+ int *dimv, *lb;
+
+ if (v == (ArrayType *) NULL) RETURN_NULL;
+ nbytes = ARR_NDIM(v)*33;
+ /*
+ * 33 since we assume 15 digits per number + ':' +'[]'
+ */
+ save_p = p = (char *) palloc(nbytes + 4);
+ memset(save_p, 0, nbytes + 4);
+ dimv = ARR_DIMS(v); lb = ARR_LBOUND(v);
+ p += 4;
+ for (i = 0; i < ARR_NDIM(v); i++) {
+ sprintf(p, "[%d:%d]", lb[i], dimv[i]+lb[i]-1);
+ p += strlen(p);
+ }
+ nbytes = strlen(save_p + 4) + 4;
+ memmove(save_p, &nbytes,4);
+ return (save_p);
+}
+
+/*---------------------------------------------------------------------------
+ * array_ref :
+ * This routing takes an array pointer and an index array and returns
+ * a pointer to the referred element if element is passed by
+ * reference otherwise returns the value of the referred element.
+ *---------------------------------------------------------------------------
+ */
+Datum
+array_ref(ArrayType *array,
+ int n,
+ int indx[],
+ int reftype,
+ int elmlen,
+ int arraylen,
+ bool *isNull)
+{
+ int i, ndim, *dim, *lb, offset, nbytes;
+ struct varlena *v;
+ char *retval;
+
+ if (array == (ArrayType *) NULL) RETURN_NULL;
+ if (arraylen > 0) {
+ /*
+ * fixed length arrays -- these are assumed to be 1-d
+ */
+ if (indx[0]*elmlen > arraylen)
+ elog(WARN, "array_ref: array bound exceeded");
+ retval = (char *)array + indx[0]*elmlen;
+ return _ArrayCast(retval, reftype, elmlen);
+ }
+ dim = ARR_DIMS(array);
+ lb = ARR_LBOUND(array);
+ ndim = ARR_NDIM(array);
+ nbytes = (* (int32 *) array) - ARR_OVERHEAD(ndim);
+
+ if (!SanityCheckInput(ndim, n, dim, lb, indx))
+ RETURN_NULL;
+
+ offset = GetOffset(n, dim, lb, indx);
+
+ if (ARR_IS_LO(array)) {
+ char * lo_name;
+ int fd;
+
+ /* We are assuming fixed element lengths here */
+ offset *= elmlen;
+ lo_name = (char *)ARR_DATA_PTR(array);
+#ifdef LOARRAY
+ if ((fd = LOopen(lo_name, ARR_IS_INV(array)?INV_READ:O_RDONLY)) < 0)
+ RETURN_NULL;
+#endif
+ if (ARR_IS_CHUNKED(array))
+ v = _ReadChunkArray1El(indx, elmlen, fd, array, isNull);
+ else {
+ if (lo_lseek(fd, offset, SEEK_SET) < 0)
+ RETURN_NULL;
+#ifdef LOARRAY
+ v = (struct varlena *) LOread(fd, elmlen);
+#endif
+ }
+ if (*isNull) RETURN_NULL;
+ if (VARSIZE(v) - 4 < elmlen)
+ RETURN_NULL;
+ (void) lo_close(fd);
+ retval = (char *)_ArrayCast((char *)VARDATA(v), reftype, elmlen);
+ if ( reftype == 0) { /* not by value */
+ char * tempdata = palloc (elmlen);
+ memmove(tempdata, retval, elmlen);
+ retval = tempdata;
+ }
+ pfree(v);
+ return (Datum) retval;
+ }
+
+ if (elmlen > 0) {
+ offset = offset * elmlen;
+ /* off the end of the array */
+ if (nbytes - offset < 1) RETURN_NULL;
+ retval = ARR_DATA_PTR (array) + offset;
+ return _ArrayCast(retval, reftype, elmlen);
+ } else {
+ bool done = false;
+ char *temp;
+ int bytes = nbytes;
+ temp = ARR_DATA_PTR (array);
+ i = 0;
+ while (bytes > 0 && !done) {
+ if (i == offset) {
+ retval = temp;
+ done = true;
+ }
+ bytes -= INTALIGN(* (int32 *) temp);
+ temp += INTALIGN(* (int32 *) temp);
+ i++;
+ }
+ if (! done)
+ RETURN_NULL;
+ return (Datum) retval;
+ }
+}
+
+/*-----------------------------------------------------------------------------
+ * array_clip :
+ * This routine takes an array and a range of indices (upperIndex and
+ * lowerIndx), creates a new array structure for the referred elements
+ * and returns a pointer to it.
+ *-----------------------------------------------------------------------------
+ */
+Datum
+array_clip(ArrayType *array,
+ int n,
+ int upperIndx[],
+ int lowerIndx[],
+ int reftype,
+ int len,
+ bool *isNull)
+{
+ int i, ndim, *dim, *lb, nbytes;
+ ArrayType *newArr;
+ int bytes, span[MAXDIM];
+
+ /* timer_start(); */
+ if (array == (ArrayType *) NULL)
+ RETURN_NULL;
+ dim = ARR_DIMS(array);
+ lb = ARR_LBOUND(array);
+ ndim = ARR_NDIM(array);
+ nbytes = (* (int32 *) array) - ARR_OVERHEAD(ndim);
+
+ if (!SanityCheckInput(ndim, n, dim, lb, upperIndx))
+ RETURN_NULL;
+
+ if (!SanityCheckInput(ndim, n, dim, lb, lowerIndx))
+ RETURN_NULL;
+
+ for (i = 0; i < n; i++)
+ if (lowerIndx[i] > upperIndx[i])
+ elog(WARN, "lowerIndex cannot be larger than upperIndx");
+ mda_get_range(n, span, lowerIndx, upperIndx);
+
+ if (ARR_IS_LO(array)) {
+ char * lo_name, * newname;
+ int fd, newfd, isDestLO = true, rsize;
+
+ if (len < 0)
+ elog(WARN, "array_clip: array of variable length objects not supported");
+#ifdef LOARRAY
+ lo_name = (char *)ARR_DATA_PTR(array);
+ if ((fd = LOopen(lo_name, ARR_IS_INV(array)?INV_READ:O_RDONLY)) < 0)
+ RETURN_NULL;
+ newname = _array_newLO( &newfd, Unix );
+#endif
+ bytes = strlen(newname) + 1 + ARR_OVERHEAD(n);
+ newArr = (ArrayType *) palloc(bytes);
+ memmove(newArr, array, sizeof(ArrayType));
+ memmove(newArr, &bytes, sizeof(int));
+ memmove(ARR_DIMS(newArr), span, n*sizeof(int));
+ memmove(ARR_LBOUND(newArr), lowerIndx, n*sizeof(int));
+ strcpy(ARR_DATA_PTR(newArr), newname);
+
+ rsize = compute_size (lowerIndx, upperIndx, n, len);
+ if (rsize < MAX_BUFF_SIZE) {
+ char *buff;
+ rsize += 4;
+ buff = palloc(rsize);
+ if ( buff )
+ isDestLO = false;
+ if (ARR_IS_CHUNKED(array)) {
+ _ReadChunkArray(lowerIndx, upperIndx, len, fd, &(buff[4]),
+ array,0,isNull);
+ } else {
+ _ReadArray(lowerIndx, upperIndx, len, fd, (int)&(buff[4]),
+ array,
+ 0,isNull);
+ }
+ memmove(buff, &rsize, 4);
+#ifdef LOARRAY
+ if (! *isNull)
+ bytes = LOwrite(newfd, (struct varlena *)buff);
+#endif
+ pfree (buff);
+ }
+ if (isDestLO)
+ if (ARR_IS_CHUNKED(array)) {
+ _ReadChunkArray(lowerIndx, upperIndx, len, fd, (char*)newfd, array,
+ 1,isNull);
+ } else {
+ _ReadArray(lowerIndx, upperIndx, len, fd, newfd, array, 1,isNull);
+ }
+#ifdef LOARRAY
+ (void) LOclose(fd);
+ (void) LOclose(newfd);
+#endif
+ if (*isNull) {
+ pfree(newArr);
+ newArr = NULL;
+ }
+ /* timer_end(); */
+ return ((Datum) newArr);
+ }
+
+ if (len > 0) {
+ bytes = getNitems(n, span);
+ bytes = bytes*len + ARR_OVERHEAD(n);
+ } else {
+ bytes = _ArrayClipCount(lowerIndx, upperIndx, array);
+ bytes += ARR_OVERHEAD(n);
+ }
+ newArr = (ArrayType *) palloc(bytes);
+ memmove(newArr, array, sizeof(ArrayType));
+ memmove(newArr, &bytes, sizeof(int));
+ memmove(ARR_DIMS(newArr), span, n*sizeof(int));
+ memmove(ARR_LBOUND(newArr), lowerIndx, n*sizeof(int));
+ _ArrayRange(lowerIndx, upperIndx, len, ARR_DATA_PTR(newArr), array, 1);
+ return (Datum) newArr;
+}
+
+/*-----------------------------------------------------------------------------
+ * array_set :
+ * This routine sets the value of an array location (specified by an index array)
+ * to a new value specified by "dataPtr".
+ * result :
+ * returns a pointer to the modified array.
+ *-----------------------------------------------------------------------------
+ */
+char *
+array_set(ArrayType *array,
+ int n,
+ int indx[],
+ char *dataPtr,
+ int reftype,
+ int elmlen,
+ int arraylen,
+ bool *isNull)
+{
+ int ndim, *dim, *lb, offset, nbytes;
+ char *pos;
+
+ if (array == (ArrayType *) NULL)
+ RETURN_NULL;
+ if (arraylen > 0) {
+ /*
+ * fixed length arrays -- these are assumed to be 1-d
+ */
+ if (indx[0]*elmlen > arraylen)
+ elog(WARN, "array_ref: array bound exceeded");
+ pos = (char *)array + indx[0]*elmlen;
+ ArrayCastAndSet(dataPtr, (bool) reftype, elmlen, pos);
+ return((char *)array);
+ }
+ dim = ARR_DIMS(array);
+ lb = ARR_LBOUND(array);
+ ndim = ARR_NDIM(array);
+ nbytes = (* (int32 *) array) - ARR_OVERHEAD(ndim);
+
+ if (!SanityCheckInput(ndim, n, dim, lb, indx))
+ return((char *)array);
+ offset = GetOffset( n, dim, lb, indx);
+
+ if (ARR_IS_LO(array)) {
+ int fd;
+ char * lo_name;
+ struct varlena *v;
+
+ /* We are assuming fixed element lengths here */
+ offset *= elmlen;
+#ifdef LOARRAY
+ lo_name = ARR_DATA_PTR(array);
+ if ((fd = LOopen(lo_name, ARR_IS_INV(array)?INV_WRITE:O_WRONLY)) < 0)
+ return((char *)array);
+#endif
+ if (lo_lseek(fd, offset, SEEK_SET) < 0)
+ return((char *)array);
+ v = (struct varlena *) palloc(elmlen + 4);
+ VARSIZE (v) = elmlen + 4;
+ ArrayCastAndSet(dataPtr, (bool) reftype, elmlen, VARDATA(v));
+#ifdef LOARRAY
+ n = LOwrite(fd, v);
+#endif
+ /* if (n < VARSIZE(v) - 4)
+ RETURN_NULL;
+ */
+ pfree(v);
+ (void) lo_close(fd);
+ return((char *)array);
+ }
+ if (elmlen > 0) {
+ offset = offset * elmlen;
+ /* off the end of the array */
+ if (nbytes - offset < 1) return((char *)array);
+ pos = ARR_DATA_PTR (array) + offset;
+ } else {
+ elog(WARN, "array_set: update of variable length fields not supported");
+ }
+ ArrayCastAndSet(dataPtr, (bool) reftype, elmlen, pos);
+ return((char *)array);
+}
+
+/*----------------------------------------------------------------------------
+ * array_assgn :
+ * This routine sets the value of a range of array locations (specified
+ * by upper and lower index values ) to new values passed as
+ * another array
+ * result :
+ * returns a pointer to the modified array.
+ *----------------------------------------------------------------------------
+ */
+char *
+array_assgn(ArrayType *array,
+ int n,
+ int upperIndx[],
+ int lowerIndx[],
+ ArrayType *newArr,
+ int reftype,
+ int len,
+ bool *isNull)
+{
+ int i, ndim, *dim, *lb;
+
+ if (array == (ArrayType *) NULL)
+ RETURN_NULL;
+ if (len < 0)
+ elog(WARN,"array_assgn:updates on arrays of variable length elements not allowed");
+
+ dim = ARR_DIMS(array);
+ lb = ARR_LBOUND(array);
+ ndim = ARR_NDIM(array);
+
+ if (!SanityCheckInput(ndim, n, dim, lb, upperIndx) ||
+ !SanityCheckInput(ndim, n, dim, lb, lowerIndx)) {
+ return((char *)array);
+ }
+
+ for (i = 0; i < n; i++)
+ if (lowerIndx[i] > upperIndx[i])
+ elog(WARN, "lowerIndex larger than upperIndx");
+
+ if (ARR_IS_LO(array)) {
+ char * lo_name;
+ int fd, newfd;
+
+#ifdef LOARRAY
+ lo_name = (char *)ARR_DATA_PTR(array);
+ if ((fd = LOopen(lo_name, ARR_IS_INV(array)?INV_WRITE:O_WRONLY)) < 0)
+ return((char *)array);
+#endif
+ if (ARR_IS_LO(newArr)) {
+#ifdef LOARRAY
+ lo_name = (char *)ARR_DATA_PTR(newArr);
+ if ((newfd = LOopen(lo_name, ARR_IS_INV(newArr)?INV_READ:O_RDONLY)) < 0)
+ return((char *)array);
+#endif
+ _LOArrayRange(lowerIndx, upperIndx, len, fd, newfd, array, 1, isNull);
+ (void) lo_close(newfd);
+ } else {
+ _LOArrayRange(lowerIndx, upperIndx, len, fd, (int)ARR_DATA_PTR(newArr),
+ array, 0, isNull);
+ }
+ (void) lo_close(fd);
+ return ((char *) array);
+ }
+ _ArrayRange(lowerIndx, upperIndx, len, ARR_DATA_PTR(newArr), array, 0);
+ return (char *) array;
+}
+
+/*-----------------------------------------------------------------------------
+ * array_eq :
+ * compares two arrays for equality
+ * result :
+ * returns 1 if the arrays are equal, 0 otherwise.
+ *-----------------------------------------------------------------------------
+ */
+int
+array_eq (ArrayType *array1, ArrayType *array2)
+{
+ if ((array1 == NULL) || (array2 == NULL))
+ return(0);
+ if (*(int *)array1 != *(int *)array2)
+ return (0);
+ if (memcmp(array1, array2, *(int *)array1))
+ return(0);
+ return(1);
+}
+
+/***************************************************************************/
+/******************| Support Routines |*****************/
+/***************************************************************************/
+static void
+system_cache_lookup(Oid element_type,
+ bool input,
+ int *typlen,
+ bool *typbyval,
+ char *typdelim,
+ Oid *typelem,
+ Oid *proc,
+ char *typalign)
+{
+ HeapTuple typeTuple;
+ TypeTupleForm typeStruct;
+
+ typeTuple = SearchSysCacheTuple(TYPOID, ObjectIdGetDatum(element_type),
+ 0,0,0);
+
+ if (!HeapTupleIsValid(typeTuple)) {
+ elog(WARN, "array_out: Cache lookup failed for type %d\n",
+ element_type);
+ return;
+ }
+ typeStruct = (TypeTupleForm) GETSTRUCT(typeTuple);
+ *typlen = typeStruct->typlen;
+ *typbyval = typeStruct->typbyval;
+ *typdelim = typeStruct->typdelim;
+ *typelem = typeStruct->typelem;
+ *typalign = typeStruct->typalign;
+ if (input) {
+ *proc = typeStruct->typinput;
+ } else {
+ *proc = typeStruct->typoutput;
+ }
+}
+
+static Datum
+_ArrayCast(char *value, bool byval, int len)
+{
+ if (byval) {
+ switch (len) {
+ case 1:
+ return((Datum) * value);
+ case 2:
+ return((Datum) * (int16 *) value);
+ case 3:
+ case 4:
+ return((Datum) * (int32 *) value);
+ default:
+ elog(WARN, "array_ref: byval and elt len > 4!");
+ break;
+ }
+ } else {
+ return (Datum) value;
+ }
+ return 0;
+}
+
+
+static int
+ArrayCastAndSet(char *src,
+ bool typbyval,
+ int typlen,
+ char *dest)
+{
+ int inc;
+
+ if (typlen > 0) {
+ if (typbyval) {
+ switch(typlen) {
+ case 1:
+ *dest = DatumGetChar(src);
+ break;
+ case 2:
+ * (int16 *) dest = DatumGetInt16(src);
+ break;
+ case 4:
+ * (int32 *) dest = (int32)src;
+ break;
+ }
+ } else {
+ memmove(dest, src, typlen);
+ }
+ inc = typlen;
+ } else {
+ memmove(dest, src, *(int32 *)src);
+ inc = (INTALIGN(* (int32 *) src));
+ }
+ return(inc);
+}
+
+static char *
+_AdvanceBy1word(char *str, char **word)
+{
+ char *retstr, *space;
+
+ *word = NULL;
+ if (str == NULL) return str;
+ while (isspace(*str)) str++;
+ *word = str;
+ if ((space = (char *)strchr(str, ' ')) != (char *) NULL) {
+ retstr = space + 1;
+ *space = '\0';
+ }
+ else
+ retstr = NULL;
+ return retstr;
+}
+
+int
+SanityCheckInput(int ndim, int n, int dim[], int lb[], int indx[])
+{
+ int i;
+ /* Do Sanity check on input */
+ if (n != ndim) return 0;
+ for (i = 0; i < ndim; i++)
+ if ((lb[i] > indx[i]) || (indx[i] >= (dim[i] + lb[i])))
+ return 0;
+ return 1;
+}
+
+static void
+_ArrayRange(int st[],
+ int endp[],
+ int bsize,
+ char *destPtr,
+ ArrayType *array,
+ int from)
+{
+ int n, *dim, *lb, st_pos, prod[MAXDIM];
+ int span[MAXDIM], dist[MAXDIM], indx[MAXDIM];
+ int i, j, inc;
+ char *srcPtr, *array_seek();
+
+ n = ARR_NDIM(array); dim = ARR_DIMS(array);
+ lb = ARR_LBOUND(array); srcPtr = ARR_DATA_PTR(array);
+ for (i = 0; i < n; st[i] -= lb[i], endp[i] -= lb[i], i++);
+ mda_get_prod(n, dim, prod);
+ st_pos = tuple2linear(n, st, prod);
+ srcPtr = array_seek(srcPtr, bsize, st_pos);
+ mda_get_range(n, span, st, endp);
+ mda_get_offset_values(n, dist, prod, span);
+ for (i=0; i < n; indx[i++]=0);
+ i = j = n-1; inc = bsize;
+ do {
+ srcPtr = array_seek(srcPtr, bsize, dist[j]);
+ if (from)
+ inc = array_read(destPtr, bsize, 1, srcPtr);
+ else
+ inc = array_read(srcPtr, bsize, 1, destPtr);
+ destPtr += inc; srcPtr += inc;
+ } while ((j = next_tuple(i+1, indx, span)) != -1);
+}
+
+static int
+_ArrayClipCount(int stI[], int endpI[], ArrayType *array)
+{
+ int n, *dim, *lb, st_pos, prod[MAXDIM];
+ int span[MAXDIM], dist[MAXDIM], indx[MAXDIM];
+ int i, j, inc, st[MAXDIM], endp[MAXDIM];
+ int count = 0;
+ char *ptr, *array_seek();
+
+ n = ARR_NDIM(array); dim = ARR_DIMS(array);
+ lb = ARR_LBOUND(array); ptr = ARR_DATA_PTR(array);
+ for (i = 0; i < n; st[i] = stI[i]-lb[i], endp[i]=endpI[i]-lb[i], i++);
+ mda_get_prod(n, dim, prod);
+ st_pos = tuple2linear(n, st, prod);
+ ptr = array_seek(ptr, -1, st_pos);
+ mda_get_range(n, span, st, endp);
+ mda_get_offset_values(n, dist, prod, span);
+ for (i=0; i < n; indx[i++]=0);
+ i = j = n-1;
+ do {
+ ptr = array_seek(ptr, -1, dist[j]);
+ inc = INTALIGN(* (int32 *) ptr);
+ ptr += inc; count += inc;
+ } while ((j = next_tuple(i+1, indx, span)) != -1);
+ return count;
+}
+
+char *
+array_seek(char *ptr, int eltsize, int nitems)
+{
+ int i;
+
+ if (eltsize > 0)
+ return(ptr + eltsize*nitems);
+ for (i = 0; i < nitems; i++)
+ ptr += INTALIGN(* (int32 *) ptr);
+ return(ptr);
+}
+
+int
+array_read(char *destptr, int eltsize, int nitems, char *srcptr)
+{
+ int i, inc, tmp;
+
+ if (eltsize > 0) {
+ memmove(destptr, srcptr, eltsize*nitems);
+ return(eltsize*nitems);
+ }
+ for (i = inc = 0; i < nitems; i++) {
+ tmp = (INTALIGN(* (int32 *) srcptr));
+ memmove(destptr, srcptr, tmp);
+ srcptr += tmp;
+ destptr += tmp;
+ inc += tmp;
+ }
+ return(inc);
+}
+
+static void
+_LOArrayRange(int st[],
+ int endp[],
+ int bsize,
+ int srcfd,
+ int destfd,
+ ArrayType *array,
+ int isSrcLO,
+ bool *isNull)
+{
+ int n, *dim, st_pos, prod[MAXDIM];
+ int span[MAXDIM], dist[MAXDIM], indx[MAXDIM];
+ int i, j, inc, tmp, *lb, offset;
+
+ n = ARR_NDIM(array); dim = ARR_DIMS(array);
+ lb = ARR_LBOUND(array);
+ for (i = 0; i < n; st[i] -= lb[i], endp[i] -= lb[i], i++);
+
+ mda_get_prod(n, dim, prod);
+ st_pos = tuple2linear(n, st, prod);
+ offset = st_pos*bsize;
+ if (lo_lseek(srcfd, offset, SEEK_SET) < 0)
+ return;
+ mda_get_range(n, span, st, endp);
+ mda_get_offset_values(n, dist, prod, span);
+ for (i=0; i < n; indx[i++]=0);
+ for (i = n-1, inc = bsize; i >= 0; inc *= span[i--])
+ if (dist[i])
+ break;
+ j = n-1;
+ do {
+ offset += (dist[j]*bsize);
+ if (lo_lseek(srcfd, offset, SEEK_SET) < 0)
+ return;
+ tmp = _LOtransfer((char**)&srcfd, inc, 1, (char**)&destfd, isSrcLO, 1);
+ if ( tmp < inc )
+ return;
+ offset += inc;
+ } while ((j = next_tuple(i+1, indx, span)) != -1);
+}
+
+
+static void
+_ReadArray (int st[],
+ int endp[],
+ int bsize,
+ int srcfd,
+ int destfd,
+ ArrayType *array,
+ int isDestLO,
+ bool *isNull)
+{
+ int n, *dim, st_pos, prod[MAXDIM];
+ int span[MAXDIM], dist[MAXDIM], indx[MAXDIM];
+ int i, j, inc, tmp, *lb, offset;
+
+ n = ARR_NDIM(array); dim = ARR_DIMS(array);
+ lb = ARR_LBOUND(array);
+ for (i = 0; i < n; st[i] -= lb[i], endp[i] -= lb[i], i++);
+
+ mda_get_prod(n, dim, prod);
+ st_pos = tuple2linear(n, st, prod);
+ offset = st_pos*bsize;
+ if (lo_lseek(srcfd, offset, SEEK_SET) < 0)
+ return;
+ mda_get_range(n, span, st, endp);
+ mda_get_offset_values(n, dist, prod, span);
+ for (i=0; i < n; indx[i++]=0);
+ for (i = n-1, inc = bsize; i >= 0; inc *= span[i--])
+ if (dist[i])
+ break;
+ j = n-1;
+ do {
+ offset += (dist[j]*bsize);
+ if (lo_lseek(srcfd, offset, SEEK_SET) < 0)
+ return;
+ tmp = _LOtransfer((char**)&destfd, inc, 1, (char**)&srcfd, 1, isDestLO);
+ if ( tmp < inc )
+ return;
+ offset += inc;
+ } while ((j = next_tuple(i+1, indx, span)) != -1);
+}
+
+
+int
+_LOtransfer(char **destfd,
+ int size,
+ int nitems,
+ char **srcfd,
+ int isSrcLO,
+ int isDestLO)
+{
+#define MAX_READ (512 * 1024)
+#define min(a, b) (a < b ? a : b)
+ struct varlena *v;
+ int tmp, inc, resid;
+
+ inc = nitems*size;
+ if (isSrcLO && isDestLO && inc > 0)
+ for (tmp = 0, resid = inc;
+ resid > 0 && (inc = min(resid, MAX_READ)) > 0; resid -= inc) {
+#ifdef LOARRAY
+ v = (struct varlena *) LOread((int) *srcfd, inc);
+ if (VARSIZE(v) - 4 < inc)
+ {pfree(v); return(-1);}
+ tmp += LOwrite((int) *destfd, v);
+#endif
+ pfree(v);
+
+ }
+ else if (!isSrcLO && isDestLO) {
+ tmp = lo_write((int) *destfd, *srcfd, inc);
+ *srcfd = *srcfd + tmp;
+ }
+ else if (isSrcLO && !isDestLO) {
+ tmp = lo_read((int) *srcfd, *destfd, inc);
+ *destfd = *destfd + tmp;
+ }
+ else {
+ memmove(*destfd, *srcfd, inc);
+ tmp = inc;
+ *srcfd += inc;
+ *destfd += inc;
+ }
+ return(tmp);
+#undef MAX_READ
+}
+
+char *
+_array_newLO(int *fd, int flag)
+{
+ char *p;
+ char saveName[NAME_LEN];
+
+ p = (char *) palloc(NAME_LEN);
+ sprintf(p, "/Arry.%d", newoid());
+ strcpy (saveName, p);
+#ifdef LOARRAY
+ if ( (*fd = LOcreat (saveName, 0600, flag)) < 0)
+ elog(WARN, "Large object create failed");
+#endif
+ return (p);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * arrayutils.c--
+ * This file contains some support routines required for array functions.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayutils.c,v 1.1.1.1 1996/07/09 06:22:03 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define WEAK_C_OPTIMIZER
+
+#include "c.h"
+
+int
+GetOffset(int n, int dim[], int lb[], int indx[])
+{
+ int i, scale, offset;
+ for (i = n-1, scale = 1, offset = 0; i >= 0; scale*=dim[i--])
+ offset += (indx[i] - lb[i])*scale;
+ return offset ;
+}
+
+int
+getNitems(int n, int a[])
+{
+ int i, ret;
+ for (i = 0, ret = 1; i < n; ret *= a[i++]);
+ if (n == 0) ret = 0;
+ return ret;
+}
+
+int
+compute_size(int st[], int endp[], int n, int base)
+{
+ int i, ret;
+ for (i = 0, ret = base; i < n; i++)
+ ret *= (endp[i] - st[i] + 1);
+ return ret;
+}
+
+void
+mda_get_offset_values(int n, int dist[], int PC[], int span[])
+{
+ int i, j;
+ for (j = n-2, dist[n-1]=0; j >= 0; j--)
+ for (i = j+1, dist[j] = PC[j]-1; i < n;
+ dist[j] -= (span[i] - 1)*PC[i], i++);
+}
+
+void
+mda_get_range(int n, int span[], int st[], int endp[])
+{
+ int i;
+ for (i= 0; i < n; i++)
+ span[i] = endp[i] - st[i] + 1;
+}
+
+void
+mda_get_prod(int n, int range[], int P[])
+{
+ int i;
+ for (i= n-2, P[n-1] = 1; i >= 0; i--)
+ P[i] = P[i+1] * range[i + 1];
+}
+
+int
+tuple2linear(int n, int tup[], int scale[])
+{
+ int i, lin;
+ for (i= lin = 0; i < n; i++)
+ lin += tup[i]*scale[i];
+ return lin;
+}
+
+void
+array2chunk_coord(int n, int C[], int a_coord[], int c_coord[])
+{
+ int i;
+ for (i= 0; i < n; i++)
+ c_coord[i] = a_coord[i]/C[i];
+}
+
+/*-----------------------------------------------------------------------------
+ generates the tuple that is lexicographically one greater than the current
+ n-tuple in "curr", with the restriction that the i-th element of "curr" is
+ less than the i-th element of "span".
+ RETURNS 0 if no next tuple exists
+ 1 otherwise
+ -----------------------------------------------------------------------------*/
+int
+next_tuple(int n, int curr[], int span[])
+{
+ int i;
+
+ if (!n) return(-1);
+ curr[n-1] = (curr[n-1]+1)%span[n-1];
+ for (i = n-1; i*(!curr[i]); i--)
+ curr[i-1] = (curr[i-1]+1)%span[i-1];
+
+ if (i)
+ return(i);
+ if (curr[0])
+ return(0);
+ return(-1);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * bool.c--
+ * Functions for the built-in type "bool".
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/bool.c,v 1.1.1.1 1996/07/09 06:22:03 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "utils/builtins.h" /* where the declarations go */
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+/*****************************************************************************
+ * USER I/O ROUTINES *
+ *****************************************************************************/
+
+/*
+ * boolin - converts "t" or "f" to 1 or 0
+ */
+int32
+boolin(char *b)
+{
+ if (b == NULL)
+ elog(WARN, "Bad input string for type bool");
+ return((int32) (*b == 't') || (*b == 'T'));
+}
+
+/*
+ * boolout - converts 1 or 0 to "t" or "f"
+ */
+char *
+boolout(long b)
+{
+ char *result = (char *) palloc(2);
+
+ *result = (b) ? 't' : 'f';
+ result[1] = '\0';
+ return(result);
+}
+
+/*****************************************************************************
+ * PUBLIC ROUTINES *
+ *****************************************************************************/
+
+int32
+booleq(int8 arg1, int8 arg2)
+{
+ return(arg1 == arg2);
+}
+
+int32
+boolne(int8 arg1, int8 arg2)
+{
+ return(arg1 != arg2);
+}
+
+
+
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * char.c--
+ * Functions for the built-in type "char".
+ * Functions for the built-in type "cid".
+ * Functions for the built-in type "char2".
+ * Functions for the built-in type "char4".
+ * Functions for the built-in type "char8".
+ * Functions for the built-in type "char16".
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/char.c,v 1.1.1.1 1996/07/09 06:22:03 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* for sprintf() */
+#include
+#include "postgres.h"
+#include "utils/palloc.h"
+#include "utils/builtins.h" /* where the declarations go */
+
+/*****************************************************************************
+ * USER I/O ROUTINES *
+ *****************************************************************************/
+
+/*
+ * charin - converts "x" to 'x'
+ */
+int32 charin(char *ch)
+{
+ if (ch == NULL)
+ return((int32) NULL);
+ return((int32) *ch);
+}
+
+/*
+ * charout - converts 'x' to "x"
+ */
+char *charout(int32 ch)
+{
+ char *result = (char *) palloc(2);
+
+ result[0] = (char) ch;
+ result[1] = '\0';
+ return(result);
+}
+
+/*
+ * cidin - converts "..." to internal representation.
+ *
+ * NOTE: we must not use 'charin' because cid might be a non
+ * printable character...
+ */
+int32 cidin(char *s)
+{
+ CommandId c;
+
+ if (s==NULL)
+ c = 0;
+ else
+ c = atoi(s);
+
+ return((int32)c);
+}
+
+/*
+ * cidout - converts a cid to "..."
+ *
+ * NOTE: we must no use 'charout' because cid might be a non
+ * printable character...
+ */
+char *cidout(int32 c)
+{
+ char *result;
+ CommandId c2;
+
+ /*
+ * cid is a number between 0 .. 2^16-1, therefore we need at most
+ * 6 chars for the string (5 digits + '\0')
+ * NOTE: print it as an UNSIGNED int!
+ */
+ result = palloc(6);
+ c2 = (CommandId)c;
+ sprintf(result, "%u", (unsigned)(c2));
+ return(result);
+}
+
+/*
+ * char16in - converts "..." to internal reprsentation
+ *
+ * Note:
+ * Currently if strlen(s) < 14, the extra chars are nulls
+ */
+char *char16in(char *s)
+{
+ char *result;
+
+ if (s == NULL)
+ return(NULL);
+ result = (char *) palloc(16);
+ memset(result, 0, 16);
+ (void) strncpy(result, s, 16);
+ return(result);
+}
+
+/*
+ * char16out - converts internal reprsentation to "..."
+ */
+char *char16out(char *s)
+{
+ char *result = (char *) palloc(17);
+
+ memset(result, 0, 17);
+ if (s == NULL) {
+ result[0] = '-';
+ } else {
+ strncpy(result, s, 16);
+ }
+ return(result);
+}
+
+
+/*****************************************************************************
+ * PUBLIC ROUTINES *
+ *****************************************************************************/
+
+int32 chareq(int8 arg1, int8 arg2) { return(arg1 == arg2); }
+int32 charne(int8 arg1, int8 arg2) { return(arg1 != arg2); }
+int32 charlt(int8 arg1, int8 arg2) { return(arg1 < arg2); }
+int32 charle(int8 arg1, int8 arg2) { return(arg1 <= arg2); }
+int32 chargt(int8 arg1, int8 arg2) { return(arg1 > arg2); }
+int32 charge(int8 arg1, int8 arg2) { return(arg1 >= arg2); }
+int8 charpl(int8 arg1, int8 arg2) { return(arg1 + arg2); }
+int8 charmi(int8 arg1, int8 arg2) { return(arg1 - arg2); }
+int8 charmul(int8 arg1, int8 arg2) { return(arg1 * arg2); }
+int8 chardiv(int8 arg1, int8 arg2) { return(arg1 / arg2); }
+
+int32 cideq(int8 arg1, int8 arg2) { return(arg1 == arg2); }
+
+/*
+ * char16eq - returns 1 iff arguments are equal
+ * char16ne - returns 1 iff arguments are not equal
+ *
+ * BUGS:
+ * Assumes that "xy\0\0a" should be equal to "xy\0b".
+ * If not, can do the comparison backwards for efficiency.
+ *
+ * char16lt - returns 1 iff a < b
+ * char16le - returns 1 iff a <= b
+ * char16gt - returns 1 iff a < b
+ * char16ge - returns 1 iff a <= b
+ *
+ */
+int32 char16eq(char *arg1, char *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ return(strncmp(arg1, arg2, 16) == 0);
+}
+
+int32 char16ne(char *arg1, char *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ return(strncmp(arg1, arg2, 16) != 0);
+}
+
+int32 char16lt(char *arg1, char *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ return((int32) (strncmp(arg1, arg2, 16) < 0));
+}
+
+int32 char16le(char *arg1, char *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ return((int32) (strncmp(arg1, arg2, 16) <= 0));
+}
+
+int32 char16gt(char *arg1, char *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+
+ return((int32) (strncmp(arg1, arg2, 16) > 0));
+}
+
+int32 char16ge(char *arg1, char *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+
+ return((int32) (strncmp(arg1, arg2, 16) >= 0));
+}
+
+
+/* ============================== char2 ============================== */
+uint16 char2in(char *s)
+{
+ uint16 res;
+
+ if (s == NULL)
+ return(0);
+
+ memset((char *) &res, 0, sizeof(res));
+ (void) strncpy((char *) &res, s, 2);
+ return(res);
+}
+
+char *char2out(uint16 s)
+{
+ char *result = (char *) palloc(3);
+
+ memset(result, 0, 3);
+ (void) strncpy(result, (char *) &s, 2);
+
+ return(result);
+}
+
+int32 char2eq(uint16 a, uint16 b)
+{
+ return(strncmp((char *) &a, (char *) &b, 2) == 0);
+}
+
+int32 char2ne(uint16 a, uint16 b)
+{
+ return(strncmp((char *) &a, (char *) &b, 2) != 0);
+}
+
+int32 char2lt(uint16 a, uint16 b)
+{
+ return(strncmp((char *) &a, (char *) &b, 2) < 0);
+}
+
+int32 char2le(uint16 a, uint16 b)
+{
+ return(strncmp((char *) &a, (char *) &b, 2) <= 0);
+}
+
+int32 char2gt(uint16 a, uint16 b)
+{
+ return(strncmp((char *) &a, (char *) &b, 2) > 0);
+}
+
+int32 char2ge(uint16 a, uint16 b)
+{
+ return(strncmp((char *) &a, (char *) &b, 2) >= 0);
+}
+
+int32 char2cmp(uint16 a, uint16 b)
+{
+ return (strncmp((char *) &a, (char *) &b, 2));
+}
+
+/* ============================== char4 ============================== */
+uint32 char4in(char *s)
+{
+ uint32 res;
+
+ if (s == NULL)
+ return(0);
+
+ memset((char *) &res, 0, sizeof(res));
+ (void) strncpy((char *) &res, s, 4);
+
+ return(res);
+}
+
+char *char4out(s)
+ uint32 s;
+{
+ char *result = (char *) palloc(5);
+
+ memset(result, 0, 5);
+ (void) strncpy(result, (char *) &s, 4);
+
+ return(result);
+}
+
+int32 char4eq(uint32 a, uint32 b)
+{
+ return(strncmp((char *) &a, (char *) &b, 4) == 0);
+}
+
+int32 char4ne(uint32 a, uint32 b)
+{
+ return(strncmp((char *) &a, (char *) &b, 4) != 0);
+}
+
+int32 char4lt(uint32 a, uint32 b)
+{
+ return(strncmp((char *) &a, (char *) &b, 4) < 0);
+}
+
+int32 char4le(uint32 a, uint32 b)
+{
+ return(strncmp((char *) &a, (char *) &b, 4) <= 0);
+}
+
+int32 char4gt(uint32 a, uint32 b)
+{
+ return(strncmp((char *) &a, (char *) &b, 4) > 0);
+}
+
+int32 char4ge(uint32 a, uint32 b)
+{
+ return(strncmp((char *) &a, (char *) &b, 4) >= 0);
+}
+
+int32 char4cmp(uint32 a, uint32 b)
+{
+ return(strncmp((char *) &a, (char *) &b, 4));
+}
+
+/* ============================== char8 ============================== */
+char *char8in(char *s)
+{
+ char *result;
+
+ if (s == NULL)
+ return((char *) NULL);
+
+ result = (char *) palloc(8);
+ memset(result, 0, 8);
+ (void) strncpy(result, s, 8);
+ return(result);
+}
+
+char *char8out(char *s)
+{
+ char *result = (char *) palloc(9);
+
+ memset(result, 0, 9);
+ if (s == NULL) {
+ result[0] = '-';
+ } else {
+ strncpy(result, s, 8);
+ }
+ return(result);
+}
+
+int32 char8eq(char *arg1, char *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ return(strncmp(arg1, arg2, 8) == 0);
+}
+
+int32 char8ne(char *arg1, char *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ return(strncmp(arg1, arg2, 8) != 0);
+}
+
+int32 char8lt(char *arg1, char *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ return(strncmp(arg1, arg2, 8) < 0);
+}
+
+int32 char8le(char *arg1, char *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ return(strncmp(arg1, arg2, 8) <= 0);
+}
+
+int32 char8gt(char *arg1, char *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ return(strncmp(arg1, arg2, 8) > 0);
+}
+
+int32 char8ge(char *arg1, char *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ return(strncmp(arg1, arg2, 8) >= 0);
+}
+
+int32 char8cmp(char *arg1, char *arg2)
+{
+ return(strncmp(arg1, arg2, 8));
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * chunk.c--
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/chunk.c,v 1.1.1.1 1996/07/09 06:22:03 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "postgres.h"
+#include "utils/memutils.h"
+#include "libpq/libpq-fs.h"
+
+#include "storage/fd.h" /* for SEEK_ */
+
+#include "catalog/pg_type.h"
+
+#include "utils/palloc.h"
+#include "fmgr.h"
+#include "utils/elog.h"
+#include "utils/array.h"
+
+#include "optimizer/internal.h"
+
+#define INFTY 500000000
+#define MANY 10000
+#define MAXPAT 20
+#define quot_ceil(x,y) (((x)+(y)-1)/(y))
+#define min(x,y) (((x) < (y))? (x) : (y))
+#define max(x,y) (((x) > (y))? (x) : (y))
+
+static CHUNK_INFO cInfo;
+
+/* non-export function prototypes */
+static int _FindBestChunk(int size, int dmax[], int dbest[], int dim,
+ int A[MAXPAT][MAXDIM+1], int N);
+static int get_next(int d[], int k, int C, int dmax[]);
+static void initialize_info(CHUNK_INFO *A, int ndim, int dim[], int chunk[]);
+static void _ConvertToChunkFile(int n, int baseSize, int dim[], int C[],
+ int srcfd, int destfd);
+static void read_chunk(int chunk_no[], int C[], char a_chunk[], int srcfd,
+ int n, int baseSize, int PX[], int dist[]);
+static int write_chunk(struct varlena * a_chunk, int ofile);
+static int seek_and_read(int pos, int size, char buff[], int fp, int from);
+
+/*------------------------------------------------------------------------
+ * _ChunkArray ---
+ * converts an input array to chunked format using the information
+ * provided by the access pattern.
+ * Results:
+ * creates a new file that stores the chunked array and returns
+ * information about the chunked file
+ *-----------------------------------------------------------------------
+ */
+char *
+_ChunkArray(int fd,
+ FILE *afd,
+ int ndim,
+ int dim[],
+ int baseSize,
+ int *nbytes,
+ char *chunkfile)
+{
+ int cfd;
+ int chunk[MAXDIM], csize;
+ bool reorgFlag;
+
+ if (chunkfile == NULL)
+ reorgFlag = true;
+ else
+ reorgFlag = false;
+
+#ifdef LOARRAY
+ if (reorgFlag)
+ /* create new LO for chunked file */
+ chunkfile = _array_newLO( &cfd, fileFlag );
+ else
+ cfd = LOopen(chunkfile, O_RDONLY);
+#endif
+ if (cfd < 0)
+ elog(WARN, "Enable to open chunk file");
+ strcpy (cInfo.lo_name, chunkfile);
+
+ /* find chunk size */
+ csize = GetChunkSize(afd, ndim, dim, baseSize, chunk);
+
+ if (reorgFlag)
+ /* copy data from input file to chunked file */
+ _ConvertToChunkFile(ndim, baseSize, dim, chunk, fd, cfd);
+
+ initialize_info(&cInfo, ndim, dim, chunk);
+ *nbytes = sizeof(CHUNK_INFO);
+ return (char *) &cInfo ;
+}
+
+/*--------------------------------------------------------------------------
+ * GetChunkSize --
+ * given an access pattern and array dimensionality etc, this program
+ * returns the dimensions of the chunk in "d"
+ *-----------------------------------------------------------------------
+ */
+int
+GetChunkSize(FILE *fd,
+ int ndim,
+ int dim[MAXDIM],
+ int baseSize,
+ int d[MAXDIM])
+{
+ int N, i, j, csize;
+ int A[MAXPAT][MAXDIM+1], dmax[MAXDIM];
+
+ /*
+ * ----------- read input ------------
+ */
+ fscanf(fd, "%d", &N);
+ if ( N > MAXPAT )
+ elog(WARN, "array_in: too many access pattern elements");
+ for (i = 0; i < N; i++)
+ for (j = 0; j < ndim+1; j++)
+ if (fscanf(fd, "%d ", &(A[i][j])) == EOF)
+ elog (WARN, "array_in: bad access pattern input");
+
+ /*
+ * estimate chunk size
+ */
+ for (i = 0; i < ndim; i++)
+ for (j = 0, dmax[i] = 1; j < N; j++)
+ if (dmax[i] < A[j][i])
+ dmax[i] = A[j][i];
+ csize = _PAGE_SIZE_/baseSize;
+
+ _FindBestChunk (csize, dmax, d, ndim, A, N);
+
+ return csize;
+}
+
+/*-------------------------------------------------------------------------
+ * _FindBestChunk --
+ * This routine does most of the number crunching to compute the
+ * optimal chunk shape.
+ * Called by GetChunkSize
+ *------------------------------------------------------------------------
+ */
+static int
+_FindBestChunk(int size,
+ int dmax[],
+ int dbest[],
+ int dim,
+ int A[MAXPAT][MAXDIM+1],
+ int N)
+{
+ int d[MAXDIM];
+ int tc, mintc = INFTY;
+
+ d[0] = 0;
+ mintc = INFTY;
+ while (get_next(d,dim,size, dmax)) {
+ /*
+ * compute the number of page fetches for a given
+ * chunk size (d[]) and access pattern (A[][])
+ */
+ register int i,j, nc;
+ for (i = 0, tc = 0; i < N; i++){
+ for (j = 0, nc = 1; j < dim; j++)
+ nc *= quot_ceil(A[i][j], d[j]);
+ nc *= A[i][dim];
+ tc += nc;
+ }
+ /*
+ * tc holds the total number of page fetches
+ */
+ if (mintc >= tc) {
+ mintc = tc;
+ for (j = 0; j < dim; dbest[j] = d[j], j++)
+ ;
+ }
+ }
+ return(mintc);
+}
+
+/*----------------------------------------------------------------------
+ * get_next --
+ * Called by _GetBestChunk to get the next tuple in the lexicographic order
+ *---------------------------------------------------------------------
+ */
+static int
+get_next(int d[], int k, int C, int dmax[])
+{
+ register int i,j, temp;
+
+ if (!d[0]) {
+ temp = C;
+ for (j = k-1; j >= 0; j--){
+ d[j] = min(temp, dmax[j]);
+ temp = max(1, temp/d[j]);
+ }
+ return(1);
+ }
+
+ for (j = 0, temp = 1; j < k; j++)
+ temp *= d[j];
+
+ for (i=k-1; i >= 0; i--){
+ temp = temp/d[i];
+ if (((temp*(d[i]+1)) < C) && (d[i]+1 <= dmax[i]))
+ break;
+ }
+ if (i < 0)
+ return(0);
+
+ d[i]++;
+ j = C/temp;
+ d[i] = min(dmax[i], j/(j/d[i]));
+ temp = temp*d[i];
+ temp = C/temp;
+
+ for (j = k-1; j > i; j--){
+ d[j] = min(temp, dmax[j]);
+ temp = max(1, temp/d[j]);
+ }
+ return(1);
+}
+
+static char a_chunk[_PAGE_SIZE_ + 4]; /* 4 since a_chunk is in
+ varlena format */
+
+static void
+initialize_info(CHUNK_INFO *A, int ndim, int dim[], int chunk[])
+{
+ int i;
+
+ for ( i = 0; i < ndim; i++)
+ A->C[i] = chunk[i];
+}
+
+/*--------------------------------------------------------------------------
+ * Procedure reorganize_data():
+ * This procedure reads the input multidimensional array that is organised
+ * in the order specified by array "X" and breaks it up into chunks of
+ * dimensions specified in "C".
+ *
+ * This is a very slow process, since reading and writing of LARGE files
+ * may be involved.
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+_ConvertToChunkFile(int n,
+ int baseSize,
+ int dim[],
+ int C[],
+ int srcfd,
+ int destfd)
+{
+ int max_chunks[MAXDIM], chunk_no[MAXDIM];
+ int PX[MAXDIM], dist[MAXDIM];
+ int csize = 1, i, temp;
+
+ for (i = 0; i < n; chunk_no[i++] = 0) {
+ max_chunks[i] = dim[i]/C[i];
+ csize *= C[i];
+ }
+ csize *= baseSize;
+ temp = csize + 4;
+ memmove(a_chunk, &temp, 4);
+
+ mda_get_prod(n, dim, PX);
+ mda_get_offset_values(n, dist, PX, C);
+ for (i = 0; i < n; dist[i] *= baseSize, i++)
+ ;
+ do {
+ read_chunk(chunk_no, C, &(a_chunk[4]), srcfd, n, baseSize, PX, dist);
+ write_chunk((struct varlena*)a_chunk, destfd);
+ } while (next_tuple(n, chunk_no, max_chunks) != -1);
+}
+
+/*--------------------------------------------------------------------------
+ * read_chunk
+ * reads a chunk from the input files into a_chunk, the position of the
+ * chunk is specified by chunk_no
+ *--------------------------------------------------------------------------
+ */
+static void
+read_chunk(int chunk_no[],
+ int C[],
+ char a_chunk[],
+ int srcfd,
+ int n,
+ int baseSize,
+ int PX[],
+ int dist[])
+{
+ int i, j, cp, unit_transfer;
+ int start_pos, pos[MAXDIM];
+ int indx[MAXDIM];
+ int fpOff;
+
+ for ( i = start_pos = 0; i < n; i++) {
+ pos[i] = chunk_no[i] * C[i];
+ start_pos += pos[i]*PX[i];
+ }
+ start_pos *= baseSize;
+
+ /* Read a block of dimesion C starting at co-ordinates pos */
+ unit_transfer = C[n-1] * baseSize;
+
+ for (i = 0; i < n; indx[i++] = 0)
+ ;
+ fpOff = start_pos;
+ seek_and_read(fpOff, unit_transfer, a_chunk, srcfd, SEEK_SET);
+ fpOff += unit_transfer;
+ cp = unit_transfer;
+
+ while ((j = next_tuple(n-1, indx, C)) != -1) {
+ fpOff += dist[j];
+ seek_and_read(fpOff, unit_transfer, &(a_chunk[cp]), srcfd, SEEK_SET);
+ cp += unit_transfer;
+ fpOff += unit_transfer;
+ }
+}
+
+/*--------------------------------------------------------------------------
+ * write_chunk()
+ * writes a chunk of size csize into the output file
+ *--------------------------------------------------------------------------
+ */
+static int
+write_chunk(struct varlena * a_chunk, int ofile)
+{
+ int got_n;
+#ifdef LOARRAY
+ got_n = LOwrite (ofile, a_chunk);
+#endif
+ return(got_n);
+}
+
+/*--------------------------------------------------------------------------
+ * seek_and_read()
+ * seeks to the asked location in the input file and reads the
+ * appropriate number of blocks
+ * Called By: read_chunk()
+ *--------------------------------------------------------------------------
+ */
+static int
+seek_and_read(int pos, int size, char buff[], int fp, int from)
+{
+ struct varlena *v;
+
+ /* Assuming only one file */
+ if ( lo_lseek(fp, pos, from ) < 0)
+ elog(WARN, "File seek error");
+#ifdef LOARRAY
+ v = (struct varlena *) LOread(fp, size);
+#endif
+ if (VARSIZE(v) - 4 < size)
+ elog(WARN, "File read error");
+ memmove(buff, VARDATA(v), size);
+ pfree(v);
+ return(1);
+
+}
+
+/*----------------------------------------------------------------------------
+ * _ReadChunkArray --
+ * returns the subarray specified bu the range indices "st" and "endp"
+ * from the chunked array stored in file "fp"
+ *---------------------------------------------------------------------------
+ */
+int
+_ReadChunkArray(int st[],
+ int endp[],
+ int bsize,
+ int fp,
+ char *destfp,
+ ArrayType *array,
+ int isDestLO,
+ bool *isNull)
+{
+ int i,j,jj;
+ int n, temp, words_read;
+ int chunk_span[MAXDIM], chunk_off[MAXDIM];
+ int chunk_st[MAXDIM], chunk_end[MAXDIM];
+ int block_seek;
+
+ int bptr, *C, csize, *dim, *lb;
+ int range_st[MAXDIM], range_end[MAXDIM],
+ range[MAXDIM], array_span[MAXDIM];
+ int PA[MAXDIM], PCHUNK[MAXDIM], PC[MAXDIM];
+ int to_read;
+ int cdist[MAXDIM], adist[MAXDIM];
+ int dist[MAXDIM], temp_seek;
+
+ int srcOff; /* Needed since LO don't understand SEEK_CUR*/
+ char *baseDestFp = (char *)destfp;
+
+ CHUNK_INFO *A = (CHUNK_INFO *) ARR_DATA_PTR(array);
+ n = ARR_NDIM(array);
+ dim = ARR_DIMS(array);
+ lb = ARR_LBOUND(array);
+ C = A->C;
+
+ csize = C[n-1];
+ PC[n-1] = 1;
+ temp = dim[n - 1]/C[n-1];
+ for (i = n-2; i >= 0; i--){
+ PC[i] = PC[i+1] * temp;
+ temp = dim[i] / C[i];
+ csize *= C[i];
+ }
+
+ for (i = 0; i < n; st[i] -= lb[i], endp[i] -= lb[i], i++)
+ ;
+ mda_get_prod(n, C, PCHUNK);
+ mda_get_range(n, array_span, st, endp);
+ mda_get_prod(n, array_span, PA);
+
+ array2chunk_coord(n, C, st, chunk_st);
+ array2chunk_coord(n, C, endp, chunk_end);
+ mda_get_range(n, chunk_span, chunk_st, chunk_end);
+ mda_get_offset_values(n, dist, PC, chunk_span);
+
+ for (i = 0; i < n; i++) {
+ range_st[i] = st[i];
+ range_end[i] = min(chunk_st[i]*C[i]+C[i]-1, endp[i]);
+ }
+
+ for (i = j = 0; i < n; i++)
+ j+= chunk_st[i]*PC[i];
+ temp_seek = srcOff = j * csize * bsize;
+ if (lo_lseek(fp, srcOff, SEEK_SET) < 0) RETURN_NULL;
+
+ jj = n-1;
+ for (i = 0; i < n; chunk_off[i++] = 0)
+ ;
+ words_read = 0; temp_seek = 0;
+ do {
+ /* Write chunk (chunk_st) to output buffer */
+ mda_get_range(n, array_span, range_st, range_end);
+ mda_get_offset_values(n, adist, PA, array_span);
+ mda_get_offset_values(n, cdist, PCHUNK, array_span);
+ for (i=0; i < n; range[i] = range_st[i]-st[i], i++);
+ bptr = tuple2linear(n, range, PA);
+ for (i = 0; i < n; range[i++] = 0);
+ j = n-1; bptr *= bsize;
+ if (isDestLO) {
+ if (lo_lseek(destfp, bptr, SEEK_SET) < 0)
+ RETURN_NULL;
+ }
+ else
+ destfp = baseDestFp + bptr;
+ for(i = 0, block_seek = 0; i < n; i++)
+ block_seek += (range_st[i]-(chunk_st[i] + chunk_off[i])
+ *C[i])*PCHUNK[i];
+ if (dist[jj] + block_seek + temp_seek) {
+ temp = (dist[jj]*csize+block_seek+temp_seek)*bsize;
+ srcOff += temp;
+ if (lo_lseek(fp, srcOff, SEEK_SET) < 0)
+ RETURN_NULL;
+ }
+ for (i = n-1, to_read = bsize; i >= 0;
+ to_read *= min(C[i], array_span[i]), i--)
+ if (cdist[i] || adist[i])
+ break;
+ do {
+ if (cdist[j]) {
+ srcOff += (cdist[j]*bsize);
+ if (lo_lseek(fp, srcOff, SEEK_SET) < 0)
+ RETURN_NULL;
+ }
+ block_seek += cdist[j];
+ bptr += adist[j]*bsize;
+ if (isDestLO) {
+ if (lo_lseek(destfp, bptr, SEEK_SET) < 0)
+ RETURN_NULL;
+ }
+ else
+ destfp = baseDestFp + bptr;
+ temp = _LOtransfer ((char**)&destfp, to_read, 1, (char**)&fp, 1, isDestLO);
+ if (temp < to_read)
+ RETURN_NULL;
+ srcOff += to_read;
+ words_read+=to_read;
+ bptr += to_read;
+ block_seek += (to_read/bsize);
+ /*
+ * compute next tuple in range[]
+ */
+ {
+ int x;
+ if (!(i+1))
+ j = -1;
+ else {
+ range[i] = (range[i]+1)%array_span[i];
+ for (x = i; x*(!range[x]); x--)
+ range[x-1] = (range[x-1]+1)%array_span[x-1];
+ if (x)
+ j = x;
+ else {
+ if (range[0])
+ j = 0;
+ else
+ j = -1;
+ }
+ }
+ }
+ /*
+ * end of compute next tuple --
+ * j is set to -1 if tuple generation is over
+ */
+ } while (j != -1);
+
+ block_seek = csize - block_seek;
+ temp_seek = block_seek;
+ jj = next_tuple(n, chunk_off, chunk_span);
+ if (jj == -1)
+ break;
+ range_st[jj] = (chunk_st[jj]+chunk_off[jj])*C[jj];
+ range_end[jj] = min(range_st[jj] + C[jj]-1, endp[jj]);
+
+ for (i = jj+1; i < n; i++) {
+ range_st[i] = st[i];
+ range_end[i] = min((chunk_st[i]+chunk_off[i])*C[i]+C[i]-1, endp[i]);
+ }
+ } while (jj != -1);
+ return(words_read);
+}
+
+/*------------------------------------------------------------------------
+ * _ReadChunkArray1El --
+ * returns one element of the chunked array as specified by the index "st"
+ * the chunked file descriptor is "fp"
+ *-------------------------------------------------------------------------
+ */
+struct varlena *
+_ReadChunkArray1El(int st[],
+ int bsize,
+ int fp,
+ ArrayType *array,
+ bool *isNull)
+{
+ int i, j, n, temp, srcOff;
+ int chunk_st[MAXDIM];
+
+ int *C, csize, *dim, *lb;
+ int PCHUNK[MAXDIM], PC[MAXDIM];
+
+ CHUNK_INFO *A = (CHUNK_INFO *) ARR_DATA_PTR(array);
+
+ n = ARR_NDIM(array);
+ lb = ARR_LBOUND(array);
+ C = A->C;
+ dim = ARR_DIMS(array);
+
+ csize = C[n-1];
+ PC[n-1] = 1;
+ temp = dim[n - 1]/C[n-1];
+ for (i = n-2; i >= 0; i--){
+ PC[i] = PC[i+1] * temp;
+ temp = dim[i] / C[i];
+ csize *= C[i];
+ }
+
+ for (i = 0; i < n; st[i] -= lb[i], i++);
+ mda_get_prod(n, C, PCHUNK);
+
+ array2chunk_coord(n, C, st, chunk_st);
+
+ for (i = j = 0; i < n; i++)
+ j+= chunk_st[i]*PC[i];
+ srcOff = j * csize;
+
+ for(i = 0; i < n; i++)
+ srcOff += (st[i]-chunk_st[i]*C[i])*PCHUNK[i];
+
+ srcOff *= bsize;
+ if (lo_lseek(fp, srcOff, SEEK_SET) < 0)
+ RETURN_NULL;
+#ifdef LOARRAY
+ return (struct varlena *) LOread(fp, bsize);
+#endif
+ return (struct varlena *) 0;
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * date.c--
+ * Functions for the built-in type "AbsoluteTime".
+ * Functions for the built-in type "RelativeTime".
+ * Functions for the built-in type "TimeInterval".
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.1.1.1 1996/07/09 06:22:03 scrappy Exp $
+ *
+ * NOTES
+ * This code is actually (almost) unused.
+ * It needs to be integrated with Time and struct trange.
+ *
+ * XXX This code needs to be rewritten to work with the "new" definitions
+ * XXX in h/tim.h. Look for int32's, int, long, etc. in the code. The
+ * XXX definitions in h/tim.h may need to be rethought also.
+ *
+ * XXX This code has been cleaned up some - avi 07/07/93
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "postgres.h"
+#include "miscadmin.h"
+#include "access/xact.h"
+#include "utils/builtins.h" /* where function declarations go */
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/nabstime.h"
+
+#define TM_YEAR_BASE 1900 /* compatible to UNIX time */
+#define EPOCH_YEAR 1970 /* compatible to UNIX time */
+#define YEAR_MAX 2038 /* otherwise overflow */
+#define YEAR_MIN 1902 /* otherwise overflow */
+#define DAYS_PER_LYEAR 366
+#define DAYS_PER_NYEAR 365
+#define HOURS_PER_DAY 24
+#define MINS_PER_HOUR 60
+#define SECS_PER_MIN 60
+#define MAX_LONG 2147483647 /* 2^31 */
+
+/* absolute time definitions */
+#define TIME_NOW_STR "now" /* represents time now */
+#define TIME_EPOCH_STR "epoch" /* Jan 1 00:00:00 1970 GMT */
+#define TIME_EPOCH_STR_LEN (sizeof(TIME_EPOCH_STR)-1)
+
+#define INVALID_ABSTIME_STR "Undefined AbsTime"
+#define INVALID_ABSTIME_STR_LEN (sizeof(INVALID_ABSTIME_STR)-1)
+
+#define INVALID_RELTIME_STR "Undefined RelTime"
+#define INVALID_RELTIME_STR_LEN (sizeof(INVALID_RELTIME_STR)-1)
+#define RELTIME_LABEL '@'
+#define RELTIME_PAST "ago"
+#define DIRMAXLEN (sizeof(RELTIME_PAST)-1)
+
+/*
+ * Unix epoch is Jan 1 00:00:00 1970. Postgres knows about times
+ * sixty-eight years on either side of that.
+ */
+
+#define IsCharDigit(C) isdigit(C)
+#define IsCharA_Z(C) isalpha(C)
+#define IsSpace(C) ((C) == ' ')
+#define IsNull(C) ((C) == NULL)
+
+#define T_INTERVAL_INVAL 0 /* data represents no valid interval */
+#define T_INTERVAL_VALID 1 /* data represents a valid interval */
+/*
+ * ['Mon May 10 23:59:12 1943 PST' 'Sun Jan 14 03:14:21 1973 PST']
+ * 0 1 2 3 4 5 6
+ * 1234567890123456789012345678901234567890123456789012345678901234
+ *
+ * we allocate some extra -- timezones are usually 3 characters but
+ * this is not in the POSIX standard...
+ */
+#define T_INTERVAL_LEN 80
+#define INVALID_INTERVAL_STR "Undefined Range"
+#define INVALID_INTERVAL_STR_LEN (sizeof(INVALID_INTERVAL_STR)-1)
+
+#define ABSTIMEMIN(t1, t2) abstimele((t1),(t2)) ? (t1) : (t2)
+#define ABSTIMEMAX(t1, t2) abstimelt((t1),(t2)) ? (t2) : (t1)
+
+static char *month_name[] = {
+ "Jan","Feb","Mar","Apr","May","Jun","Jul",
+ "Aug","Sep","Oct","Nov","Dec" };
+
+static char *unit_tab[] = {
+ "second", "seconds", "minute", "minutes",
+ "hour", "hours", "day", "days", "week", "weeks",
+ "month", "months", "year", "years"};
+#define UNITMAXLEN 7 /* max length of a unit name */
+#define NUNITS 14 /* number of different units */
+
+/* table of seconds per unit (month = 30 days, year = 365 days) */
+static int sec_tab[] = {
+ 1,1, 60, 60,
+ 3600, 3600, 86400, 86400, 604800, 604800,
+ 2592000, 2592000, 31536000, 31536000 };
+
+/* maximal values (in seconds) per unit which can be represented */
+static int unit_max_quantity[] = {
+ 2144448000, 2144448000, 35740800, 35740800,
+ 595680, 595680, 24820, 24820, 3545, 3545,
+ 827, 827, 68, 68 };
+
+
+struct timeb *TimeDifferenceFromGMT = NULL;
+static bool TimeDiffIsInited = false;
+static char *timezonename = NULL;
+
+/*
+ * Function prototypes -- internal to this file only
+ */
+static int correct_unit(char unit[], int *unptr);
+static int correct_dir(char direction[], int *signptr);
+static int istinterval(char *i_string,
+ AbsoluteTime *i_start,
+ AbsoluteTime *i_end);
+
+/*****************************************************************************
+ * USER I/O ROUTINES *
+ *****************************************************************************/
+
+/*
+ * reltimein - converts a reltime string in an internal format
+ */
+int32 /* RelativeTime */
+reltimein(char *timestring)
+{
+ int error;
+ int32 /* RelativeTime */ timeinsec;
+ int sign, unitnr;
+ long quantity;
+
+ error = isreltime(timestring, &sign, &quantity, &unitnr);
+
+#ifdef DATEDEBUG
+ elog(DEBUG, "reltimein: isreltime(%s) returns error=%d, %d, %d, %d",
+ timestring, error, sign, quantity, unitnr);
+#endif /* !DATEDEBUG */
+
+ if (error != 1) {
+ timeinsec = INVALID_RELTIME; /*invalid time representation */
+ } else {
+ /* this check is necessary, while no control on overflow */
+ if (quantity > unit_max_quantity[unitnr] || quantity < 0) {
+#ifdef DATEDEBUG
+ elog(DEBUG, "reltimein: illegal quantity %d (< %d)",
+ quantity, unit_max_quantity[unitnr]);
+#endif /* DATEDEBUG */
+ timeinsec = INVALID_RELTIME; /* illegal quantity */
+ } else {
+ timeinsec = sign * quantity * sec_tab[unitnr];
+#ifdef DATEDEBUG
+ elog(DEBUG, "reltimein: computed timeinsec %d",
+ timeinsec);
+#endif /* DATEDEBUG */
+ }
+ }
+ return(timeinsec);
+}
+
+
+/*
+ * reltimeout - converts the internal format to a reltime string
+ */
+char *reltimeout(int32 timevalue)
+{
+ char *timestring;
+ long quantity;
+ register int i;
+ int unitnr;
+
+ timestring = (char *) palloc(Max(strlen(INVALID_RELTIME_STR),
+ UNITMAXLEN) + 1);
+ if (timevalue == INVALID_RELTIME) {
+ (void) strcpy(timestring,INVALID_RELTIME_STR);
+ return(timestring);
+ }
+ if (timevalue == 0)
+ i = 1; /* unit = 'seconds' */
+ else
+ for (i = 12; i >= 0; i = i-2)
+ if ((timevalue % sec_tab[i]) == 0)
+ break; /* appropriate unit found */
+ unitnr = i;
+ quantity = (timevalue / sec_tab[unitnr]);
+ if (quantity > 1 || quantity < -1)
+ unitnr++; /* adjust index for PLURAL of unit */
+ if (quantity >= 0)
+ (void) sprintf( timestring, "%c %lu %s", RELTIME_LABEL,
+ quantity, unit_tab[unitnr]);
+ else
+ (void) sprintf( timestring, "%c %lu %s %s", RELTIME_LABEL,
+ (quantity * -1), unit_tab[unitnr], RELTIME_PAST);
+ return(timestring);
+}
+
+
+/*
+ * tintervalin - converts an interval string to an internal format
+ */
+TimeInterval tintervalin(char *intervalstr)
+{
+ int error;
+ AbsoluteTime i_start, i_end, t1, t2;
+ TimeInterval interval;
+
+ interval = (TimeInterval) palloc(sizeof(TimeIntervalData));
+ error = istinterval(intervalstr, &t1, &t2);
+ if (error == 0)
+ interval->status = T_INTERVAL_INVAL;
+ if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
+ interval->status = T_INTERVAL_INVAL; /* undefined */
+ else {
+ i_start = ABSTIMEMIN(t1, t2);
+ i_end = ABSTIMEMAX(t1, t2);
+ interval->data[0] = i_start;
+ interval->data[1] = i_end;
+ interval->status = T_INTERVAL_VALID;
+ }
+ return(interval);
+}
+
+
+/*
+ * tintervalout - converts an internal interval format to a string
+ *
+ */
+char *tintervalout(TimeInterval interval)
+{
+ char *i_str, *p;
+
+ i_str = (char *) palloc( T_INTERVAL_LEN ); /* ['...' '...'] */
+ (void) strcpy(i_str,"['");
+ if (interval->status == T_INTERVAL_INVAL)
+ (void) strcat(i_str,INVALID_INTERVAL_STR);
+ else {
+ p = nabstimeout(interval->data[0]);
+ (void) strcat(i_str,p);
+ pfree(p);
+ (void) strcat(i_str,"' '");
+ p = nabstimeout(interval->data[1]);
+ (void) strcat(i_str,p);
+ pfree(p);
+ }
+ (void) strcat(i_str,"']\0");
+ return(i_str);
+}
+
+
+/*****************************************************************************
+ * PUBLIC ROUTINES *
+ *****************************************************************************/
+
+/*
+ * mktinterval - creates a time interval with endpoints t1 and t2
+ */
+TimeInterval mktinterval(AbsoluteTime t1, AbsoluteTime t2)
+{
+ AbsoluteTime tstart = ABSTIMEMIN(t1, t2), tend = ABSTIMEMAX(t1, t2);
+ TimeInterval interval;
+
+ interval = (TimeInterval) palloc(sizeof(TimeIntervalData));
+ if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
+ interval->status = T_INTERVAL_INVAL;
+ else {
+ interval->status = T_INTERVAL_VALID;
+ interval->data[0] = tstart;
+ interval->data[1] = tend;
+ }
+
+ return interval;
+}
+
+/*
+ * timepl, timemi and abstimemi use the formula
+ * abstime + reltime = abstime
+ * so abstime - reltime = abstime
+ * and abstime - abstime = reltime
+ */
+
+/*
+ * timepl - returns the value of (abstime t1 + relime t2)
+ */
+AbsoluteTime timepl(AbsoluteTime t1, RelativeTime t2)
+{
+ if (t1 == CURRENT_ABSTIME)
+ t1 = GetCurrentTransactionStartTime();
+
+ if (AbsoluteTimeIsReal(t1) &&
+ RelativeTimeIsValid(t2) &&
+ ((t2 > 0) ? (t1 < NOEND_ABSTIME - t2)
+ : (t1 > NOSTART_ABSTIME - t2))) /* prevent overflow */
+ return (t1 + t2);
+
+ return(INVALID_ABSTIME);
+}
+
+
+/*
+ * timemi - returns the value of (abstime t1 - reltime t2)
+ */
+AbsoluteTime timemi(AbsoluteTime t1, RelativeTime t2)
+{
+ if (t1 == CURRENT_ABSTIME)
+ t1 = GetCurrentTransactionStartTime();
+
+ if (AbsoluteTimeIsReal(t1) &&
+ RelativeTimeIsValid(t2) &&
+ ((t2 > 0) ? (t1 > NOSTART_ABSTIME + t2)
+ : (t1 < NOEND_ABSTIME + t2))) /* prevent overflow */
+ return (t1 - t2);
+
+ return(INVALID_ABSTIME);
+}
+
+
+/*
+ * abstimemi - returns the value of (abstime t1 - abstime t2)
+ */
+static RelativeTime abstimemi(AbsoluteTime t1, AbsoluteTime t2)
+{
+ if (t1 == CURRENT_ABSTIME)
+ t1 = GetCurrentTransactionStartTime();
+ if (t2 == CURRENT_ABSTIME)
+ t2 = GetCurrentTransactionStartTime();
+
+ if (AbsoluteTimeIsReal(t1) &&
+ AbsoluteTimeIsReal(t2))
+ return (t1 - t2);
+
+ return(INVALID_RELTIME);
+}
+
+
+/*
+ * ininterval - returns 1, iff absolute date is in the interval
+ */
+int ininterval(AbsoluteTime t, TimeInterval interval)
+{
+ if (interval->status == T_INTERVAL_VALID && t != INVALID_ABSTIME)
+ return (abstimege(t, interval->data[0]) &&
+ abstimele(t, interval->data[1]));
+ return(0);
+}
+
+/*
+ * intervalrel - returns relative time corresponding to interval
+ */
+RelativeTime intervalrel(TimeInterval interval)
+{
+ if (interval->status == T_INTERVAL_VALID)
+ return(abstimemi(interval->data[1], interval->data[0]));
+ else
+ return(INVALID_RELTIME);
+}
+
+/*
+ * timenow - returns time "now", internal format
+ *
+ * Now AbsoluteTime is time since Jan 1 1970 -mer 7 Feb 1992
+ */
+AbsoluteTime timenow()
+{
+ time_t sec;
+ if (time(&sec) < 0)
+ return(INVALID_ABSTIME);
+ return((AbsoluteTime) sec);
+}
+
+/*
+ * reltimeeq - returns 1, iff arguments are equal
+ * reltimene - returns 1, iff arguments are not equal
+ * reltimelt - returns 1, iff t1 less than t2
+ * reltimegt - returns 1, iff t1 greater than t2
+ * reltimele - returns 1, iff t1 less than or equal to t2
+ * reltimege - returns 1, iff t1 greater than or equal to t2
+ */
+int32 reltimeeq(RelativeTime t1, RelativeTime t2)
+{
+ if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
+ return 0;
+ return(t1 == t2);
+}
+
+int32 reltimene(RelativeTime t1, RelativeTime t2)
+{
+ if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
+ return 0;
+ return(t1 != t2);
+}
+
+int32 reltimelt(RelativeTime t1, RelativeTime t2)
+{
+ if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
+ return 0;
+ return(t1 < t2);
+}
+
+int32 reltimegt(RelativeTime t1, RelativeTime t2)
+{
+ if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
+ return 0;
+ return(t1 > t2);
+}
+
+int32 reltimele(RelativeTime t1, RelativeTime t2)
+{
+ if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
+ return 0;
+ return(t1 <= t2);
+}
+
+int32 reltimege(RelativeTime t1, RelativeTime t2)
+{
+ if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
+ return 0;
+ return(t1 >= t2);
+}
+
+
+/*
+ * intervaleq - returns 1, iff interval i1 is equal to interval i2
+ */
+int32 intervaleq(TimeInterval i1, TimeInterval i2)
+{
+ if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
+ return(0); /* invalid interval */
+ return(abstimeeq(i1->data[0], i2->data[0]) &&
+ abstimeeq(i1->data[1], i2->data[1]));
+}
+
+/*
+ * intervalleneq - returns 1, iff length of interval i is equal to
+ * reltime t
+ */
+int32 intervalleneq(TimeInterval i, RelativeTime t)
+{
+ RelativeTime rt;
+
+ if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
+ return(0);
+ rt = intervalrel(i);
+ return (rt != INVALID_RELTIME && rt == t);
+}
+
+/*
+ * intervallenne - returns 1, iff length of interval i is not equal
+ * to reltime t
+ */
+int32 intervallenne(TimeInterval i, RelativeTime t)
+{
+ RelativeTime rt;
+
+ if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
+ return(0);
+ rt = intervalrel(i);
+ return (rt != INVALID_RELTIME && rt != t);
+}
+
+/*
+ * intervallenlt - returns 1, iff length of interval i is less than
+ * reltime t
+ */
+int32 intervallenlt(TimeInterval i, RelativeTime t)
+{
+ RelativeTime rt;
+
+ if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
+ return(0);
+ rt = intervalrel(i);
+ return (rt != INVALID_RELTIME && rt < t);
+}
+
+/*
+ * intervallengt - returns 1, iff length of interval i is greater than
+ * reltime t
+ */
+int32 intervallengt(TimeInterval i, RelativeTime t)
+{
+ RelativeTime rt;
+
+ if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
+ return(0);
+ rt = intervalrel(i);
+ return (rt != INVALID_RELTIME && rt > t);
+}
+
+/*
+ * intervallenle - returns 1, iff length of interval i is less or equal
+ * than reltime t
+ */
+int32 intervallenle(TimeInterval i, RelativeTime t)
+{
+ RelativeTime rt;
+
+ if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
+ return(0);
+ rt = intervalrel(i);
+ return (rt != INVALID_RELTIME && rt <= t);
+}
+
+/*
+ * intervallenge - returns 1, iff length of interval i is greater or
+ * equal than reltime t
+ */
+int32 intervallenge(TimeInterval i, RelativeTime t)
+{
+ RelativeTime rt;
+
+ if ((i->status == T_INTERVAL_INVAL) || (t == INVALID_RELTIME))
+ return(0);
+ rt = intervalrel(i);
+ return (rt != INVALID_RELTIME && rt >= t);
+}
+
+/*
+ * intervalct - returns 1, iff interval i1 contains interval i2
+ */
+int32 intervalct(TimeInterval i1, TimeInterval i2)
+{
+ if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
+ return(0);
+ return(abstimele(i1->data[0], i2->data[0]) &&
+ abstimege(i1->data[1], i2->data[1]));
+}
+
+/*
+ * intervalov - returns 1, iff interval i1 (partially) overlaps i2
+ */
+int32 intervalov(TimeInterval i1, TimeInterval i2)
+{
+ if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
+ return(0);
+ return(! (abstimelt(i1->data[1], i2->data[0]) ||
+ abstimegt(i1->data[0], i2->data[1])));
+}
+
+/*
+ * intervalstart - returns the start of interval i
+ */
+AbsoluteTime intervalstart(TimeInterval i)
+{
+ if (i->status == T_INTERVAL_INVAL)
+ return INVALID_ABSTIME;
+ return(i->data[0]);
+}
+
+/*
+ * intervalend - returns the end of interval i
+ */
+AbsoluteTime intervalend(TimeInterval i)
+{
+ if (i->status == T_INTERVAL_INVAL)
+ return INVALID_ABSTIME;
+ return(i->data[1]);
+}
+
+
+/*****************************************************************************
+ * PRIVATE ROUTINES *
+ *****************************************************************************/
+
+/*
+ * isreltime - returns 1, iff datestring is of type reltime
+ * 2, iff datestring is 'invalid time' identifier
+ * 0, iff datestring contains a syntax error
+ *
+ * output parameter:
+ * sign = -1, iff direction is 'ago'
+ * else sign = 1.
+ * quantity : quantity of unit
+ * unitnr : 0 or 1 ... sec
+ * 2 or 3 ... min
+ * 4 or 5 ... hour
+ * 6 or 7 ... day
+ * 8 or 9 ... week
+ * 10 or 11... month
+ * 12 or 13... year
+ *
+ *
+ * Relative time:
+ *
+ * `@' ` ' Quantity ` ' Unit [ ` ' Direction]
+ *
+ * OR `Undefined RelTime' (see also INVALID_RELTIME_STR)
+ *
+ * where
+ * Quantity is `1', `2', ...
+ * Unit is `second', `minute', `hour', `day', `week',
+ * `month' (30-days), or `year' (365-days),
+ * or PLURAL of these units.
+ * Direction is `ago'
+ *
+ * VALID time less or equal `@ 68 years'
+ *
+ */
+int isreltime(char *timestring, int *sign, long *quantity, int *unitnr)
+{
+ register char *p;
+ register char c;
+ int i;
+ char unit[UNITMAXLEN] ;
+ char direction[DIRMAXLEN];
+ int localSign;
+ int localUnitNumber;
+ long localQuantity;
+
+ if (!PointerIsValid(sign)) {
+ sign = &localSign;
+ }
+ if (!PointerIsValid(unitnr)) {
+ unitnr = &localUnitNumber;
+ }
+ if (!PointerIsValid(quantity)) {
+ quantity = &localQuantity;
+ }
+ unit[0] = '\0';
+ direction[0] = '\0';
+ p = timestring;
+ /* skip leading blanks */
+ while ((c = *p) != '\0') {
+ if (c != ' ')
+ break;
+ p++;
+ }
+ /* Test whether 'invalid time' identifier or not */
+ if (!strncmp(INVALID_RELTIME_STR,p,strlen(INVALID_RELTIME_STR) + 1))
+ return(2); /* correct 'invalid time' identifier found */
+
+ /* handle label of relative time */
+ if (c != RELTIME_LABEL)
+ return(0); /*syntax error*/
+ c = *++p;
+ if (c != ' ') return(0); /*syntax error*/
+ p++;
+ /* handle the quantity */
+ *quantity = 0;
+ for (;;) {
+ c = *p;
+ if (isdigit(c)) {
+ *quantity = *quantity * 10 + (c -'0');
+ p++;
+ } else {
+ if (c == ' ' )
+ break; /* correct quantity found */
+ else
+ return(0); /* syntax error */
+ }
+ }
+ /* handle unit */
+ p++;
+ i = 0;
+ for (;;) {
+ c = *p;
+ if (c >= 'a' && c <= 'z' && i <= (UNITMAXLEN - 1)) {
+ unit[i] = c;
+ p++;
+ i++;
+ } else {
+ if ((c == ' ' || c == '\0')
+ && correct_unit(unit, unitnr))
+ break; /* correct unit found */
+ else
+ return(0); /* syntax error */
+ }
+ }
+ /* handle optional direction */
+ if (c == ' ')
+ p++;
+ i = 0;
+ *sign = 1;
+ for (;;) {
+ c = *p;
+ if (c >= 'a' && c <= 'z' && i <= (DIRMAXLEN - 1)) {
+ direction[i] = c;
+ p++;
+ i++;
+ } else {
+ if ((c == ' ' || c == '\0') && i == 0) {
+ *sign = 1;
+ break; /* no direction specified */
+ }
+ if ((c == ' ' || c == '\0') && i != 0)
+ {
+ direction[i] = '\0';
+ correct_dir(direction, sign);
+ break; /* correct direction found */
+ }
+ else
+ return(0); /* syntax error*/
+ }
+ }
+ return(1);
+}
+
+/*
+ * correct_unit - returns 1, iff unit is a correct unit description
+ *
+ * output parameter:
+ * unptr: points to an integer which is the appropriate unit number
+ * (see function isreltime())
+ */
+static int correct_unit(char unit[], int *unptr)
+{
+ int j = 0;
+
+ while (j < NUNITS) {
+ if (strncmp(unit, unit_tab[j], strlen(unit_tab[j])) == 0) {
+ *unptr = j;
+ return(1);
+ }
+ j++;
+ }
+ return (0); /* invalid unit descriptor */
+}
+
+/*
+ * correct_dir - returns 1, iff direction is a correct identifier
+ *
+ * output parameter:
+ * signptr: points to -1 if dir corresponds to past tense
+ * else to 1
+ */
+static int correct_dir(char direction[], int *signptr)
+{
+ *signptr = 1;
+ if (strncmp(RELTIME_PAST, direction, strlen(RELTIME_PAST)+1) == 0)
+ {
+ *signptr = -1;
+ return(1);
+ } else
+ return (0); /* invalid direction descriptor */
+}
+
+
+/*
+ * istinterval - returns 1, iff i_string is a valid interval descr.
+ * 0, iff i_string is NOT a valid interval desc.
+ * 2, iff any time is INVALID_ABSTIME
+ *
+ * output parameter:
+ * i_start, i_end: interval margins
+ *
+ * Time interval:
+ * `[' {` '} `''
`'' {` '} `'' `'' {` '} `]'+ *
+ * OR `Undefined Range' (see also INVALID_INTERVAL_STR)
+ *
+ * where
satisfies the syntax of absolute time.+ *
+ * e.g. [ ' Jan 18 1902' 'Jan 1 00:00:00 1970']
+ */
+static int istinterval(char *i_string,
+ AbsoluteTime *i_start,
+ AbsoluteTime *i_end)
+{
+ register char *p,*p1;
+ register char c;
+
+ p = i_string;
+ /* skip leading blanks up to '[' */
+ while ((c = *p) != '\0') {
+ if ( IsSpace(c))
+ p++;
+ else if (c != '[')
+ return(0); /* syntax error */
+ else
+ break;
+ }
+ p++;
+ /* skip leading blanks up to "'" */
+ while ((c = *p) != '\0') {
+ if (IsSpace(c))
+ p++;
+ else if (c != '"')
+ return (0); /* syntax error */
+ else
+ break;
+ }
+ p++;
+ if (strncmp(INVALID_INTERVAL_STR,p,strlen(INVALID_INTERVAL_STR)) == 0)
+ return(0); /* undefined range, handled like a syntax err.*/
+ /* search for the end of the first date and change it to a NULL*/
+ p1 = p;
+ while ((c = *p1) != '\0') {
+ if ( c == '"') {
+ *p1 = '\0';
+ break;
+ }
+ p1++;
+ }
+ /* get the first date */
+ *i_start = nabstimein(p); /* first absolute date */
+ /* rechange NULL at the end of the first date to a "'" */
+ *p1 = '"';
+ p = ++p1;
+ /* skip blanks up to "'", beginning of second date*/
+ while ((c = *p) != '\0') {
+ if (IsSpace(c))
+ p++;
+ else if (c != '"')
+ return (0); /* syntax error */
+ else
+ break;
+ }
+ p++;
+ /* search for the end of the second date and change it to a NULL*/
+ p1 = p;
+ while ((c = *p1) != '\0') {
+ if ( c == '"') {
+ *p1 = '\0';
+ break;
+ }
+ p1++;
+ }
+ /* get the second date */
+ *i_end = nabstimein(p); /* second absolute date */
+ /* rechange NULL at the end of the first date to a ''' */
+ *p1 = '"';
+ p = ++p1;
+ /* skip blanks up to ']'*/
+ while ((c = *p) != '\0') {
+ if ( IsSpace(c))
+ p++;
+ else if (c != ']')
+ return(0); /*syntax error */
+ else
+ break;
+ }
+ p++;
+ c = *p;
+ if ( c != '\0' )
+ return (0); /* syntax error */
+ /* it seems to be a valid interval */
+ return(1);
+}
+
+
+/*****************************************************************************
+ *
+ *****************************************************************************/
+
+/*
+ * timeofday -
+ * returns the current time as a text. similar to timenow() but returns
+ * seconds with more precision (up to microsecs). (I need this to compare
+ * the Wisconsin benchmark with Illustra whose TimeNow() shows current
+ * time with precision up to microsecs.) - ay 3/95
+ */
+text *
+timeofday()
+{
+
+#ifndef WIN32
+ struct timeval tp;
+ struct timezone tpz;
+#endif /* WIN32 */
+ char templ[500];
+ char buf[500];
+ text *tm;
+ int len = 0;
+
+#ifndef WIN32
+ gettimeofday(&tp, &tpz);
+ (void) strftime(templ, sizeof(templ), "%a %b %d %H:%M:%S.%%d %Y %Z",
+ localtime((time_t *) &tp.tv_sec));
+ sprintf(buf, templ, tp.tv_usec);
+
+ len = VARHDRSZ + strlen(buf);
+ tm = (text *)palloc(len);
+ VARSIZE(tm) = len;
+ strncpy(VARDATA(tm), buf, strlen(buf));
+ return tm;
+#else
+ len = len / len;
+ return tm;
+#endif /* WIN32 */
+
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * datetimes.c--
+ * implements DATE and TIME data types specified in SQL-92 standard
+ *
+ * Copyright (c) 1994-5, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/datetimes.c,v 1.1.1.1 1996/07/09 06:22:03 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* for sprintf() */
+#include
+#include "postgres.h"
+#include "utils/palloc.h"
+#include "utils/elog.h"
+
+/* these things look like structs, but we pass them by value so be careful
+ For example, passing an int -> DateADT is not portable! */
+typedef struct DateADT {
+ char day;
+ char month;
+ short year;
+} DateADT;
+
+typedef struct TimeADT {
+ short hr;
+ short min;
+ float sec;
+} TimeADT;
+
+#ifndef EUROPEAN_STYLE
+#define AMERICAN_STYLE
+#endif
+
+static int day_tab[2][12] = {
+ {31,28,31,30,31,30,31,31,30,31,30,31},
+ {31,29,31,30,31,30,31,31,30,31,30,31} };
+
+static int
+isleap(int year)
+{
+ return
+ (((year % 4) == 0 && (year % 100) != 0) || (year % 400) == 0);
+}
+
+/*****************************************************************************
+ * Date ADT
+ *****************************************************************************/
+
+int4
+date_in(char *datestr)
+{
+ int d, m, y;
+ int4 result;
+ DateADT *date = (DateADT*)&result;
+
+#ifdef USE_SHORT_YEAR
+#define CHECK_DATE_LEN(datestr) (strlen(datestr) >= 8)
+#else
+#define CHECK_DATE_LEN(datestr) (strlen(datestr) == 10)
+#endif /* USE_SHORT_YEAR */
+
+#ifdef AMERICAN_STYLE
+ if (!CHECK_DATE_LEN(datestr) ||
+ sscanf(datestr, "%d%*c%d%*c%d", &m, &d, &y) != 3) {
+ elog(WARN, "date_in: date \"%s\" not of the form mm-dd-yyyy",
+ datestr);
+ }
+#else
+ if (!CHECK_DATE_LEN(datestr) ||
+ sscanf(datestr, "%d%*c%d%*c%d", &d, &m, &y) != 3) {
+ elog(WARN, "date_in: date \"%s\" not of the form dd-mm-yyyy",
+ datestr);
+ }
+#endif
+ if (m < 1 || m > 12)
+ elog(WARN, "date_in: month must be limited to values 1 through 12 in \"%s\"", datestr);
+ if (d < 1 || d > day_tab[isleap(y)][m-1])
+ elog(WARN, "date_in: day must be limited to values 1 through %d in \"%s\"",
+ day_tab[isleap(y)][m-1], datestr);
+
+#ifdef USE_SHORT_YEAR
+ if (y < 100)
+ y += 1900; /* hack! */
+#endif /* USE_SHORT_YEAR */
+
+ date->day = d;
+ date->month = m;
+ date->year = y;
+ return result;
+}
+
+char *
+date_out(int4 dateVal)
+{
+ char *datestr = palloc(11);
+ int4 dateStore;
+ DateADT *date;
+
+ /* DateADT is a structure that happens to be four bytes long,
+ trust me on this.... */
+ date = (DateADT*)&dateStore;
+ dateStore = dateVal;
+
+#ifdef AMERICAN_STYLE
+ sprintf(datestr, "%02d-%02d-%04d",
+ (int)date->month, (int)date->day, (int)date->year);
+#else
+ sprintf(datestr, "%02d-%02d-%04d",
+ (int)date->day, (int)date->month, (int)date->year);
+#endif
+
+ return datestr;
+}
+
+
+int
+date_eq(int4 dateVal1, int4 dateVal2)
+{
+ int4 dateStore1 = dateVal1;
+ int4 dateStore2 = dateVal2;
+ DateADT *date1, *date2;
+
+ date1 = (DateADT*)&dateStore1;
+ date2 = (DateADT*)&dateStore2;
+
+ return (date1->day==date2->day &&
+ date1->month==date2->month &&
+ date1->year==date2->year);
+}
+
+int
+date_ne(int4 dateVal1, int4 dateVal2)
+{
+ int4 dateStore1 = dateVal1;
+ int4 dateStore2 = dateVal2;
+ DateADT *date1, *date2;
+
+ date1 = (DateADT*)&dateStore1;
+ date2 = (DateADT*)&dateStore2;
+
+ return (date1->day!=date2->day || date1->month!=date2->month ||
+ date1->year!=date2->year);
+}
+
+int
+date_lt(int4 dateVal1, int4 dateVal2)
+{
+ int4 dateStore1 = dateVal1;
+ int4 dateStore2 = dateVal2;
+ DateADT *date1, *date2;
+
+ date1 = (DateADT*)&dateStore1;
+ date2 = (DateADT*)&dateStore2;
+
+ if (date1->year!=date2->year)
+ return (date1->yearyear);
+ if (date1->month!=date2->month)
+ return (date1->monthmonth);
+ return (date1->dayday);
+}
+
+int
+date_le(int4 dateVal1, int4 dateVal2)
+{
+
+ int4 dateStore1 = dateVal1;
+ int4 dateStore2 = dateVal2;
+ DateADT *date1, *date2;
+
+ date1 = (DateADT*)&dateStore1;
+ date2 = (DateADT*)&dateStore2;
+
+ if (date1->year!=date2->year)
+ return (date1->year<=date2->year);
+ if (date1->month!=date2->month)
+ return (date1->month<=date2->month);
+ return (date1->day<=date2->day);
+}
+
+int
+date_gt(int4 dateVal1, int4 dateVal2)
+{
+ int4 dateStore1 = dateVal1;
+ int4 dateStore2 = dateVal2;
+ DateADT *date1, *date2;
+
+ date1 = (DateADT*)&dateStore1;
+ date2 = (DateADT*)&dateStore2;
+
+
+ if (date1->year!=date2->year)
+ return (date1->year>date2->year);
+ if (date1->month!=date2->month)
+ return (date1->month>date2->month);
+ return (date1->day>date2->day);
+}
+
+int
+date_ge(int4 dateVal1, int4 dateVal2)
+{
+ int4 dateStore1 = dateVal1;
+ int4 dateStore2 = dateVal2;
+ DateADT *date1, *date2;
+
+ date1 = (DateADT*)&dateStore1;
+ date2 = (DateADT*)&dateStore2;
+
+ if (date1->year!=date2->year)
+ return (date1->year>=date2->year);
+ if (date1->month!=date2->month)
+ return (date1->month>=date2->month);
+ return (date1->day>=date2->day);
+}
+
+int
+date_cmp(int4 dateVal1, int4 dateVal2)
+{
+ int4 dateStore1 = dateVal1;
+ int4 dateStore2 = dateVal2;
+ DateADT *date1, *date2;
+
+ date1 = (DateADT*)&dateStore1;
+ date2 = (DateADT*)&dateStore2;
+
+ if (date1->year!=date2->year)
+ return ((date1->yearyear) ? -1 : 1);
+ if (date1->month!=date2->month)
+ return ((date1->monthmonth) ? -1 : 1);
+ if (date1->day!=date2->day)
+ return ((date1->dayday) ? -1 : 1);
+ return 0;
+}
+
+/*****************************************************************************
+ * Time ADT
+ *****************************************************************************/
+
+char *
+time_in(char *timestr)
+{
+ int h, m;
+ float sec;
+ TimeADT *time;
+
+ if (sscanf(timestr, "%d%*c%d%*c%f", &h, &m, &sec) != 3) {
+ elog(WARN, "time_in: time \"%s\" not of the form hh:mm:ss",
+ timestr);
+ }
+
+ if (h < 0 || h > 23)
+ elog(WARN, "time_in: hour must be limited to values 0 through 23 in \"%s\"", timestr);
+ if (m < 0 || m > 59)
+ elog(WARN, "time_in: minute must be limited to values 0 through 59 in \"%s\"", timestr);
+ if (sec < 0 || sec >= 62.0)
+ elog(WARN, "time_in: second must be limited to values 0 through 61.99 in \"%s\"", timestr);
+
+ time = (TimeADT*)palloc(sizeof(TimeADT));
+ time->hr = h;
+ time->min = m;
+ time->sec = sec;
+ return (char*)time;
+}
+
+char *
+time_out(TimeADT *time)
+{
+ char *timestr = palloc(16);
+
+ sprintf(timestr, "%02d:%02d:%09.6f",
+ (int)time->hr, (int)time->min, time->sec);
+
+ return timestr;
+}
+
+
+int
+time_eq(TimeADT *time1, TimeADT *time2)
+{
+ return (time1->sec==time2->sec && time1->min==time2->min &&
+ time1->hr==time2->hr);
+}
+
+int
+time_ne(TimeADT *time1, TimeADT *time2)
+{
+ return (time1->sec!=time2->sec || time1->min!=time2->min ||
+ time1->hr!=time2->hr);
+}
+
+int
+time_lt(TimeADT *time1, TimeADT *time2)
+{
+ if (time1->hr!=time2->hr)
+ return (time1->hrhr);
+ if (time1->min!=time2->min)
+ return (time1->minmin);
+ return (time1->secsec);
+}
+
+int
+time_le(TimeADT *time1, TimeADT *time2)
+{
+ if (time1->hr!=time2->hr)
+ return (time1->hr<=time2->hr);
+ if (time1->min!=time2->min)
+ return (time1->min<=time2->min);
+ return (time1->sec<=time2->sec);
+}
+
+int
+time_gt(TimeADT *time1, TimeADT *time2)
+{
+ if (time1->hr!=time2->hr)
+ return (time1->hr>time2->hr);
+ if (time1->min!=time2->min)
+ return (time1->min>time2->min);
+ return (time1->sec>time2->sec);
+}
+
+int
+time_ge(TimeADT *time1, TimeADT *time2)
+{
+ if (time1->hr!=time2->hr)
+ return (time1->hr>=time2->hr);
+ if (time1->min!=time2->min)
+ return (time1->min>=time2->min);
+ return (time1->sec>=time2->sec);
+}
+
+int
+time_cmp(TimeADT *time1, TimeADT *time2)
+{
+ if (time1->hr!=time2->hr)
+ return ((time1->hrhr) ? -1 : 1);
+ if (time1->min!=time2->min)
+ return ((time1->minmin) ? -1 : 1);
+ if (time1->sec!=time2->sec)
+ return ((time1->secsec) ? -1 : 1);
+ return 0;
+}
+
+int32 /* RelativeTime */
+int42reltime(int32 timevalue)
+{
+ return(timevalue);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * datum.c--
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/datum.c,v 1.1.1.1 1996/07/09 06:22:03 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ * In the implementation of the next routines we assume the following:
+ *
+ * A) if a type is "byVal" then all the information is stored in the
+ * Datum itself (i.e. no pointers involved!). In this case the
+ * length of the type is always greater than zero and less than
+ * "sizeof(Datum)"
+ * B) if a type is not "byVal" and it has a fixed length, then
+ * the "Datum" always contain a pointer to a stream of bytes.
+ * The number of significant bytes are always equal to the length of the
+ * type.
+ * C) if a type is not "byVal" and is of variable length (i.e. it has
+ * length == -1) then "Datum" always points to a "struct varlena".
+ * This varlena structure has information about the actual length of this
+ * particular instance of the type and about its value.
+ *
+ */
+#include
+#include "postgres.h"
+#include "utils/datum.h"
+#include "catalog/pg_type.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+/*-------------------------------------------------------------------------
+ * datumGetSize
+ *
+ * Find the "real" size of a datum, given the datum value,
+ * its type, whether it is a "by value", and its length.
+ *
+ * To cut a long story short, usually the real size is equal to the
+ * type length, with the exception of variable length types which have
+ * a length equal to -1. In this case, we have to look at the value of
+ * the datum itself (which is a pointer to a 'varlena' struct) to find
+ * its size.
+ *-------------------------------------------------------------------------
+ */
+Size
+datumGetSize(Datum value, Oid type, bool byVal, Size len)
+{
+
+ struct varlena *s;
+ Size size;
+
+ if (byVal) {
+ if (len >= 0 && len <= sizeof(Datum)) {
+ size = len;
+ } else {
+ elog(WARN,
+ "datumGetSize: Error: type=%ld, byVaL with len=%d",
+ (long) type, len);
+ }
+ } else { /* not byValue */
+ if (len == -1) {
+ /*
+ * variable length type
+ * Look at the varlena struct for its real length...
+ */
+ s = (struct varlena *) DatumGetPointer(value);
+ if (!PointerIsValid(s)) {
+ elog(WARN,
+ "datumGetSize: Invalid Datum Pointer");
+ }
+ size = (Size) VARSIZE(s);
+ } else {
+ /*
+ * fixed length type
+ */
+ size = len;
+ }
+ }
+
+ return(size);
+}
+
+/*-------------------------------------------------------------------------
+ * datumCopy
+ *
+ * make a copy of a datum
+ *
+ * If the type of the datum is not passed by value (i.e. "byVal=false")
+ * then we assume that the datum contains a pointer and we copy all the
+ * bytes pointed by this pointer
+ *-------------------------------------------------------------------------
+ */
+Datum
+datumCopy(Datum value, Oid type, bool byVal, Size len)
+{
+
+ Size realSize;
+ Datum res;
+ char *s;
+
+
+ if (byVal) {
+ res = value;
+ } else {
+ if (value == 0) return((Datum)NULL);
+ realSize = datumGetSize(value, type, byVal, len);
+ /*
+ * the value is a pointer. Allocate enough space
+ * and copy the pointed data.
+ */
+ s = (char *) palloc(realSize);
+ if (s == NULL) {
+ elog(WARN,"datumCopy: out of memory\n");
+ }
+ memmove(s, DatumGetPointer(value), realSize);
+ res = (Datum)s;
+ }
+ return(res);
+}
+
+/*-------------------------------------------------------------------------
+ * datumFree
+ *
+ * Free the space occupied by a datum CREATED BY "datumCopy"
+ *
+ * NOTE: DO NOT USE THIS ROUTINE with datums returned by amgetattr() etc.
+ * ONLY datums created by "datumCopy" can be freed!
+ *-------------------------------------------------------------------------
+ */
+void
+datumFree(Datum value, Oid type, bool byVal, Size len)
+{
+
+ Size realSize;
+ Pointer s;
+
+ realSize = datumGetSize(value, type, byVal, len);
+
+ if (!byVal) {
+ /*
+ * free the space palloced by "datumCopy()"
+ */
+ s = DatumGetPointer(value);
+ pfree(s);
+ }
+}
+
+/*-------------------------------------------------------------------------
+ * datumIsEqual
+ *
+ * Return true if two datums are equal, false otherwise
+ *
+ * NOTE: XXX!
+ * We just compare the bytes of the two values, one by one.
+ * This routine will return false if there are 2 different
+ * representations of the same value (something along the lines
+ * of say the representation of zero in one's complement arithmetic).
+ *
+ *-------------------------------------------------------------------------
+ */
+bool
+datumIsEqual(Datum value1, Datum value2, Oid type, bool byVal, Size len)
+{
+ Size size1, size2;
+ char *s1, *s2;
+
+ if (byVal) {
+ /*
+ * just compare the two datums.
+ * NOTE: just comparing "len" bytes will not do the
+ * work, because we do not know how these bytes
+ * are aligned inside the "Datum".
+ */
+ if (value1 == value2)
+ return(true);
+ else
+ return(false);
+ } else {
+ /*
+ * byVal = false
+ * Compare the bytes pointed by the pointers stored in the
+ * datums.
+ */
+ size1 = datumGetSize(value1, type, byVal, len);
+ size2 = datumGetSize(value2, type, byVal, len);
+ if (size1 != size2)
+ return(false);
+ s1 = (char *) DatumGetPointer(value1);
+ s2 = (char *) DatumGetPointer(value2);
+ if (!memcmp(s1, s2, size1))
+ return(true);
+ else
+ return(false);
+ }
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * dt.c--
+ * Functions for the built-in type "dt".
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/dt.c,v 1.1.1.1 1996/07/09 06:22:04 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "c.h"
+#include "utils/palloc.h"
+#include "utils/builtins.h" /* where function declarations go */
+
+
+/*****************************************************************************
+ * USER I/O ROUTINES *
+ *****************************************************************************/
+
+/*
+ * dtin - converts "nseconds" to internal representation
+ *
+ * XXX Currently, just creates an integer.
+ */
+int32 dtin(char *datetime)
+{
+ if (datetime == NULL)
+ return((int32) 0);
+ return((int32) atol(datetime));
+}
+
+/*
+ * dtout - converts internal form to "..."
+ *
+ * XXX assumes sign, 10 digits max, '\0'
+ */
+char *dtout(int32 datetime)
+{
+ char *result;
+
+ result = (char *) palloc(12);
+ Assert(result);
+ ltoa(datetime, result);
+ return(result);
+}
+
+/*****************************************************************************
+ * PUBLIC ROUTINES *
+ *****************************************************************************/
+/* (see int.c for comparison/operation routines) */
+
+/*****************************************************************************
+ * PRIVATE ROUTINES *
+ *****************************************************************************/
+/* (none) */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * filename.c--
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/filename.c,v 1.1.1.1 1996/07/09 06:22:04 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#ifndef WIN32
+#endif /* WIN32 */
+
+#include
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/builtins.h" /* where function declarations go */
+
+char *
+filename_in(char *file)
+{
+ char *str, *getenv();
+ int ind;
+
+ /*
+ * XXX - HACK CITY --- REDO
+ * should let the shell do expansions (shexpand)
+ */
+
+#ifndef WIN32
+ str = (char *) palloc(MAXPATHLEN * sizeof(*str));
+ str[0] = '\0';
+ if (file[0] == '~') {
+ if (file[1] == '\0' || file[1] == '/') {
+ /* Home directory */
+
+ char *userName;
+ struct passwd *pw;
+
+ userName = GetPgUserName();
+
+ if ((pw = getpwnam(userName)) == NULL) {
+ elog(WARN, "User %s is not a Unix user on the db server.",
+ userName);
+ }
+
+ strcpy(str, pw->pw_dir);
+
+ ind = 1;
+ } else {
+ /* Someone else's directory */
+ char name[16], *p;
+ struct passwd *pw;
+ int len;
+
+ if ((p = (char *) strchr(file, '/')) == NULL) {
+ strcpy(name, file+1);
+ len = strlen(name);
+ } else {
+ len = (p - file) - 1;
+ strncpy(name, file+1, len);
+ name[len] = '\0';
+ }
+ /*printf("name: %s\n");*/
+ if ((pw = getpwnam(name)) == NULL) {
+ elog(WARN, "No such user: %s\n", name);
+ ind = 0;
+ } else {
+ strcpy(str, pw->pw_dir);
+ ind = len + 1;
+ }
+ }
+ } else if (file[0] == '$') { /* $POSTGRESHOME, etc. expand it. */
+ char environment[80], *envirp, *p;
+ int len;
+
+ if ((p = (char *) strchr(file, '/')) == NULL) {
+ strcpy(environment, file+1);
+ len = strlen(environment);
+ } else {
+ len = (p - file) - 1;
+ strncpy(environment, file+1, len);
+ environment[len] = '\0';
+ }
+ envirp = getenv(environment);
+ if (envirp) {
+ strcpy(str, envirp);
+ ind = len + 1;
+ }
+ else {
+ elog(WARN,"Couldn't find %s in your environment", environment);
+ }
+ } else {
+ ind = 0;
+ }
+ strcat(str, file+ind);
+ return(str);
+#else
+ return(NULL);
+#endif /* WIN32 */
+}
+
+char *
+filename_out(char *s)
+{
+ char *ret;
+
+ if (!s)
+ return((char *) NULL);
+ ret = (char *) palloc(strlen(s) + 1);
+ if (!ret)
+ elog(WARN, "filename_out: palloc failed");
+ return(strcpy(ret, s));
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * float.c--
+ * Functions for the built-in floating-point types.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/float.c,v 1.1.1.1 1996/07/09 06:22:04 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ * OLD COMMENTS
+ * Basic float4 ops:
+ * float4in, float4out, float4abs, float4um
+ * Basic float8 ops:
+ * float8in, float8inAd, float8out, float8outAd, float8abs, float8um
+ * Arithmetic operators:
+ * float4pl, float4mi, float4mul, float4div
+ * float8pl, float8mi, float8mul, float8div
+ * Comparison operators:
+ * float4eq, float4ne, float4lt, float4le, float4gt, float4ge
+ * float8eq, float8ne, float8lt, float8le, float8gt, float8ge
+ * Conversion routines:
+ * ftod, dtof
+ *
+ * Random float8 ops:
+ * dround, dtrunc, dsqrt, dcbrt, dpow, dexp, dlog1
+ * Arithmetic operators:
+ * float48pl, float48mi, float48mul, float48div
+ * float84pl, float84mi, float84mul, float84div
+ * Comparison operators:
+ * float48eq, float48ne, float48lt, float48le, float48gt, float48ge
+ * float84eq, float84ne, float84lt, float84le, float84gt, float84ge
+ *
+ * (You can do the arithmetic and comparison stuff using conversion
+ * routines, but then you pay the overhead of converting...)
+ *
+ * XXX GLUESOME STUFF. FIX IT! -AY '94
+ */
+#include /* for sprintf() */
+#include
+#include
+#include
+#include
+
+#include /* faked on sunos4 */
+
+#include
+
+#include "postgres.h"
+#include "fmgr.h"
+#include "utils/builtins.h" /* for ftod() prototype */
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+
+#define FORMAT 'g' /* use "g" output format as standard format */
+/* not sure what the following should be, but better to make it over-sufficient */
+#define MAXFLOATWIDTH 64
+#define MAXDOUBLEWIDTH 128
+
+#if !(NeXT && NX_CURRENT_COMPILER_RELEASE > NX_COMPILER_RELEASE_3_2)
+ /* NS3.3 has conflicting declarations of these in */
+
+#ifndef atof
+extern double atof(const char *p);
+#endif
+
+#ifdef NEED_CBRT
+#define cbrt my_cbrt
+static double cbrt(double x);
+#else /* NEED_CBRT */
+extern double cbrt(double x);
+#endif /* NEED_CBRT */
+
+#ifdef NEED_RINT
+#define rint my_rint
+static double rint(double x);
+#else /* NEED_RINT */
+extern double rint(double x);
+#endif /* NEED_RINT */
+
+#ifdef NEED_ISINF
+#define isinf my_isinf
+static int isinf(double x);
+#else /* NEED_ISINF */
+extern int isinf(double x);
+#endif /* NEED_ISINF */
+
+#endif
+/* ========== USER I/O ROUTINES ========== */
+
+
+#define FLOAT4_MAX FLT_MAX
+#define FLOAT4_MIN FLT_MIN
+#define FLOAT8_MAX DBL_MAX
+#define FLOAT8_MIN DBL_MIN
+
+/*
+ check to see if a float4 val is outside of
+ the FLOAT4_MIN, FLOAT4_MAX bounds.
+
+ raise an elog warning if it is
+*/
+static void CheckFloat4Val(double val)
+{
+ /* defining unsafe floats's will make float4 and float8 ops faster
+ at the cost of safety, of course! */
+#ifdef UNSAFE_FLOATS
+ return;
+#else
+ if (fabs(val) > FLOAT4_MAX)
+ elog(WARN,"\tBad float4 input format -- overflow\n");
+ if (val != 0.0 && fabs(val) < FLOAT4_MIN)
+ elog(WARN,"\tBad float4 input format -- underflow\n");
+ return;
+#endif /* UNSAFE_FLOATS */
+}
+
+/*
+ check to see if a float8 val is outside of
+ the FLOAT8_MIN, FLOAT8_MAX bounds.
+
+ raise an elog warning if it is
+*/
+static void CheckFloat8Val(double val)
+{
+ /* defining unsafe floats's will make float4 and float8 ops faster
+ at the cost of safety, of course! */
+#ifdef UNSAFE_FLOATS
+ return;
+#else
+ if (fabs(val) > FLOAT8_MAX)
+ elog(WARN,"\tBad float8 input format -- overflow\n");
+ if (val != 0.0 && fabs(val) < FLOAT8_MIN)
+ elog(WARN,"\tBad float8 input format -- underflow\n");
+ return;
+#endif /* UNSAFE_FLOATS */
+}
+
+/*
+ * float4in - converts "num" to float
+ * restricted syntax:
+ * {} [+|-] {digit} [.{digit}] []
+ * where is a space, digit is 0-9,
+ * is "e" or "E" followed by an integer.
+ */
+float32 float4in(char *num)
+{
+ float32 result = (float32) palloc(sizeof(float32data));
+ double val;
+ char* endptr;
+
+ errno = 0;
+ val = strtod(num,&endptr);
+ if (*endptr != '\0' || errno == ERANGE)
+ elog(WARN,"\tBad float4 input format\n");
+
+ /* if we get here, we have a legal double, still need to check to see
+ if it's a legal float */
+
+ CheckFloat4Val(val);
+
+ *result = val;
+ return result;
+}
+
+/*
+ * float4out - converts a float4 number to a string
+ * using a standard output format
+ */
+char *float4out(float32 num)
+{
+ char *ascii = (char *)palloc(MAXFLOATWIDTH+1);
+
+ if (!num)
+ return strcpy(ascii, "(null)");
+
+ sprintf(ascii, "%.*g", FLT_DIG, *num);
+ return(ascii);
+}
+
+
+/*
+ * float8in - converts "num" to float8
+ * restricted syntax:
+ * {} [+|-] {digit} [.{digit}] []
+ * where is a space, digit is 0-9,
+ * is "e" or "E" followed by an integer.
+ */
+float64 float8in(char *num)
+{
+ float64 result = (float64) palloc(sizeof(float64data));
+ double val;
+ char* endptr;
+
+ errno = 0;
+ val = strtod(num,&endptr);
+ if (*endptr != '\0' || errno == ERANGE)
+ elog(WARN,"\tBad float8 input format\n");
+
+ CheckFloat8Val(val);
+ *result = val;
+ return(result);
+}
+
+
+/*
+ * float8out - converts float8 number to a string
+ * using a standard output format
+ */
+char *float8out(float64 num)
+{
+ char *ascii = (char *)palloc(MAXDOUBLEWIDTH+1);
+
+ if (!num)
+ return strcpy(ascii, "(null)");
+
+#ifndef WIN32
+ if (isnan(*num))
+ return strcpy(ascii, "NaN");
+ if (isinf(*num))
+ return strcpy(ascii, "Infinity");
+#else
+ if (_isnan(*num))
+ return strcpy(ascii, "NaN");
+ if (!_finite(*num))
+ return strcpy(ascii, "Infinity");
+#endif
+
+ sprintf(ascii, "%.*g", DBL_DIG, *num);
+ return(ascii);
+}
+
+/* ========== PUBLIC ROUTINES ========== */
+
+
+/*
+ * ======================
+ * FLOAT4 BASE OPERATIONS
+ * ======================
+ */
+
+/*
+ * float4abs - returns a pointer to |arg1| (absolute value)
+ */
+float32 float4abs(float32 arg1)
+{
+ float32 result;
+ double val;
+
+ if (!arg1)
+ return (float32)NULL;
+
+ val = fabs(*arg1);
+
+ CheckFloat4Val(val);
+
+ result = (float32) palloc(sizeof(float32data));
+ *result = val;
+ return(result);
+}
+
+/*
+ * float4um - returns a pointer to -arg1 (unary minus)
+ */
+float32 float4um(float32 arg1)
+{
+ float32 result;
+ double val;
+
+ if (!arg1)
+ return (float32)NULL;
+
+ val = -(*arg1);
+ CheckFloat4Val(val);
+
+ result = (float32) palloc(sizeof(float32data));
+ *result = val;
+ return(result);
+}
+
+float32 float4larger(float32 arg1, float32 arg2)
+{
+ float32 result;
+
+ if (!arg1 || !arg2)
+ return (float32)NULL;
+
+ result = (float32) palloc(sizeof(float32data));
+
+ *result = ((*arg1 > *arg2) ? *arg1 : *arg2);
+ return result;
+}
+
+float32 float4smaller(float32 arg1, float32 arg2)
+{
+ float32 result;
+
+ if (!arg1 || !arg2)
+ return (float32)NULL;
+
+ result = (float32) palloc(sizeof(float32data));
+
+ *result = ((*arg1 > *arg2) ? *arg2 : *arg1);
+ return result;
+}
+
+/*
+ * ======================
+ * FLOAT8 BASE OPERATIONS
+ * ======================
+ */
+
+/*
+ * float8abs - returns a pointer to |arg1| (absolute value)
+ */
+float64 float8abs(float64 arg1)
+{
+ float64 result;
+ double val;
+
+ if (!arg1)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ val = fabs(*arg1);
+ CheckFloat8Val(val);
+ *result = val;
+ return(result);
+}
+
+
+/*
+ * float8um - returns a pointer to -arg1 (unary minus)
+ */
+float64 float8um(float64 arg1)
+{
+ float64 result;
+ double val;
+
+ if (!arg1)
+ return (float64)NULL;
+
+ val = -(*arg1);
+
+ CheckFloat8Val(val);
+ result = (float64) palloc(sizeof(float64data));
+ *result = val;
+ return(result);
+}
+
+float64 float8larger(float64 arg1, float64 arg2)
+{
+ float64 result;
+
+ if (!arg1 || !arg2)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ *result = ((*arg1 > *arg2) ? *arg1 : *arg2);
+ return result;
+}
+
+float64 float8smaller(float64 arg1, float64 arg2)
+{
+ float64 result;
+
+ if (!arg1 || !arg2)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ *result = ((*arg1 > *arg2) ? *arg2 : *arg1);
+ return result;
+}
+
+
+/*
+ * ====================
+ * ARITHMETIC OPERATORS
+ * ====================
+ */
+
+/*
+ * float4pl - returns a pointer to arg1 + arg2
+ * float4mi - returns a pointer to arg1 - arg2
+ * float4mul - returns a pointer to arg1 * arg2
+ * float4div - returns a pointer to arg1 / arg2
+ * float4inc - returns a poniter to arg1 + 1.0
+ */
+float32 float4pl(float32 arg1, float32 arg2)
+{
+ float32 result;
+ double val;
+
+ if (!arg1 || !arg2)
+ return (float32)NULL;
+
+ val = *arg1 + *arg2;
+ CheckFloat4Val(val);
+
+ result = (float32) palloc(sizeof(float32data));
+ *result = val;
+
+ return(result);
+}
+
+float32 float4mi(float32 arg1, float32 arg2)
+{
+ float32 result;
+ double val;
+
+ if (!arg1 || !arg2)
+ return (float32)NULL;
+
+ val = *arg1 - *arg2;
+
+ CheckFloat4Val(val);
+ result = (float32) palloc(sizeof(float32data));
+ *result = val;
+ return(result);
+}
+
+float32 float4mul(float32 arg1, float32 arg2)
+{
+ float32 result;
+ double val;
+
+ if (!arg1 || !arg2)
+ return (float32)NULL;
+
+ val = *arg1 * *arg2;
+
+ CheckFloat4Val(val);
+ result = (float32) palloc(sizeof(float32data));
+ *result = val;
+ return(result);
+}
+
+float32 float4div(float32 arg1, float32 arg2)
+{
+ float32 result;
+ double val;
+
+ if (!arg1 || !arg2)
+ return (float32)NULL;
+
+ if (*arg2 == 0.0)
+ elog(WARN,"float4div: divide by 0.0 error");
+
+ val = *arg1 / *arg2;
+
+ CheckFloat4Val(val);
+ result = (float32) palloc(sizeof(float32data));
+ *result = *arg1 / *arg2;
+ return(result);
+}
+
+float32 float4inc(float32 arg1)
+{
+ double val;
+
+ if (!arg1)
+ return (float32)NULL;
+
+ val = *arg1 + (float32data)1.0;
+ CheckFloat4Val(val);
+ *arg1 = val;
+ return arg1;
+}
+
+/*
+ * float8pl - returns a pointer to arg1 + arg2
+ * float8mi - returns a pointer to arg1 - arg2
+ * float8mul - returns a pointer to arg1 * arg2
+ * float8div - returns a pointer to arg1 / arg2
+ * float8inc - returns a pointer to arg1 + 1.0
+ */
+float64 float8pl(float64 arg1, float64 arg2)
+{
+ float64 result;
+ double val;
+
+ if (!arg1 || !arg2)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ val = *arg1 + *arg2;
+ CheckFloat8Val(val);
+ *result = val;
+ return(result);
+}
+
+float64 float8mi(float64 arg1, float64 arg2)
+{
+ float64 result;
+ double val;
+
+ if (!arg1 || !arg2)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ val = *arg1 - *arg2;
+ CheckFloat8Val(val);
+ *result = val;
+ return(result);
+}
+
+float64 float8mul(float64 arg1, float64 arg2)
+{
+ float64 result;
+ double val;
+
+ if (!arg1 || !arg2)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ val = *arg1 * *arg2;
+ CheckFloat8Val(val);
+ *result = val;
+ return(result);
+}
+
+float64 float8div(float64 arg1, float64 arg2)
+{
+ float64 result;
+ double val;
+
+ if (!arg1 || !arg2)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ if (*arg2 == 0.0)
+ elog(WARN,"float8div: divide by 0.0 error");
+
+ val = *arg1 / *arg2;
+ CheckFloat8Val(val);
+ *result = val;
+ return(result);
+}
+
+float64 float8inc(float64 arg1)
+{
+ double val;
+ if (!arg1)
+ return (float64)NULL;
+
+ val = *arg1 + (float64data)1.0;
+ CheckFloat8Val(val);
+ *arg1 = val;
+ return(arg1);
+}
+
+
+/*
+ * ====================
+ * COMPARISON OPERATORS
+ * ====================
+ */
+
+/*
+ * float4{eq,ne,lt,le,gt,ge} - float4/float4 comparison operations
+ */
+long float4eq(float32 arg1, float32 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 == *arg2);
+}
+
+long float4ne(float32 arg1, float32 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 != *arg2);
+}
+
+long float4lt(float32 arg1, float32 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 < *arg2);
+}
+
+long float4le(float32 arg1, float32 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 <= *arg2);
+}
+
+long float4gt(float32 arg1, float32 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 > *arg2);
+}
+
+long float4ge(float32 arg1, float32 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 >= *arg2);
+}
+
+/*
+ * float8{eq,ne,lt,le,gt,ge} - float8/float8 comparison operations
+ */
+long float8eq(float64 arg1, float64 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 == *arg2);
+}
+
+long float8ne(float64 arg1, float64 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 != *arg2);
+}
+
+long float8lt(float64 arg1, float64 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 < *arg2);
+}
+
+long float8le(float64 arg1, float64 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 <= *arg2);
+}
+
+long float8gt(float64 arg1, float64 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 > *arg2);
+}
+
+long float8ge(float64 arg1, float64 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 >= *arg2);
+}
+
+
+/*
+ * ===================
+ * CONVERSION ROUTINES
+ * ===================
+ */
+
+/*
+ * ftod - converts a float4 number to a float8 number
+ */
+float64 ftod(float32 num)
+{
+ float64 result;
+
+ if (!num)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ *result = *num;
+ return(result);
+}
+
+
+/*
+ * dtof - converts a float8 number to a float4 number
+ */
+float32 dtof(float64 num)
+{
+ float32 result;
+
+ if (!num)
+ return (float32)NULL;
+
+ result = (float32) palloc(sizeof(float32data));
+
+ *result = *num;
+ return(result);
+}
+
+
+/*
+ * =======================
+ * RANDOM FLOAT8 OPERATORS
+ * =======================
+ */
+
+/*
+ * dround - returns a pointer to ROUND(arg1)
+ */
+float64 dround(float64 arg1)
+{
+ float64 result;
+ double tmp;
+
+ if (!arg1)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ tmp = *arg1;
+ *result = (float64data) rint(tmp);
+ return(result);
+}
+
+
+/*
+ * dtrunc - returns a pointer to truncation of arg1,
+ * arg1 >= 0 ... the greatest integer as float8 less
+ * than or equal to arg1
+ * arg1 < 0 ... the greatest integer as float8 greater
+ * than or equal to arg1
+ */
+float64 dtrunc(float64 arg1)
+{
+ float64 result;
+ double tmp;
+
+ if (!arg1)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ tmp = *arg1;
+ if (*arg1 >= 0)
+ *result = (float64data) floor(tmp);
+ else
+ *result = (float64data) -(floor(-tmp));
+ return(result);
+}
+
+
+/*
+ * dsqrt - returns a pointer to square root of arg1
+ */
+float64 dsqrt(float64 arg1)
+{
+ float64 result;
+ double tmp;
+
+ if (!arg1)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ tmp = *arg1;
+ *result = (float64data) sqrt(tmp);
+ return (result);
+}
+
+
+/*
+ * dcbrt - returns a pointer to cube root of arg1
+ */
+float64 dcbrt(float64 arg1)
+{
+ float64 result;
+ double tmp;
+
+ if (!arg1)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ tmp = *arg1;
+ *result = (float64data) cbrt(tmp);
+ return(result);
+}
+
+
+/*
+ * dpow - returns a pointer to pow(arg1,arg2)
+ */
+float64 dpow(float64 arg1, float64 arg2)
+{
+ float64 result;
+ double tmp1, tmp2;
+
+ if (!arg1 || !arg2)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ tmp1 = *arg1;
+ tmp2 = *arg2;
+ errno = 0;
+ *result = (float64data) pow(tmp1, tmp2);
+ if (errno == ERANGE)
+ elog(WARN, "pow() returned a floating point out of the range\n");
+
+ CheckFloat8Val(*result);
+ return(result);
+}
+
+
+/*
+ * dexp - returns a pointer to the exponential function of arg1
+ */
+float64 dexp(float64 arg1)
+{
+ float64 result;
+ double tmp;
+
+ if (!arg1)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ tmp = *arg1;
+ errno = 0;
+ *result = (float64data) exp(tmp);
+ if (errno == ERANGE)
+ elog(WARN, "exp() returned a floating point out of range\n");
+
+ CheckFloat8Val(*result);
+ return(result);
+}
+
+
+/*
+ * dlog1 - returns a pointer to the natural logarithm of arg1
+ * ("dlog" is already a logging routine...)
+ */
+float64 dlog1(float64 arg1)
+{
+ float64 result;
+ double tmp;
+
+ if (!arg1)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ tmp = *arg1;
+ if (tmp == 0.0)
+ elog(WARN, "can't take log of 0!");
+ if (tmp < 0)
+ elog(WARN, "can't take log of a negative number");
+ *result = (float64data) log(tmp);
+
+ CheckFloat8Val(*result);
+ return(result);
+}
+
+
+/*
+ * ====================
+ * ARITHMETIC OPERATORS
+ * ====================
+ */
+
+/*
+ * float48pl - returns a pointer to arg1 + arg2
+ * float48mi - returns a pointer to arg1 - arg2
+ * float48mul - returns a pointer to arg1 * arg2
+ * float48div - returns a pointer to arg1 / arg2
+ */
+float64 float48pl(float32 arg1, float64 arg2)
+{
+ float64 result;
+
+ if (!arg1 || !arg2)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ *result = *arg1 + *arg2;
+ CheckFloat8Val(*result);
+ return(result);
+}
+
+float64 float48mi(float32 arg1, float64 arg2)
+{
+ float64 result;
+
+ if (!arg1 || !arg2)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ *result = *arg1 - *arg2;
+ CheckFloat8Val(*result);
+ return(result);
+}
+
+float64 float48mul(float32 arg1, float64 arg2)
+{
+ float64 result;
+
+ if (!arg1 || !arg2)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ *result = *arg1 * *arg2;
+ CheckFloat8Val(*result);
+ return(result);
+}
+
+float64 float48div(float32 arg1, float64 arg2)
+{
+ float64 result;
+
+ if (!arg1 || !arg2)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ if (*arg2 == 0.0)
+ elog(WARN, "float48div: divide by 0.0 error!");
+
+ *result = *arg1 / *arg2;
+ CheckFloat8Val(*result);
+ return(result);
+}
+
+/*
+ * float84pl - returns a pointer to arg1 + arg2
+ * float84mi - returns a pointer to arg1 - arg2
+ * float84mul - returns a pointer to arg1 * arg2
+ * float84div - returns a pointer to arg1 / arg2
+ */
+float64 float84pl(float64 arg1, float32 arg2)
+{
+ float64 result;
+
+ if (!arg1 || !arg2)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ *result = *arg1 + *arg2;
+ CheckFloat8Val(*result);
+ return(result);
+}
+
+float64 float84mi(float64 arg1, float32 arg2)
+{
+ float64 result;
+
+ if (!arg1 || !arg2)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ *result = *arg1 - *arg2;
+ CheckFloat8Val(*result);
+ return(result);
+}
+
+float64 float84mul(float64 arg1, float32 arg2)
+{
+
+ float64 result;
+
+ if (!arg1 || !arg2)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ *result = *arg1 * *arg2;
+ CheckFloat8Val(*result);
+ return(result);
+}
+
+float64 float84div(float64 arg1, float32 arg2)
+{
+ float64 result;
+
+ if (!arg1 || !arg2)
+ return (float64)NULL;
+
+ result = (float64) palloc(sizeof(float64data));
+
+ if (*arg2 == 0.0)
+ elog(WARN, "float48div: divide by 0.0 error!");
+
+ *result = *arg1 / *arg2;
+ CheckFloat8Val(*result);
+ return(result);
+}
+
+/*
+ * ====================
+ * COMPARISON OPERATORS
+ * ====================
+ */
+
+/*
+ * float48{eq,ne,lt,le,gt,ge} - float4/float8 comparison operations
+ */
+long float48eq(float32 arg1, float64 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 == (float)*arg2);
+}
+
+long float48ne(float32 arg1, float64 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 != (float)*arg2);
+}
+
+long float48lt(float32 arg1, float64 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 < (float)*arg2);
+}
+
+long float48le(float32 arg1, float64 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 <= (float)*arg2);
+}
+
+long float48gt(float32 arg1, float64 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 > (float)*arg2);
+}
+
+long float48ge(float32 arg1, float64 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return(*arg1 >= (float)*arg2);
+}
+
+/*
+ * float84{eq,ne,lt,le,gt,ge} - float4/float8 comparison operations
+ */
+long float84eq(float64 arg1, float32 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return((float)*arg1 == *arg2);
+}
+
+long float84ne(float64 arg1, float32 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return((float)*arg1 != *arg2);
+}
+
+long float84lt(float64 arg1, float32 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return((float)*arg1 < *arg2);
+}
+
+long float84le(float64 arg1, float32 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return((float)*arg1 <= *arg2);
+}
+
+long float84gt(float64 arg1, float32 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return((float)*arg1 > *arg2);
+}
+
+long float84ge(float64 arg1, float32 arg2)
+{
+ if (!arg1 || !arg2)
+ return (long)NULL;
+
+ return((float)*arg1 >= *arg2);
+}
+
+/* ========== PRIVATE ROUTINES ========== */
+
+/* From "fdlibm" @ netlib.att.com */
+
+#ifdef NEED_RINT
+
+/* @(#)s_rint.c 5.1 93/09/24 */
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+/*
+ * rint(x)
+ * Return x rounded to integral value according to the prevailing
+ * rounding mode.
+ * Method:
+ * Using floating addition.
+ * Exception:
+ * Inexact flag raised if x not equal to rint(x).
+ */
+
+#ifdef __STDC__
+static const double
+#else
+ static double
+#endif
+ one = 1.0,
+ TWO52[2]={
+ 4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
+ -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
+ };
+
+#ifdef __STDC__
+static double rint(double x)
+#else
+ static double rint(x)
+ double x;
+#endif
+{
+ int i0,n0,j0,sx;
+ unsigned i,i1;
+ double w,t;
+ n0 = (*((int *)&one)>>29)^1;
+ i0 = *(n0+(int*)&x);
+ sx = (i0>>31)&1;
+ i1 = *(1-n0+(int*)&x);
+ j0 = ((i0>>20)&0x7ff)-0x3ff;
+ if(j0<20) {
+ if(j0<0) {
+ if(((i0&0x7fffffff)|i1)==0) return x;
+ i1 |= (i0&0x0fffff);
+ i0 &= 0xfffe0000;
+ i0 |= ((i1|-i1)>>12)&0x80000;
+ *(n0+(int*)&x)=i0;
+ w = TWO52[sx]+x;
+ t = w-TWO52[sx];
+ i0 = *(n0+(int*)&t);
+ *(n0+(int*)&t) = (i0&0x7fffffff)|(sx<<31);
+ return t;
+ } else {
+ i = (0x000fffff)>>j0;
+ if(((i0&i)|i1)==0) return x; /* x is integral */
+ i>>=1;
+ if(((i0&i)|i1)!=0) {
+ if(j0==19) i1 = 0x40000000; else
+ i0 = (i0&(~i))|((0x20000)>>j0);
+ }
+ }
+ } else if (j0>51) {
+ if(j0==0x400) return x+x; /* inf or NaN */
+ else return x; /* x is integral */
+ } else {
+ i = ((unsigned)(0xffffffff))>>(j0-20);
+ if((i1&i)==0) return x; /* x is integral */
+ i>>=1;
+ if((i1&i)!=0) i1 = (i1&(~i))|((0x40000000)>>(j0-20));
+ }
+ *(n0+(int*)&x) = i0;
+ *(1-n0+(int*)&x) = i1;
+ w = TWO52[sx]+x;
+ return w-TWO52[sx];
+}
+
+#endif /* NEED_RINT */
+
+#ifdef NEED_CBRT
+
+static
+ double
+ cbrt(x)
+double x;
+{
+ int isneg = (x < 0.0);
+ double tmpres = pow(fabs(x), (double) 1.0 / (double) 3.0);
+
+ return(isneg ? -tmpres : tmpres);
+}
+
+#endif /* NEED_CBRT */
+
+#ifdef NEED_ISINF
+
+#if defined(PORTNAME_aix)
+#ifdef CLASS_CONFLICT
+/* we want the math symbol */
+#undef class
+#endif /* CLASS_CONFICT */
+
+static int isinf(x)
+ double x;
+{
+ int fpclass = class(x);
+ if (fpclass == FP_PLUS_INF)
+ return(1);
+ if (fpclass == FP_MINUS_INF)
+ return(-1);
+ return(0);
+}
+#endif /* PORTNAME_aix */
+
+#if defined(PORTNAME_ultrix4)
+#include
+static int isinf(x)
+ double x;
+{
+ int fpclass = fp_class_d(x);
+ if (fpclass == FP_POS_INF)
+ return(1);
+ if (fpclass == FP_NEG_INF)
+ return(-1);
+ return(0);
+}
+#endif /* PORTNAME_ultrix4 */
+
+#if defined(PORTNAME_alpha)
+#include
+static int isinf(x)
+ double x;
+{
+ int fpclass = fp_class(x);
+ if (fpclass == FP_POS_INF)
+ return(1);
+ if (fpclass == FP_NEG_INF)
+ return(-1);
+ return(0);
+}
+#endif /* PORTNAME_alpha */
+
+#if defined(PORTNAME_sparc_solaris)
+#include
+static int
+ isinf(d)
+double d;
+{
+ fpclass_t type = fpclass(d);
+ switch (type) {
+ case FP_SNAN:
+ case FP_QNAN:
+ case FP_NINF:
+ case FP_PINF:
+ return (1);
+ default:
+ break;
+ }
+
+ return (0);
+}
+#endif /* PORTNAME_sparc_solaris */
+
+#if defined(PORTNAME_irix5)
+#include
+static int
+ isinf(d)
+double d;
+{
+ fpclass_t type = fpclass(d);
+ switch (type) {
+ case FP_SNAN:
+ case FP_QNAN:
+ case FP_NINF:
+ case FP_PINF:
+ return (1);
+ default:
+ break;
+ }
+
+ return (0);
+}
+#endif /* PORTNAME_irix5 */
+
+#endif /* NEED_ISINF */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * geo-ops.c--
+ * 2D geometric operations
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/geo-ops.c,v 1.1.1.1 1996/07/09 06:22:04 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include /* faked on sunos */
+#include /* for sprintf proto, etc. */
+#include
+
+#include "utils/geo-decls.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+#define LDELIM '('
+#define RDELIM ')'
+#define DELIM ','
+#define BOXNARGS 4
+#define LSEGNARGS 4
+#define POINTNARGS 2
+
+/***********************************************************************
+ **
+ ** Routines for two-dimensional boxes.
+ **
+ ***********************************************************************/
+
+/*----------------------------------------------------------
+ * Formatting and conversion routines.
+ *---------------------------------------------------------*/
+
+/* box_in - convert a string to internal form.
+ *
+ * str: input string "(f8, f8, f8, f8)"
+ */
+BOX *box_in(char *str)
+{
+ double tmp;
+ char *p, *coord[BOXNARGS];
+ int i;
+ BOX *result;
+
+ if (str == NULL)
+ elog (WARN," Bad (null) box external representation");
+
+ if ((p = (char *)strchr(str, LDELIM)) == (char *)NULL)
+ elog (WARN, "Bad box external representation '%s'",str);
+ for (i = 0, p = str; *p && i < BOXNARGS && *p != RDELIM; p++)
+ if (*p == DELIM || (*p == LDELIM && !i))
+ coord[i++] = p + 1;
+ if (i < BOXNARGS - 1)
+ elog (WARN, "Bad box external representation '%s'", str);
+ result = PALLOCTYPE(BOX);
+ result->xh = atof(coord[0]);
+ result->yh = atof(coord[1]);
+ result->xl = atof(coord[2]);
+ result->yl = atof(coord[3]);
+ if (result->xh < result->xl) {
+ tmp = result->xh;
+ result->xh = result->xl;
+ result->xl = tmp;
+ }
+ if (result->yh < result->yl) {
+ tmp = result->yh;
+ result->yh = result->yl;
+ result->yl = tmp;
+ }
+
+ return(result);
+}
+
+/* box_out - convert a box to external form.
+ */
+char *box_out(BOX *box)
+{
+ char *result;
+
+ if (box == NULL)
+ return(NULL);
+ result = (char *)PALLOC(80);
+ (void) sprintf(result, "(%G,%G,%G,%G)",
+ box->xh, box->yh, box->xl, box->yl);
+
+ return(result);
+}
+
+
+/* box_construct - fill in a new box.
+ */
+BOX *box_construct(double x1, double x2, double y1, double y2)
+{
+ BOX *result;
+
+ result = PALLOCTYPE(BOX);
+ return( box_fill(result, x1, x2, y1, y2) );
+}
+
+
+/* box_fill - fill in a static box
+ */
+BOX *box_fill(BOX *result, double x1, double x2, double y1, double y2)
+{
+ double tmp;
+
+ result->xh = x1;
+ result->xl = x2;
+ result->yh = y1;
+ result->yl = y2;
+ if (result->xh < result->xl) {
+ tmp = result->xh;
+ result->xh = result->xl;
+ result->xl = tmp;
+ }
+ if (result->yh < result->yl) {
+ tmp = result->yh;
+ result->yh = result->yl;
+ result->yl = tmp;
+ }
+
+ return(result);
+}
+
+
+/* box_copy - copy a box
+ */
+BOX *box_copy(BOX *box)
+{
+ BOX *result;
+
+ result = PALLOCTYPE(BOX);
+ memmove((char *) result, (char *) box, sizeof(BOX));
+
+ return(result);
+}
+
+
+/*----------------------------------------------------------
+ * Relational operators for BOXes.
+ * <, >, <=, >=, and == are based on box area.
+ *---------------------------------------------------------*/
+
+/* box_same - are two boxes identical?
+ */
+long box_same(BOX *box1, BOX *box2)
+{
+ return((box1->xh == box2->xh && box1->xl == box2->xl) &&
+ (box1->yh == box2->yh && box1->yl == box2->yl));
+}
+
+/* box_overlap - does box1 overlap box2?
+ */
+long box_overlap(BOX *box1, BOX *box2)
+{
+ return(((box1->xh >= box2->xh && box1->xl <= box2->xh) ||
+ (box2->xh >= box1->xh && box2->xl <= box1->xh)) &&
+ ((box1->yh >= box2->yh && box1->yl <= box2->yh) ||
+ (box2->yh >= box1->yh && box2->yl <= box1->yh)) );
+}
+
+/* box_overleft - is the right edge of box1 to the left of
+ * the right edge of box2?
+ *
+ * This is "less than or equal" for the end of a time range,
+ * when time ranges are stored as rectangles.
+ */
+long box_overleft(BOX *box1, BOX *box2)
+{
+ return(box1->xh <= box2->xh);
+}
+
+/* box_left - is box1 strictly left of box2?
+ */
+long box_left(BOX *box1, BOX *box2)
+{
+ return(box1->xh < box2->xl);
+}
+
+/* box_right - is box1 strictly right of box2?
+ */
+long box_right(BOX *box1, BOX *box2)
+{
+ return(box1->xl > box2->xh);
+}
+
+/* box_overright - is the left edge of box1 to the right of
+ * the left edge of box2?
+ *
+ * This is "greater than or equal" for time ranges, when time ranges
+ * are stored as rectangles.
+ */
+long box_overright(BOX *box1, BOX *box2)
+{
+ return(box1->xl >= box2->xl);
+}
+
+/* box_contained - is box1 contained by box2?
+ */
+long box_contained(BOX *box1, BOX *box2)
+{
+ return((box1->xh <= box2->xh && box1->xl >= box2->xl &&
+ box1->yh <= box2->yh && box1->yl >= box2->yl));
+}
+
+/* box_contain - does box1 contain box2?
+ */
+long box_contain(BOX *box1, BOX *box2)
+{
+ return((box1->xh >= box2->xh && box1->xl <= box2->xl &&
+ box1->yh >= box2->yh && box1->yl <= box2->yl));
+}
+
+
+/* box_positionop -
+ * is box1 entirely {above, below } box2?
+ */
+long box_below(BOX *box1, BOX *box2)
+{
+ return( box1->yh <= box2->yl );
+}
+
+long box_above(BOX *box1, BOX *box2)
+{
+ return( box1->yl >= box2->yh );
+}
+
+
+/* box_relop - is area(box1) relop area(box2), within
+ * our accuracy constraint?
+ */
+long box_lt(BOX *box1, BOX *box2)
+{
+ return( FPlt(box_ar(box1), box_ar(box2)) );
+}
+
+long box_gt(BOX *box1, BOX *box2)
+{
+ return( FPgt(box_ar(box1), box_ar(box2)) );
+}
+
+long box_eq(BOX *box1, BOX *box2)
+{
+ return( FPeq(box_ar(box1), box_ar(box2)) );
+}
+
+long box_le(BOX *box1, BOX *box2)
+{
+ return( FPle(box_ar(box1), box_ar(box2)) );
+}
+
+long box_ge(BOX *box1, BOX *box2)
+{
+ return( FPge(box_ar(box1), box_ar(box2)) );
+}
+
+
+/*----------------------------------------------------------
+ * "Arithmetic" operators on boxes.
+ * box_foo returns foo as an object (pointer) that
+ can be passed between languages.
+ * box_xx is an internal routine which returns the
+ * actual value (and cannot be handed back to
+ * LISP).
+ *---------------------------------------------------------*/
+
+/* box_area - returns the area of the box.
+ */
+double *box_area(BOX *box)
+{
+ double *result;
+
+ result = PALLOCTYPE(double);
+ *result = box_ln(box) * box_ht(box);
+
+ return(result);
+}
+
+
+/* box_length - returns the length of the box
+ * (horizontal magnitude).
+ */
+double *box_length(BOX *box)
+{
+ double *result;
+
+ result = PALLOCTYPE(double);
+ *result = box->xh - box->xl;
+
+ return(result);
+}
+
+
+/* box_height - returns the height of the box
+ * (vertical magnitude).
+ */
+double *box_height(BOX *box)
+{
+ double *result;
+
+ result = PALLOCTYPE(double);
+ *result = box->yh - box->yl;
+
+ return(result);
+}
+
+
+/* box_distance - returns the distance between the
+ * center points of two boxes.
+ */
+double *box_distance(BOX *box1, BOX *box2)
+{
+ double *result;
+ Point *box_center(), *a, *b;
+
+ result = PALLOCTYPE(double);
+ a = box_center(box1);
+ b = box_center(box2);
+ *result = HYPOT(a->x - b->x, a->y - b->y);
+
+ PFREE(a);
+ PFREE(b);
+ return(result);
+}
+
+
+/* box_center - returns the center point of the box.
+ */
+Point *box_center(BOX *box)
+{
+ Point *result;
+
+ result = PALLOCTYPE(Point);
+ result->x = (box->xh + box->xl) / 2.0;
+ result->y = (box->yh + box->yl) / 2.0;
+
+ return(result);
+}
+
+
+/* box_ar - returns the area of the box.
+ */
+double box_ar(BOX *box)
+{
+ return( box_ln(box) * box_ht(box) );
+}
+
+
+/* box_ln - returns the length of the box
+ * (horizontal magnitude).
+ */
+double box_ln(BOX *box)
+{
+ return( box->xh - box->xl );
+}
+
+
+/* box_ht - returns the height of the box
+ * (vertical magnitude).
+ */
+double box_ht(BOX *box)
+{
+ return( box->yh - box->yl );
+}
+
+
+/* box_dt - returns the distance between the
+ * center points of two boxes.
+ */
+double box_dt(BOX *box1, BOX *box2)
+{
+ double result;
+ Point *box_center(),
+ *a, *b;
+
+ a = box_center(box1);
+ b = box_center(box2);
+ result = HYPOT(a->x - b->x, a->y - b->y);
+
+ PFREE(a);
+ PFREE(b);
+ return(result);
+}
+
+/*----------------------------------------------------------
+ * Funky operations.
+ *---------------------------------------------------------*/
+
+/* box_intersect -
+ * returns the overlapping portion of two boxes,
+ * or NULL if they do not intersect.
+ */
+BOX *box_intersect(BOX *box1, BOX *box2)
+{
+ BOX *result;
+ long box_overlap();
+
+ if (! box_overlap(box1,box2))
+ return(NULL);
+ result = PALLOCTYPE(BOX);
+ result->xh = Min(box1->xh, box2->xh);
+ result->xl = Max(box1->xl, box2->xl);
+ result->yh = Min(box1->yh, box2->yh);
+ result->yl = Max(box1->yl, box2->yl);
+
+ return(result);
+}
+
+
+/* box_diagonal -
+ * returns a line segment which happens to be the
+ * positive-slope diagonal of "box".
+ * provided, of course, we have LSEGs.
+ */
+LSEG *box_diagonal(BOX *box)
+{
+ Point p1, p2;
+
+ p1.x = box->xh;
+ p1.y = box->yh;
+ p2.x = box->xl;
+ p2.y = box->yl;
+ return( lseg_construct( &p1, &p2 ) );
+
+}
+
+/***********************************************************************
+ **
+ ** Routines for 2D lines.
+ ** Lines are not intended to be used as ADTs per se,
+ ** but their ops are useful tools for other ADT ops. Thus,
+ ** there are few relops.
+ **
+ ***********************************************************************/
+
+/*----------------------------------------------------------
+ * Conversion routines from one line formula to internal.
+ * Internal form: Ax+By+C=0
+ *---------------------------------------------------------*/
+
+LINE * /* point-slope */
+line_construct_pm(Point *pt, double m)
+{
+ LINE *result;
+
+ result = PALLOCTYPE(LINE);
+ /* use "mx - y + yinter = 0" */
+ result->A = m;
+ result->B = -1.0;
+ result->C = pt->y - m * pt->x;
+ return(result);
+}
+
+
+LINE * /* two points */
+line_construct_pp(Point *pt1, Point *pt2)
+{
+ LINE *result;
+
+ result = PALLOCTYPE(LINE);
+ if (FPeq(pt1->x, pt2->x)) { /* vertical */
+ /* use "x = C" */
+ result->m = 0.0;
+ result->A = -1.0;
+ result->B = 0.0;
+ result->C = pt1->x;
+ } else {
+ /* use "mx - y + yinter = 0" */
+ result->m = (pt1->y - pt2->y) / (pt1->x - pt2->x);
+ result->A = result->m;
+ result->B = -1.0;
+ result->C = pt1->y - result->m * pt1->x;
+ }
+ return(result);
+}
+
+
+/*----------------------------------------------------------
+ * Relative position routines.
+ *---------------------------------------------------------*/
+
+long line_intersect(LINE *l1, LINE *l2)
+{
+ return( ! line_parallel(l1, l2) );
+}
+
+long line_parallel(LINE *l1, LINE *l2)
+{
+ return( FPeq(l1->m, l2->m) );
+}
+
+long line_perp(LINE *l1, LINE *l2)
+{
+ if (l1->m)
+ return( FPeq(l2->m / l1->m, -1.0) );
+ else if (l2->m)
+ return( FPeq(l1->m / l2->m, -1.0) );
+ return(1); /* both 0.0 */
+}
+
+long line_vertical(LINE *line)
+{
+ return( FPeq(line->A, -1.0) && FPzero(line->B) );
+}
+
+long line_horizontal(LINE *line)
+{
+ return( FPzero(line->m) );
+}
+
+
+long line_eq(LINE *l1, LINE *l2)
+{
+ double k;
+
+ if (! FPzero(l2->A))
+ k = l1->A / l2->A;
+ else if (! FPzero(l2->B))
+ k = l1->B / l2->B;
+ else if (! FPzero(l2->C))
+ k = l1->C / l2->C;
+ else
+ k = 1.0;
+ return( FPeq(l1->A, k * l2->A) &&
+ FPeq(l1->B, k * l2->B) &&
+ FPeq(l1->C, k * l2->C) );
+}
+
+
+/*----------------------------------------------------------
+ * Line arithmetic routines.
+ *---------------------------------------------------------*/
+
+double * /* distance between l1, l2 */
+line_distance(LINE *l1, LINE *l2)
+{
+ double *result;
+ Point *tmp;
+
+ result = PALLOCTYPE(double);
+ if (line_intersect(l1, l2)) {
+ *result = 0.0;
+ return(result);
+ }
+ if (line_vertical(l1))
+ *result = fabs(l1->C - l2->C);
+ else {
+ tmp = point_construct(0.0, l1->C);
+ result = dist_pl(tmp, l2);
+ PFREE(tmp);
+ }
+ return(result);
+}
+
+Point * /* point where l1, l2 intersect (if any) */
+line_interpt(LINE *l1, LINE *l2)
+{
+ Point *result;
+ double x;
+
+ if (line_parallel(l1, l2))
+ return(NULL);
+ if (line_vertical(l1))
+ result = point_construct(l2->m * l1->C + l2->C, l1->C);
+ else if (line_vertical(l2))
+ result = point_construct(l1->m * l2->C + l1->C, l2->C);
+ else {
+ x = (l1->C - l2->C) / (l2->A - l1->A);
+ result = point_construct(x, l1->m * x + l1->C);
+ }
+ return(result);
+}
+
+/***********************************************************************
+ **
+ ** Routines for 2D paths (sequences of line segments, also
+ ** called `polylines').
+ **
+ ** This is not a general package for geometric paths,
+ ** which of course include polygons; the emphasis here
+ ** is on (for example) usefulness in wire layout.
+ **
+ ***********************************************************************/
+
+#define PATHALLOCSIZE(N) \
+ (long) ((unsigned) (sizeof(PATH) + \
+ (((N)-1) > 0 ? ((N)-1) : 0) \
+ * sizeof(Point)))
+
+/*----------------------------------------------------------
+ * String to path / path to string conversion.
+ * External format:
+ * "(closed, npts, xcoord, ycoord,... )"
+ *---------------------------------------------------------*/
+
+PATH *path_in(char *str)
+{
+ double coord;
+ long field[2];
+ char *s;
+ int ct, i;
+ PATH *result;
+ long pathsize;
+
+ if (str == NULL)
+ elog(WARN, "Bad (null) path external representation");
+
+ /* read the path header information */
+ for (i = 0, s = str; *s && i < 2 && *s != RDELIM; ++s)
+ if (*s == DELIM || (*s == LDELIM && !i))
+ field[i++] = atol(s + 1);
+ if (i < 1)
+ elog(WARN, "Bad path external representation '%s'", str);
+ pathsize = PATHALLOCSIZE(field[1]);
+ result = (PATH *)palloc(pathsize);
+ result->length = pathsize;
+ result->closed = field[0];
+ result->npts = field[1];
+
+ /* read the path points */
+
+ ct = result->npts * 2; /* two coords for every point */
+ for (i = 0;
+ *s && i < ct && *s != RDELIM;
+ ++s) {
+ if (*s == ',') {
+ coord = atof(s + 1);
+ if (i % 2)
+ (result->p[i/2]).y = coord;
+ else
+ (result->p[i/2]).x = coord;
+ ++i;
+ }
+ }
+ if (i % 2 || i < --ct) {
+ PFREE(result);
+ elog(WARN, "Bad path external representation '%s'", str);
+ }
+
+ return(result);
+}
+
+
+char *path_out(PATH *path)
+{
+ char buf[BUFSIZ + 20000], *result, *s;
+ int i;
+ char tmp[64];
+
+ if (path == NULL)
+ return(NULL);
+ (void) sprintf(buf,"%c%d,%d", LDELIM,
+ path->closed, path->npts);
+ s = buf + strlen(buf);
+ for (i = 0; i < path->npts; ++i) {
+ (void) sprintf(tmp, ",%G,%G",
+ path->p[i].x, path->p[i].y);
+ (void) strcpy(s, tmp);
+ s += strlen(tmp);
+ }
+ *s++ = RDELIM;
+ *s = '\0';
+ result = (char *)PALLOC(strlen(buf) + 1);
+ (void) strcpy(result, buf);
+
+ return(result);
+}
+
+
+/*----------------------------------------------------------
+ * Relational operators.
+ * These are based on the path cardinality,
+ * as stupid as that sounds.
+ *
+ * Better relops and access methods coming soon.
+ *---------------------------------------------------------*/
+
+long path_n_lt(PATH *p1, PATH *p2)
+{
+ return( (p1->npts < p2->npts ) );
+}
+
+long path_n_gt(PATH *p1, PATH *p2)
+{
+ return( (p1->npts > p2->npts ) );
+}
+
+long path_n_eq(PATH *p1, PATH *p2)
+{
+ return( (p1->npts == p2->npts) );
+}
+
+long path_n_le(PATH *p1, PATH *p2)
+{
+ return( (p1->npts <= p2->npts ) );
+}
+
+long path_n_ge(PATH *p1, PATH *p2)
+{
+ return( (p1->npts >= p2->npts ) );
+}
+
+/* path_inter -
+ * Does p1 intersect p2 at any point?
+ * Use bounding boxes for a quick (O(n)) check, then do a
+ * O(n^2) iterative edge check.
+ */
+long path_inter(PATH *p1, PATH *p2)
+{
+ BOX b1, b2;
+ int i, j;
+ LSEG seg1, seg2;
+
+ b1.xh = b1.yh = b2.xh = b2.yh = DBL_MAX;
+ b1.xl = b1.yl = b2.xl = b2.yl = -DBL_MAX;
+ for (i = 0; i < p1->npts; ++i) {
+ b1.xh = Max(p1->p[i].x, b1.xh);
+ b1.yh = Max(p1->p[i].y, b1.yh);
+ b1.xl = Min(p1->p[i].x, b1.xl);
+ b1.yl = Min(p1->p[i].y, b1.yl);
+ }
+ for (i = 0; i < p2->npts; ++i) {
+ b2.xh = Max(p2->p[i].x, b2.xh);
+ b2.yh = Max(p2->p[i].y, b2.yh);
+ b2.xl = Min(p2->p[i].x, b2.xl);
+ b2.yl = Min(p2->p[i].y, b2.yl);
+ }
+ if (! box_overlap(&b1, &b2))
+ return(0);
+
+ /* pairwise check lseg intersections */
+ for (i = 0; i < p1->npts - 1; i++) {
+ for (j = 0; j < p2->npts - 1; j++) {
+ statlseg_construct(&seg1, &p1->p[i], &p1->p[i+1]);
+ statlseg_construct(&seg2, &p2->p[j], &p2->p[j+1]);
+ if (lseg_intersect(&seg1, &seg2))
+ return(1);
+ }
+ }
+
+ /* if we dropped through, no two segs intersected */
+ return(0);
+}
+
+/* this essentially does a cartesian product of the lsegs in the
+ two paths, and finds the min distance between any two lsegs */
+double *path_distance(PATH *p1, PATH *p2)
+{
+ double *min, *tmp;
+ int i,j;
+ LSEG seg1, seg2;
+
+ statlseg_construct(&seg1, &p1->p[0], &p1->p[1]);
+ statlseg_construct(&seg2, &p2->p[0], &p2->p[1]);
+ min = lseg_distance(&seg1, &seg2);
+
+ for (i = 0; i < p1->npts - 1; i++)
+ for (j = 0; j < p2->npts - 1; j++)
+ {
+ statlseg_construct(&seg1, &p1->p[i], &p1->p[i+1]);
+ statlseg_construct(&seg2, &p2->p[j], &p2->p[j+1]);
+
+ if (*min < *(tmp = lseg_distance(&seg1, &seg2)))
+ *min = *tmp;
+ PFREE(tmp);
+ }
+
+ return(min);
+}
+
+
+/*----------------------------------------------------------
+ * "Arithmetic" operations.
+ *---------------------------------------------------------*/
+
+double *path_length(PATH *path)
+{
+ double *result;
+ int ct, i;
+
+ result = PALLOCTYPE(double);
+ ct = path->npts - 1;
+ for (i = 0; i < ct; ++i)
+ *result += point_dt(&path->p[i], &path->p[i+1]);
+
+ return(result);
+}
+
+
+
+double path_ln(PATH *path)
+{
+ double result;
+ int ct, i;
+
+ ct = path->npts - 1;
+ for (result = i = 0; i < ct; ++i)
+ result += point_dt(&path->p[i], &path->p[i+1]);
+
+ return(result);
+}
+/***********************************************************************
+ **
+ ** Routines for 2D points.
+ **
+ ***********************************************************************/
+
+/*----------------------------------------------------------
+ * String to point, point to string conversion.
+ * External form: "(x, y)"
+ *---------------------------------------------------------*/
+
+Point *point_in(char *str)
+{
+ char *coord[POINTNARGS], *p, *r;
+ int i;
+ Point *result;
+
+ if (str == NULL)
+ elog(WARN, "Bad (null) point external representation");
+
+ if ((p = (char *)strchr(str, LDELIM)) == (char *)NULL)
+ elog (WARN, "Bad point external representation '%s'",str);
+ for (i = 0, p++; *p && i < POINTNARGS-1 && *p != RDELIM; p = r+1)
+ if ((r = (char *)strchr(p, DELIM)) == (char *)NULL)
+ elog (WARN, "Bad point external representation '%s'",str);
+ else
+ coord[i++] = p;
+ if ((r = (char *)strchr(p, RDELIM)) == (char *)NULL)
+ elog (WARN, "Bad point external representation '%s'",str);
+ coord[i++] = p;
+
+ if (i < POINTNARGS - 1)
+ elog(WARN, "Bad point external representation '%s'",str);
+ result = PALLOCTYPE(Point);
+ result->x = atof(coord[0]);
+ result->y = atof(coord[1]);
+ return(result);
+}
+
+char *point_out(Point *pt)
+{
+ char *result;
+
+ if (pt == NULL)
+ return(NULL);
+ result = (char *)PALLOC(40);
+ (void) sprintf(result, "(%G,%G)", pt->x, pt->y);
+ return(result);
+}
+
+
+Point *point_construct(double x, double y)
+{
+ Point *result;
+
+ result = PALLOCTYPE(Point);
+ result->x = x;
+ result->y = y;
+ return(result);
+}
+
+
+Point *point_copy(Point *pt)
+{
+ Point *result;
+
+ result = PALLOCTYPE(Point);
+ result->x = pt->x;
+ result->y = pt->y;
+ return(result);
+}
+
+
+/*----------------------------------------------------------
+ * Relational operators for Points.
+ * Since we do have a sense of coordinates being
+ * "equal" to a given accuracy (point_vert, point_horiz),
+ * the other ops must preserve that sense. This means
+ * that results may, strictly speaking, be a lie (unless
+ * EPSILON = 0.0).
+ *---------------------------------------------------------*/
+
+long point_left(Point *pt1, Point *pt2)
+{
+ return( FPlt(pt1->x, pt2->x) );
+}
+
+long point_right(Point *pt1, Point *pt2)
+{
+ return( FPgt(pt1->x, pt2->x) );
+}
+
+long point_above(Point *pt1, Point *pt2)
+{
+ return( FPgt(pt1->y, pt2->y) );
+}
+
+long point_below(Point *pt1, Point *pt2)
+{
+ return( FPlt(pt1->y, pt2->y) );
+}
+
+long point_vert(Point *pt1, Point *pt2)
+{
+ return( FPeq( pt1->x, pt2->x ) );
+}
+
+long point_horiz(Point *pt1, Point *pt2)
+{
+ return( FPeq( pt1->y, pt2->y ) );
+}
+
+long point_eq(Point *pt1, Point *pt2)
+{
+ return( point_horiz(pt1, pt2) && point_vert(pt1, pt2) );
+}
+
+/*----------------------------------------------------------
+ * "Arithmetic" operators on points.
+ *---------------------------------------------------------*/
+
+long pointdist(Point *p1, Point *p2)
+{
+ long result;
+
+ result = point_dt(p1, p2);
+ return(result);
+}
+
+double *point_distance(Point *pt1, Point *pt2)
+{
+ double *result;
+
+ result = PALLOCTYPE(double);
+ *result = HYPOT( pt1->x - pt2->x, pt1->y - pt2->y );
+ return(result);
+}
+
+
+double point_dt(Point *pt1, Point *pt2)
+{
+ return( HYPOT( pt1->x - pt2->x, pt1->y - pt2->y ) );
+}
+
+double *point_slope(Point *pt1, Point *pt2)
+{
+ double *result;
+
+ result = PALLOCTYPE(double);
+ if (point_vert(pt1, pt2))
+ *result = DBL_MAX;
+ else
+ *result = (pt1->y - pt2->y) / (pt1->x - pt1->x);
+ return(result);
+}
+
+
+double point_sl(Point *pt1, Point *pt2)
+{
+ return( point_vert(pt1, pt2)
+ ? DBL_MAX
+ : (pt1->y - pt2->y) / (pt1->x - pt2->x) );
+}
+
+/***********************************************************************
+ **
+ ** Routines for 2D line segments.
+ **
+ ***********************************************************************/
+
+/*----------------------------------------------------------
+ * String to lseg, lseg to string conversion.
+ * External form: "(id, info, x1, y1, x2, y2)"
+ *---------------------------------------------------------*/
+
+LSEG *lseg_in(char *str)
+{
+ char *coord[LSEGNARGS], *p;
+ int i;
+ LSEG *result;
+
+ if (str == NULL)
+ elog (WARN," Bad (null) box external representation");
+
+ if ((p = (char *)strchr(str, LDELIM)) == (char *)NULL)
+ elog (WARN, "Bad lseg external representation '%s'",str);
+ for (i = 0, p = str; *p && i < LSEGNARGS && *p != RDELIM; p++)
+ if (*p == DELIM || (*p == LDELIM && !i))
+ coord[i++] = p + 1;
+ if (i < LSEGNARGS - 1)
+ elog (WARN, "Bad lseg external representation '%s'", str);
+ result = PALLOCTYPE(LSEG);
+ result->p[0].x = atof(coord[0]);
+ result->p[0].y = atof(coord[1]);
+ result->p[1].x = atof(coord[2]);
+ result->p[1].y = atof(coord[3]);
+ result->m = point_sl(&result->p[0], &result->p[1]);
+
+ return(result);
+}
+
+
+char *lseg_out(LSEG *ls)
+{
+ char *result;
+
+ if (ls == NULL)
+ return(NULL);
+ result = (char *)PALLOC(80);
+ (void) sprintf(result, "(%G,%G,%G,%G)",
+ ls->p[0].x, ls->p[0].y, ls->p[1].x, ls->p[1].y);
+ return(result);
+}
+
+
+/* lseg_construct -
+ * form a LSEG from two Points.
+ */
+LSEG *lseg_construct(Point *pt1, Point *pt2)
+{
+ LSEG *result;
+
+ result = PALLOCTYPE(LSEG);
+ result->p[0].x = pt1->x;
+ result->p[0].y = pt1->y;
+ result->p[1].x = pt2->x;
+ result->p[1].y = pt2->y;
+ result->m = point_sl(pt1, pt2);
+
+ return(result);
+}
+
+/* like lseg_construct, but assume space already allocated */
+void statlseg_construct(LSEG *lseg, Point *pt1, Point *pt2)
+{
+ lseg->p[0].x = pt1->x;
+ lseg->p[0].y = pt1->y;
+ lseg->p[1].x = pt2->x;
+ lseg->p[1].y = pt2->y;
+ lseg->m = point_sl(pt1, pt2);
+}
+
+/*----------------------------------------------------------
+ * Relative position routines.
+ *---------------------------------------------------------*/
+
+/*
+ ** find intersection of the two lines, and see if it falls on
+ ** both segments.
+ */
+long lseg_intersect(LSEG *l1, LSEG *l2)
+{
+ LINE *ln;
+ Point *interpt;
+ long retval;
+
+ ln = line_construct_pp(&l2->p[0], &l2->p[1]);
+ interpt = interpt_sl(l1, ln);
+
+ if (interpt != NULL && on_ps(interpt, l2)) /* interpt on l1 and l2 */
+ retval = 1;
+ else retval = 0;
+ if (interpt != NULL) PFREE(interpt);
+ PFREE(ln);
+ return(retval);
+}
+
+long lseg_parallel(LSEG *l1, LSEG *l2)
+{
+ return( FPeq(l1->m, l2->m) );
+}
+
+long lseg_perp(LSEG *l1, LSEG *l2)
+{
+ if (! FPzero(l1->m))
+ return( FPeq(l2->m / l1->m, -1.0) );
+ else if (! FPzero(l2->m))
+ return( FPeq(l1->m / l2->m, -1.0) );
+ return(0); /* both 0.0 */
+}
+
+long lseg_vertical(LSEG *lseg)
+{
+ return( FPeq(lseg->p[0].x, lseg->p[1].x) );
+}
+
+long lseg_horizontal(LSEG *lseg)
+{
+ return( FPeq(lseg->p[0].y, lseg->p[1].y) );
+}
+
+
+long lseg_eq(LSEG *l1, LSEG *l2)
+{
+ return( FPeq(l1->p[0].x, l2->p[0].x) &&
+ 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) );
+}
+
+
+/*----------------------------------------------------------
+ * Line arithmetic routines.
+ *---------------------------------------------------------*/
+
+/* lseg_distance -
+ * If two segments don't intersect, then the closest
+ * point will be from one of the endpoints to the other
+ * segment.
+ */
+double *lseg_distance(LSEG *l1, LSEG *l2)
+{
+ double *d, *result;
+
+ result = PALLOCTYPE(double);
+ if (lseg_intersect(l1, l2)) {
+ *result = 0.0;
+ return(result);
+ }
+ *result = DBL_MAX;
+ d = dist_ps(&l1->p[0], l2);
+ *result = Min(*result, *d);
+ PFREE(d);
+ d = dist_ps(&l1->p[1], l2);
+ *result = Min(*result, *d);
+ PFREE(d);
+ d = dist_ps(&l2->p[0], l1);
+ *result = Min(*result, *d);
+ PFREE(d);
+ d = dist_ps(&l2->p[1], l1);
+ *result = Min(*result, *d);
+ PFREE(d);
+
+ return(result);
+}
+
+/* distance between l1, l2 */
+double lseg_dt(LSEG *l1, LSEG *l2)
+{
+ double *d, result;
+
+ if (lseg_intersect(l1, l2))
+ return(0.0);
+ result = DBL_MAX;
+ d = dist_ps(&l1->p[0], l2);
+ result = Min(result, *d);
+ PFREE(d);
+ d = dist_ps(&l1->p[1], l2);
+ result = Min(result, *d);
+ PFREE(d);
+ d = dist_ps(&l2->p[0], l1);
+ result = Min(result, *d);
+ PFREE(d);
+ d = dist_ps(&l2->p[1], l1);
+ result = Min(result, *d);
+ PFREE(d);
+
+ return(result);
+}
+
+
+/* lseg_interpt -
+ * Find the intersection point of two segments (if any).
+ * Find the intersection of the appropriate lines; if the
+ * point is not on a given segment, there is no valid segment
+ * intersection point at all.
+ */
+Point *lseg_interpt(LSEG *l1, LSEG *l2)
+{
+ Point *result;
+ LINE *tmp1, *tmp2;
+
+ tmp1 = line_construct_pp(&l1->p[0], &l1->p[1]);
+ tmp2 = line_construct_pp(&l2->p[0], &l2->p[1]);
+ result = line_interpt(tmp1, tmp2);
+ if (result)
+ if (! on_ps(result, l1)) {
+ PFREE(result);
+ result = NULL;
+ }
+
+ PFREE(tmp1);
+ PFREE(tmp2);
+ return(result);
+}
+
+/***********************************************************************
+ **
+ ** Routines for position comparisons of differently-typed
+ ** 2D objects.
+ **
+ ***********************************************************************/
+
+#define ABOVE 1
+#define BELOW 0
+#define UNDEF -1
+
+
+/*---------------------------------------------------------------------
+ * dist_
+ * Minimum distance from one object to another.
+ *-------------------------------------------------------------------*/
+
+double *dist_pl(Point *pt, LINE *line)
+{
+ double *result;
+
+ result = PALLOCTYPE(double);
+ *result = (line->A * pt->x + line->B * pt->y + line->C) /
+ HYPOT(line->A, line->B);
+
+ return(result);
+}
+
+double *dist_ps(Point *pt, LSEG *lseg)
+{
+ double m; /* slope of perp. */
+ LINE *ln;
+ double *result, *tmpdist;
+ Point *ip;
+
+ /* construct a line that's perpendicular. See if the intersection of
+ the two lines is on the line segment. */
+ if (lseg->p[1].x == lseg->p[0].x)
+ m = 0;
+ else if (lseg->p[1].y == lseg->p[0].y) /* slope is infinite */
+ m = DBL_MAX;
+ else m = (-1) * (lseg->p[1].y - lseg->p[0].y) /
+ (lseg->p[1].x - lseg->p[0].x);
+ ln = line_construct_pm(pt, m);
+
+ if ((ip = interpt_sl(lseg, ln)) != NULL)
+ result = point_distance(pt, ip);
+ else /* intersection is not on line segment, so distance is min
+ of distance from point to an endpoint */
+ {
+ result = point_distance(pt, &lseg->p[0]);
+ tmpdist = point_distance(pt, &lseg->p[1]);
+ if (*tmpdist < *result) *result = *tmpdist;
+ PFREE (tmpdist);
+ }
+
+ if (ip != NULL) PFREE(ip);
+ PFREE(ln);
+ return (result);
+}
+
+
+/*
+ ** Distance from a point to a path
+ */
+double *dist_ppth(Point *pt, PATH *path)
+{
+ double *result;
+ double *tmp;
+ int i;
+ LSEG lseg;
+
+ switch (path->npts) {
+ case 0:
+ result = PALLOCTYPE(double);
+ *result = Abs((double) DBL_MAX); /* +infinity */
+ break;
+ case 1:
+ result = point_distance(pt, &path->p[0]);
+ break;
+ default:
+ /*
+ * the distance from a point to a path is the smallest distance
+ * from the point to any of its constituent segments.
+ */
+ Assert(path->npts > 1);
+ result = PALLOCTYPE(double);
+ for (i = 0; i < path->npts - 1; ++i) {
+ statlseg_construct(&lseg, &path->p[i], &path->p[i+1]);
+ tmp = dist_ps(pt, &lseg);
+ if (i == 0 || *tmp < *result)
+ *result = *tmp;
+ PFREE(tmp);
+ }
+ break;
+ }
+ return(result);
+}
+
+double *dist_pb(Point *pt, BOX *box)
+{
+ Point *tmp;
+ double *result;
+
+ tmp = close_pb(pt, box);
+ result = point_distance(tmp, pt);
+
+ PFREE(tmp);
+ return(result);
+}
+
+
+double *dist_sl(LSEG *lseg, LINE *line)
+{
+ double *result;
+
+ if (inter_sl(lseg, line)) {
+ result = PALLOCTYPE(double);
+ *result = 0.0;
+ } else /* parallel */
+ result = dist_pl(&lseg->p[0], line);
+
+ return(result);
+}
+
+
+double *dist_sb(LSEG *lseg, BOX *box)
+{
+ Point *tmp;
+ double *result;
+
+ tmp = close_sb(lseg, box);
+ if (tmp == NULL) {
+ result = PALLOCTYPE(double);
+ *result = 0.0;
+ } else {
+ result = dist_pb(tmp, box);
+ PFREE(tmp);
+ }
+
+ return(result);
+}
+
+
+double *dist_lb(LINE *line, BOX *box)
+{
+ Point *tmp;
+ double *result;
+
+ tmp = close_lb(line, box);
+ if (tmp == NULL) {
+ result = PALLOCTYPE(double);
+ *result = 0.0;
+ } else {
+ result = dist_pb(tmp, box);
+ PFREE(tmp);
+ }
+
+ return(result);
+}
+
+
+/*---------------------------------------------------------------------
+ * interpt_
+ * Intersection point of objects.
+ * We choose to ignore the "point" of intersection between
+ * lines and boxes, since there are typically two.
+ *-------------------------------------------------------------------*/
+
+Point *interpt_sl(LSEG *lseg, LINE *line)
+{
+ LINE *tmp;
+ Point *p;
+
+ tmp = line_construct_pp(&lseg->p[0], &lseg->p[1]);
+ p = line_interpt(tmp, line);
+ if (p)
+ if (! on_ps(p, lseg)) {
+ PFREE(p);
+ p = NULL;
+ }
+
+ PFREE(tmp);
+ return(p);
+}
+
+
+/*---------------------------------------------------------------------
+ * close_
+ * Point of closest proximity between objects.
+ *-------------------------------------------------------------------*/
+
+/* close_pl -
+ * The intersection point of a perpendicular of the line
+ * through the point.
+ */
+Point *close_pl(Point *pt, LINE *line)
+{
+ Point *result;
+ LINE *tmp;
+ double invm;
+
+ result = PALLOCTYPE(Point);
+ if (FPeq(line->A, -1.0) && FPzero(line->B)) { /* vertical */
+ result->x = line->C;
+ result->y = pt->y;
+ return(result);
+ } else if (FPzero(line->m)) { /* horizontal */
+ result->x = pt->x;
+ result->y = line->C;
+ return(result);
+ }
+ /* drop a perpendicular and find the intersection point */
+ invm = -1.0 / line->m;
+ tmp = line_construct_pm(pt, invm);
+ result = line_interpt(tmp, line);
+ return(result);
+}
+
+
+/* close_ps -
+ * 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.
+ */
+Point *close_ps(Point *pt, LSEG *lseg)
+{
+ Point *result;
+ LINE *tmp;
+ double invm;
+ int xh, yh;
+
+ result = NULL;
+ xh = lseg->p[0].x < lseg->p[1].x;
+ yh = lseg->p[0].y < lseg->p[1].y;
+ if (pt->x < lseg->p[!xh].x)
+ result = point_copy(&lseg->p[!xh]);
+ else if (pt->x > lseg->p[xh].x)
+ result = point_copy(&lseg->p[xh]);
+ else if (pt->y < lseg->p[!yh].y)
+ result = point_copy(&lseg->p[!yh]);
+ else if (pt->y > lseg->p[yh].y)
+ result = point_copy(&lseg->p[yh]);
+ if (result)
+ return(result);
+ if (FPeq(lseg->p[0].x, lseg->p[1].x)) { /* vertical */
+ result->x = lseg->p[0].x;
+ result->y = pt->y;
+ return(result);
+ } else if (FPzero(lseg->m)) { /* horizontal */
+ result->x = pt->x;
+ result->y = lseg->p[0].y;
+ return(result);
+ }
+
+ invm = -1.0 / lseg->m;
+ tmp = line_construct_pm(pt, invm);
+ result = interpt_sl(lseg, tmp);
+ return(result);
+}
+
+Point *close_pb(Point *pt, BOX *box)
+{
+ /* think about this one for a while */
+
+ return(NULL);
+}
+
+Point *close_sl(LSEG *lseg, LINE *line)
+{
+ Point *result;
+ double *d1, *d2;
+
+ result = interpt_sl(lseg, line);
+ if (result)
+ return(result);
+ d1 = dist_pl(&lseg->p[0], line);
+ d2 = dist_pl(&lseg->p[1], line);
+ if (d1 < d2)
+ result = point_copy(&lseg->p[0]);
+ else
+ result = point_copy(&lseg->p[1]);
+
+ PFREE(d1);
+ PFREE(d2);
+ return(result);
+}
+
+Point *close_sb(LSEG *lseg, BOX *box)
+{
+ /* think about this one for a while */
+
+ return(NULL);
+}
+
+Point *close_lb(LINE *line, BOX *box)
+{
+ /* think about this one for a while */
+
+ return(NULL);
+}
+
+/*---------------------------------------------------------------------
+ * on_
+ * Whether one object lies completely within another.
+ *-------------------------------------------------------------------*/
+
+/* on_pl -
+ * Does the point satisfy the equation?
+ */
+long on_pl(Point *pt, LINE *line)
+{
+ return( FPzero(line->A * pt->x + line->B * pt->y + line->C) );
+}
+
+
+/* on_ps -
+ * Determine colinearity by detecting a triangle inequality.
+ */
+long on_ps(Point *pt, LSEG *lseg)
+{
+ return( point_dt(pt, &lseg->p[0]) + point_dt(pt, &lseg->p[1])
+ == point_dt(&lseg->p[0], &lseg->p[1]) );
+}
+
+long on_pb(Point *pt, BOX *box)
+{
+ return( pt->x <= box->xh && pt->x >= box->xl &&
+ pt->y <= box->yh && pt->y >= box->yl );
+}
+
+/* on_ppath -
+ * Whether a point lies within (on) a polyline.
+ * If open, we have to (groan) check each segment.
+ * If closed, we use the old O(n) ray method for point-in-polygon.
+ * The ray is horizontal, from pt out to the right.
+ * Each segment that crosses the ray counts as an
+ * intersection; note that an endpoint or edge may touch
+ * but not cross.
+ * (we can do p-in-p in lg(n), but it takes preprocessing)
+ */
+#define NEXT(A) ((A+1) % path->npts) /* cyclic "i+1" */
+
+long on_ppath(Point *pt, PATH *path)
+{
+ int above, next, /* is the seg above the ray? */
+ inter, /* # of times path crosses ray */
+ hi, /* index inc of higher seg (0,1) */
+ i, n;
+ double a, b, x,
+ yh, yl, xh, xl;
+
+ if (! path->closed) { /*-- OPEN --*/
+ n = path->npts - 1;
+ a = point_dt(pt, &path->p[0]);
+ for (i = 0; i < n; i++) {
+ b = point_dt(pt, &path->p[i+1]);
+ if (FPeq(a+b,
+ point_dt(&path->p[i], &path->p[i+1])))
+ return(1);
+ a = b;
+ }
+ return(0);
+ }
+
+ inter = 0; /*-- CLOSED --*/
+ above = FPgt(path->p[0].y, pt->y) ? ABOVE :
+ FPlt(path->p[0].y, pt->y) ? BELOW : UNDEF;
+
+ for (i = 0; i < path->npts; i++) {
+ hi = path->p[i].y < path->p[NEXT(i)].y;
+ /* must take care of wrap around to original vertex for closed paths */
+ yh = (i+hi < path->npts) ? path->p[i+hi].y : path->p[0].y;
+ yl = (i+!hi < path->npts) ? path->p[i+!hi].y : path->p[0].y;
+ hi = path->p[i].x < path->p[NEXT(i)].x;
+ xh = (i+hi < path->npts) ? path->p[i+hi].x : path->p[0].x;
+ xl = (i+!hi < path->npts) ? path->p[i+!hi].x : path->p[0].x;
+ /* skip seg if it doesn't touch the ray */
+
+ if (FPeq(yh, yl)) /* horizontal seg? */
+ if (FPge(pt->x, xl) && FPle(pt->x, xh) &&
+ FPeq(pt->y, yh))
+ return(1); /* pt lies on seg */
+ else
+ continue; /* skip other hz segs */
+ if (FPlt(yh, pt->y) || /* pt is strictly below seg */
+ FPgt(yl, pt->y)) /* strictly above */
+ continue;
+
+ /* seg touches the ray, find out where */
+
+ x = FPeq(xh, xl) /* vertical seg? */
+ ? path->p[i].x
+ : (pt->y - path->p[i].y) /
+ point_sl(&path->p[i],
+ &path->p[NEXT(i)]) +
+ path->p[i].x;
+ if (FPeq(x, pt->x)) /* pt lies on this seg */
+ return(1);
+
+ /* does the seg actually cross the ray? */
+
+ next = FPgt(path->p[NEXT(i)].y, pt->y) ? ABOVE :
+ FPlt(path->p[NEXT(i)].y, pt->y) ? BELOW : above;
+ inter += FPge(x, pt->x) && next != above;
+ above = next;
+ }
+ return( above == UNDEF || /* path is horizontal */
+ inter % 2); /* odd # of intersections */
+}
+
+
+long on_sl(LSEG *lseg, LINE *line)
+{
+ return( on_pl(&lseg->p[0], line) && on_pl(&lseg->p[1], line) );
+}
+
+long on_sb(LSEG *lseg, BOX *box)
+{
+ return( on_pb(&lseg->p[0], box) && on_pb(&lseg->p[1], box) );
+}
+
+/*---------------------------------------------------------------------
+ * inter_
+ * Whether one object intersects another.
+ *-------------------------------------------------------------------*/
+
+long inter_sl(LSEG *lseg, LINE *line)
+{
+ Point *tmp;
+
+ tmp = interpt_sl(lseg, line);
+ if (tmp) {
+ PFREE(tmp);
+ return(1);
+ }
+ return(0);
+}
+
+long inter_sb(LSEG *lseg, BOX *box)
+{
+ return(0);
+}
+
+long inter_lb(LINE *line, BOX *box)
+{
+ return(0);
+}
+
+/*------------------------------------------------------------------
+ * The following routines define a data type and operator class for
+ * POLYGONS .... Part of which (the polygon's bounding box is built on
+ * top of the BOX data type.
+ *
+ * make_bound_box - create the bounding box for the input polygon
+ *------------------------------------------------------------------*/
+
+/* Maximum number of output digits printed */
+#define P_MAXDIG 12
+
+/*---------------------------------------------------------------------
+ * Make the smallest bounding box for the given polygon.
+ *---------------------------------------------------------------------*/
+void make_bound_box(POLYGON *poly)
+{
+ double x1,y1,x2,y2;
+ int npts = poly->npts;
+
+ if (npts > 0) {
+ x1 = poly_min((double *)poly->pts, npts);
+ x2 = poly_max((double *)poly->pts, npts);
+ y1 = poly_min(((double *)poly->pts)+npts, npts),
+ y2 = poly_max(((double *)poly->pts)+npts, npts);
+ box_fill(&(poly->boundbox), x1, x2, y1, y2);
+ }
+}
+
+/*------------------------------------------------------------------
+ * polygon_in - read in the polygon from a string specification
+ * the string is of the form "(f8,f8,f8,f8,...,f8)"
+ *------------------------------------------------------------------*/
+POLYGON *poly_in(char *s)
+{
+ POLYGON *poly;
+ long points;
+ double *xp, *yp, strtod();
+ int i, size;
+
+ if((points = poly_pt_count(s, ',')) < 0)
+ elog(WARN, "Bad polygon external representation '%s'", s);
+
+ size = offsetof(POLYGON, pts[0]) + 2 * sizeof(double) * points;
+ poly = (POLYGON *) PALLOC(size);
+ memset((char *) poly, 0, size); /* zero any holes */
+
+ if (!PointerIsValid(poly))
+ elog(WARN, "Memory allocation failed, can't input polygon");
+
+ poly->npts = points;
+ poly->size = size;
+
+ /* Store all x coords followed by all y coords */
+ xp = (double *) &(poly->pts[0]);
+ yp = (double *) (poly->pts + points*sizeof(double));
+
+ s++; /* skip LDELIM */
+
+ for (i=0; i
+ {
+ *xp = strtod(s, &s);
+ s++; /* skip delimiter */
+ *yp = strtod(s, &s);
+ s++; /* skip delimiter */
+ }
+ make_bound_box(poly);
+ return (poly);
+}
+
+/*-------------------------------------------------------------
+ * poly_pt_count - count the number of points specified in the
+ * polygon.
+ *-------------------------------------------------------------*/
+long poly_pt_count(char *s, char delim)
+{
+ long total = 0;
+
+ if (*s++ != LDELIM) /* no left delimeter */
+ return (long) -1;
+
+ while (*s && (*s != RDELIM))
+ {
+ while (*s && (*s != delim))
+ s++;
+ total++; /* found one */
+ if (*s)
+ s++; /* bump s past the delimiter */
+ }
+
+ /* if there was no right delimiter OR an odd number of points */
+
+ if ((*(s-1) != RDELIM) || ((total%2) != 0))
+ return (long) -1;
+
+ return (total/2);
+}
+
+/*---------------------------------------------------------------
+ * poly_out - convert internal POLYGON representation to the
+ * character string format "(f8,f8,f8,f8,...f8)"
+ *---------------------------------------------------------------*/
+char *poly_out(POLYGON *poly)
+{
+ int i;
+ double *xp, *yp;
+ char *output, *outptr;
+
+ /*-----------------------------------------------------
+ * Get enough space for "(f8,f8,f8,f8,...,f8)"
+ * which P_MAXDIG+1 for each coordinate plus 2
+ * for parens and 1 for the null
+ *-----------------------------------------------------*/
+ output = (char *)PALLOC(2*(P_MAXDIG+1)*poly->npts + 3);
+ outptr = output;
+
+ if (!output)
+ elog(WARN, "Memory allocation failed, can't output polygon");
+
+ *outptr++ = LDELIM;
+
+ xp = (double *) poly->pts;
+ yp = (double *) (poly->pts + (poly->npts * sizeof(double)));
+
+ sprintf(outptr, "%*g,%*g", P_MAXDIG, *xp++, P_MAXDIG, *yp++);
+ outptr += (2*P_MAXDIG + 1);
+
+ for (i=1; i
npts; i++,xp++,yp++)+ {
+ sprintf(outptr, ",%*g,%*g", P_MAXDIG, *xp, P_MAXDIG, *yp);
+ outptr += 2*(P_MAXDIG + 1);
+ }
+ *outptr++ = RDELIM;
+ *outptr = '\0';
+ return (output);
+}
+
+/*-------------------------------------------------------
+ * Find the largest coordinate out of n coordinates
+ *-------------------------------------------------------*/
+double poly_max(double *coords, int ncoords)
+{
+ double max;
+
+ max = *coords++;
+ ncoords--;
+ while (ncoords--)
+ {
+ if (*coords > max)
+ max = *coords;
+ coords++;
+ }
+ return max;
+}
+
+/*-------------------------------------------------------
+ * Find the smallest coordinate out of n coordinates
+ *-------------------------------------------------------*/
+double poly_min(double *coords, int ncoords)
+{
+ double min;
+
+ min = *coords++;
+ ncoords--;
+ while (ncoords--)
+ {
+ if (*coords < min)
+ min = *coords;
+ coords++;
+ }
+ return min;
+}
+
+/*-------------------------------------------------------
+ * Is polygon A strictly left of polygon B? i.e. is
+ * the right most point of A left of the left most point
+ * of B?
+ *-------------------------------------------------------*/
+long poly_left(POLYGON *polya, POLYGON *polyb)
+{
+ double right, left;
+
+ if (polya->npts > 0)
+ right = poly_max((double *)polya->pts, polya->npts);
+ else
+ right = polya->boundbox.xh;
+ if (polyb->npts > 0)
+ left = poly_min((double *)polyb->pts, polyb->npts);
+ else
+ left = polyb->boundbox.xl;
+
+ return (right < left);
+}
+
+/*-------------------------------------------------------
+ * Is polygon A overlapping or left of polygon B? i.e. is
+ * the left most point of A left of the right most point
+ * of B?
+ *-------------------------------------------------------*/
+long poly_overleft(POLYGON *polya, POLYGON *polyb)
+{
+ double left, right;
+
+ if (polya->npts > 0)
+ left = poly_min((double *)polya->pts, polya->npts);
+ else
+ left = polya->boundbox.xl;
+ if (polyb->npts > 0)
+ right = poly_max((double *)polyb->pts, polyb->npts);
+ else
+ right = polyb->boundbox.xh;
+
+ return (left <= right);
+}
+
+/*-------------------------------------------------------
+ * Is polygon A strictly right of polygon B? i.e. is
+ * the left most point of A right of the right most point
+ * of B?
+ *-------------------------------------------------------*/
+long poly_right(POLYGON *polya, POLYGON *polyb)
+{
+ double right, left;
+
+ if (polya->npts > 0)
+ left = poly_min((double *)polya->pts, polya->npts);
+ else
+ left = polya->boundbox.xl;
+ if (polyb->npts > 0)
+ right = poly_max((double *)polyb->pts, polyb->npts);
+ else
+ right = polyb->boundbox.xh;
+
+ return (left > right);
+}
+
+/*-------------------------------------------------------
+ * Is polygon A overlapping or right of polygon B? i.e. is
+ * the right most point of A right of the left most point
+ * of B?
+ *-------------------------------------------------------*/
+long poly_overright(POLYGON *polya, POLYGON *polyb)
+{
+ double right, left;
+
+ if (polya->npts > 0)
+ right = poly_max((double *)polya->pts, polya->npts);
+ else
+ right = polya->boundbox.xh;
+ if (polyb->npts > 0)
+ left = poly_min((double *)polyb->pts, polyb->npts);
+ else
+ left = polyb->boundbox.xl;
+
+ return (right > left);
+}
+
+/*-------------------------------------------------------
+ * Is polygon A the same as polygon B? i.e. are all the
+ * points the same?
+ *-------------------------------------------------------*/
+long poly_same(POLYGON *polya, POLYGON *polyb)
+{
+ int i;
+ double *axp, *bxp; /* point to x coordinates for a and b */
+
+ if (polya->npts != polyb->npts)
+ return 0;
+
+ axp = (double *)polya->pts;
+ bxp = (double *)polyb->pts;
+
+ for (i=0; i
npts; axp++, bxp++, i++)+ {
+ if (*axp != *bxp)
+ return 0;
+ }
+ return 1;
+}
+
+/*-----------------------------------------------------------------
+ * Determine if polygon A overlaps polygon B by determining if
+ * their bounding boxes overlap.
+ *-----------------------------------------------------------------*/
+long poly_overlap(POLYGON *polya, POLYGON *polyb)
+{
+ return box_overlap(&(polya->boundbox), &(polyb->boundbox));
+}
+
+/*-----------------------------------------------------------------
+ * Determine if polygon A contains polygon B by determining if A's
+ * bounding box contains B's bounding box.
+ *-----------------------------------------------------------------*/
+long poly_contain(POLYGON *polya, POLYGON *polyb)
+{
+ return box_contain(&(polya->boundbox), &(polyb->boundbox));
+}
+
+/*-----------------------------------------------------------------
+ * Determine if polygon A is contained by polygon B by determining
+ * if A's bounding box is contained by B's bounding box.
+ *-----------------------------------------------------------------*/
+long poly_contained(POLYGON *polya, POLYGON *polyb)
+{
+ return box_contained(&(polya->boundbox), &(polyb->boundbox));
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * geo-selfuncs.c--
+ * Selectivity routines registered in the operator catalog in the
+ * "oprrest" and "oprjoin" attributes.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/geo-selfuncs.c,v 1.1.1.1 1996/07/09 06:22:04 scrappy Exp $
+ *
+ * XXX These are totally bogus.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "access/attnum.h"
+#include "utils/geo-decls.h" /* where function declarations go */
+#include "utils/palloc.h"
+
+float64
+areasel(Oid opid,
+ Oid relid,
+ AttrNumber attno,
+ char *value,
+ int32 flag)
+{
+ float64 result;
+
+ result = (float64) palloc(sizeof(float64data));
+ *result = 1.0 / 4.0;
+ return(result);
+}
+
+float64
+areajoinsel(Oid opid,
+ Oid relid,
+ AttrNumber attno,
+ char *value,
+ int32 flag)
+{
+ float64 result;
+
+ result = (float64) palloc(sizeof(float64data));
+ *result = 1.0 / 4.0;
+ return(result);
+}
+
+/*
+ * Selectivity functions for rtrees. These are bogus -- unless we know
+ * the actual key distribution in the index, we can't make a good prediction
+ * of the selectivity of these operators.
+ *
+ * In general, rtrees need to search multiple subtrees in order to guarantee
+ * that all occurrences of the same key have been found. Because of this,
+ * the heuristic selectivity functions we return are higher than they would
+ * otherwise be.
+ */
+
+/*
+ * left_sel -- How likely is a box to be strictly left of (right of, above,
+ * below) a given box?
+ */
+
+float64
+leftsel(Oid opid,
+ Oid relid,
+ AttrNumber attno,
+ char *value,
+ int32 flag)
+{
+ float64 result;
+
+ result = (float64) palloc(sizeof(float64data));
+ *result = 1.0 / 6.0;
+ return(result);
+}
+
+float64
+leftjoinsel(Oid opid,
+ Oid relid,
+ AttrNumber attno,
+ char *value,
+ int32 flag)
+{
+ float64 result;
+
+ result = (float64) palloc(sizeof(float64data));
+ *result = 1.0 / 6.0;
+ return(result);
+}
+
+/*
+ * contsel -- How likely is a box to contain (be contained by) a given box?
+ */
+float64
+contsel(Oid opid,
+ Oid relid,
+ AttrNumber attno,
+ char *value,
+ int32 flag)
+{
+ float64 result;
+
+ result = (float64) palloc(sizeof(float64data));
+ *result = 1.0 / 10.0;
+ return(result);
+}
+
+float64
+contjoinsel(Oid opid,
+ Oid relid,
+ AttrNumber attno,
+ char *value,
+ int32 flag)
+{
+ float64 result;
+
+ result = (float64) palloc(sizeof(float64data));
+ *result = 1.0 / 10.0;
+ return(result);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * int.c--
+ * Functions for the built-in integer types.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.1.1.1 1996/07/09 06:22:04 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ * OLD COMMENTS
+ * I/O routines:
+ * int2in, int2out, int28in, int28out, int4in, int4out
+ * Conversion routines:
+ * itoi
+ * Boolean operators:
+ * inteq, intne, intlt, intle, intgt, intge
+ * Arithmetic operators:
+ * intpl, intmi, int4mul, intdiv
+ *
+ * Arithmetic operators:
+ * intmod, int4fac
+ *
+ * XXX makes massive and possibly unwarranted type promotion assumptions.
+ * fix me when we figure out what we want to do about ANSIfication...
+ */
+
+#include "postgres.h"
+#include "fmgr.h"
+#include "utils/builtins.h" /* where the declarations go */
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+/*****************************************************************************
+ * USER I/O ROUTINES *
+ *****************************************************************************/
+
+/*
+ * int2in - converts "num" to short
+ */
+int32 int2in(char *num)
+{
+ return((int32) pg_atoi(num, sizeof(int16), '\0'));
+}
+
+/*
+ * int2out - converts short to "num"
+ */
+char *int2out(int16 sh)
+{
+ char *result;
+
+ result = (char *)palloc(7); /* assumes sign, 5 digits, '\0' */
+ itoa((int) sh, result);
+ return(result);
+}
+
+/*
+ * int28in - converts "num num ..." to internal form
+ *
+ * Note:
+ * Fills any nonexistent digits with NULLs.
+ */
+int16 *int28in(char *shs)
+{
+ register int16 (*result)[];
+ int nums;
+
+ if (shs == NULL)
+ return(NULL);
+ result = (int16 (*)[]) palloc(sizeof(int16 [8]));
+ if ((nums = sscanf(shs, "%hd%hd%hd%hd%hd%hd%hd%hd",
+ *result,
+ *result + 1,
+ *result + 2,
+ *result + 3,
+ *result + 4,
+ *result + 5,
+ *result + 6,
+ *result + 7)) != 8) {
+ do
+ (*result)[nums++] = 0;
+ while (nums < 8);
+ }
+ return((int16 *) result);
+}
+
+/*
+ * int28out - converts internal form to "num num ..."
+ */
+char *int28out(int16 (*shs)[])
+{
+ register int num;
+ register int16 *sp;
+ register char *rp;
+ char *result;
+
+ if (shs == NULL) {
+ result = (char *)palloc(2);
+ result[0] = '-';
+ result[1] = '\0';
+ return(result);
+ }
+ rp = result = (char *)palloc(8 * 7); /* assumes sign, 5 digits, ' ' */
+ sp = *shs;
+ for (num = 8; num != 0; num--) {
+ itoa(*sp++, rp);
+ while (*++rp != '\0')
+ ;
+ *rp++ = ' ';
+ }
+ *--rp = '\0';
+ return(result);
+}
+
+/*
+ * int28in - converts "num num ..." to internal form
+ *
+ * Note:
+ * Fills any nonexistent digits with NULLs.
+ */
+int32 *int44in(char *input_string)
+{
+ int32 *foo = (int32 *)palloc(4*sizeof(int32));
+ register int i = 0;
+
+ i = sscanf(input_string,
+ "%d, %d, %d, %d",
+ &foo[0],
+ &foo[1],
+ &foo[2],
+ &foo[3]);
+ while (i < 4)
+ foo[i++] = 0;
+
+ return(foo);
+}
+
+/*
+ * int28out - converts internal form to "num num ..."
+ */
+char *int44out(int32 an_array[])
+{
+ int temp = 4;
+ char *output_string = NULL;
+ int i;
+
+ if ( temp > 0 ) {
+ char *walk;
+ output_string = (char *)palloc(16*temp); /* assume 15 digits + sign */
+ walk = output_string;
+ for ( i = 0 ; i < temp ; i++ ) {
+ itoa(an_array[i],walk);
+ while (*++walk != '\0')
+ ;
+ *walk++ = ' ';
+ }
+ *--walk = '\0';
+ }
+ return(output_string);
+}
+
+
+/*****************************************************************************
+ * PUBLIC ROUTINES *
+ *****************************************************************************/
+
+/*
+ * int4in - converts "num" to int4
+ */
+int32 int4in(char *num)
+{
+ return(pg_atoi(num, sizeof(int32), '\0'));
+}
+
+/*
+ * int4out - converts int4 to "num"
+ */
+char *int4out(int32 l)
+{
+ char *result;
+
+ result = (char *)palloc(12); /* assumes sign, 10 digits, '\0' */
+ ltoa(l, result);
+ return(result);
+}
+
+
+/*
+ * ===================
+ * CONVERSION ROUTINES
+ * ===================
+ */
+
+int32 i2toi4(int16 arg1)
+{
+ return((int32) arg1);
+}
+
+int16 i4toi2(int32 arg1)
+{
+ if (arg1< -0x8000)
+ elog(NOTICE, "i4toi2: \"%d\" causes int2 underflow", arg1);
+ if (arg1 > 0x7FFF)
+ elog(NOTICE, "i4toi2: \"%d\" causes int2 overflow", arg1);
+
+ return((int16) arg1);
+}
+
+
+/*
+ * =========================
+ * BOOLEAN OPERATOR ROUTINES
+ * =========================
+ */
+
+/*
+ * inteq - returns 1 iff arg1 == arg2
+ * intne - returns 1 iff arg1 != arg2
+ * intlt - returns 1 iff arg1 < arg2
+ * intle - returns 1 iff arg1 <= arg2
+ * intgt - returns 1 iff arg1 > arg2
+ * intge - returns 1 iff arg1 >= arg2
+ */
+int32 int4eq(int32 arg1, int32 arg2) { return(arg1 == arg2); }
+int32 int4ne(int32 arg1, int32 arg2) { return(arg1 != arg2); }
+int32 int4lt(int32 arg1, int32 arg2) { return(arg1 < arg2); }
+int32 int4le(int32 arg1, int32 arg2) { return(arg1 <= arg2); }
+int32 int4gt(int32 arg1, int32 arg2) { return(arg1 > arg2); }
+int32 int4ge(int32 arg1, int32 arg2) { return(arg1 >= arg2); }
+
+int32 int2eq(int16 arg1, int16 arg2) { return(arg1 == arg2); }
+int32 int2ne(int16 arg1, int16 arg2) { return(arg1 != arg2); }
+int32 int2lt(int16 arg1, int16 arg2) { return(arg1 < arg2); }
+int32 int2le(int16 arg1, int16 arg2) { return(arg1 <= arg2); }
+int32 int2gt(int16 arg1, int16 arg2) { return(arg1 > arg2); }
+int32 int2ge(int16 arg1, int16 arg2) { return(arg1 >= arg2); }
+
+int32 int24eq(int32 arg1, int32 arg2) { return(arg1 == arg2); }
+int32 int24ne(int32 arg1, int32 arg2) { return(arg1 != arg2); }
+int32 int24lt(int32 arg1, int32 arg2) { return(arg1 < arg2); }
+int32 int24le(int32 arg1, int32 arg2) { return(arg1 <= arg2); }
+int32 int24gt(int32 arg1, int32 arg2) { return(arg1 > arg2); }
+int32 int24ge(int32 arg1, int32 arg2) { return(arg1 >= arg2); }
+
+int32 int42eq(int32 arg1, int32 arg2) { return(arg1 == arg2); }
+int32 int42ne(int32 arg1, int32 arg2) { return(arg1 != arg2); }
+int32 int42lt(int32 arg1, int32 arg2) { return(arg1 < arg2); }
+int32 int42le(int32 arg1, int32 arg2) { return(arg1 <= arg2); }
+int32 int42gt(int32 arg1, int32 arg2) { return(arg1 > arg2); }
+int32 int42ge(int32 arg1, int32 arg2) { return(arg1 >= arg2); }
+
+
+int32 keyfirsteq(int16 *arg1, int16 arg2) { return(*arg1 == arg2); }
+
+/*
+ * int[24]pl - returns arg1 + arg2
+ * int[24]mi - returns arg1 - arg2
+ * int[24]mul - returns arg1 * arg2
+ * int[24]div - returns arg1 / arg2
+ */
+int32 int4um(int32 arg) { return(-arg); }
+int32 int4pl(int32 arg1, int32 arg2) { return(arg1 + arg2); }
+int32 int4mi(int32 arg1, int32 arg2) { return(arg1 - arg2); }
+int32 int4mul(int32 arg1, int32 arg2) { return(arg1 * arg2); }
+int32 int4div(int32 arg1, int32 arg2) { return(arg1 / arg2); }
+int32 int4inc(int32 arg) { return(arg + (int32)1); }
+
+int16 int2um(int16 arg) { return(-arg); }
+int16 int2pl(int16 arg1, int16 arg2) { return(arg1 + arg2); }
+int16 int2mi(int16 arg1, int16 arg2) { return(arg1 - arg2); }
+int16 int2mul(int16 arg1, int16 arg2) { return(arg1 * arg2); }
+int16 int2div(int16 arg1, int16 arg2) { return(arg1 / arg2); }
+int16 int2inc(int16 arg) { return(arg + (int16)1); }
+
+int32 int24pl(int32 arg1, int32 arg2) { return(arg1 + arg2); }
+int32 int24mi(int32 arg1, int32 arg2) { return(arg1 - arg2); }
+int32 int24mul(int32 arg1, int32 arg2) { return(arg1 * arg2); }
+int32 int24div(int32 arg1, int32 arg2) { return(arg1 / arg2); }
+
+int32 int42pl(int32 arg1, int32 arg2) { return(arg1 + arg2); }
+int32 int42mi(int32 arg1, int32 arg2) { return(arg1 - arg2); }
+int32 int42mul(int32 arg1, int32 arg2) { return(arg1 * arg2); }
+int32 int42div(int32 arg1, int32 arg2) { return(arg1 / arg2); }
+
+/*
+ * int[24]mod - returns arg1 mod arg2
+ */
+int32 int4mod(int32 arg1, int32 arg2) { return(arg1 % arg2); }
+int32 int2mod(int16 arg1, int16 arg2) { return(arg1 % arg2); }
+int32 int24mod(int32 arg1, int32 arg2) { return(arg1 % arg2); }
+int32 int42mod(int32 arg1, int32 arg2) { return(arg1 % arg2); }
+
+/*
+ * int[24]fac - returns arg1!
+ */
+int32 int4fac(int32 arg1)
+{
+ int32 result;
+
+ if (arg1 < 1)
+ result = 0;
+ else
+ for (result = 1; arg1 > 0; --arg1)
+ result *= arg1;
+ return(result);
+}
+
+int32 int2fac(int16 arg1)
+{
+ int16 result;
+
+ if (arg1 < 1)
+ result = 0;
+ else
+ for (result = 1; arg1 > 0; --arg1)
+ result *= arg1;
+ return(result);
+}
+
+int16 int2larger(int16 arg1, int16 arg2)
+{
+ return ((arg1 > arg2) ? arg1 : arg2);
+}
+
+int16 int2smaller(int16 arg1, int16 arg2)
+{
+ return ((arg1 < arg2) ? arg1 : arg2);
+}
+
+int32 int4larger(int32 arg1, int32 arg2)
+{
+ return ((arg1 > arg2) ? arg1 : arg2);
+}
+
+int32 int4smaller(int32 arg1, int32 arg2)
+{
+ return ((arg1 < arg2) ? arg1 : arg2);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * like.c--
+ * like expression handling code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * /usr/local/devel/pglite/cvs/src/backend/utils/adt/like.c,v 1.1 1995/07/30 23:55:36 emkxp01 Exp
+ *
+ *
+ * NOTES
+ * A big hack of the regexp.c code!! Contributed by
+ * Keith Parks (7/95).
+ *
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "postgres.h" /* postgres system include file */
+#include "utils/elog.h" /* for logging postgres errors */
+#include "utils/palloc.h"
+#include "utils/builtins.h" /* where the function declarations go */
+
+int like(char *text, char *p);
+
+/*
+ * interface routines called by the function manager
+ */
+
+/*
+ fixedlen_like:
+
+ a generic fixed length like routine
+ s - the string to match against (not necessarily null-terminated)
+ p - the pattern
+ charlen - the length of the string
+*/
+static bool
+fixedlen_like(char *s, struct varlena* p, int charlen)
+{
+ char *sterm, *pterm;
+ int result;
+
+ if (!s || !p)
+ return FALSE;
+
+ /* be sure sterm is null-terminated */
+ sterm = (char *) palloc(charlen + 1);
+ memset(sterm, 0, charlen + 1);
+ strncpy(sterm, s, charlen);
+
+ /* p is a text = varlena, not a string so we have to make
+ * a string from the vl_data field of the struct. */
+
+ /* palloc the length of the text + the null character */
+ pterm = (char *) palloc(VARSIZE(p) - VARHDRSZ + 1);
+ memmove(pterm, VARDATA(p), VARSIZE(p) - VARHDRSZ);
+ *(pterm + VARSIZE(p) - VARHDRSZ) = (char)NULL;
+
+ /* do the regexp matching */
+ result = like(sterm, pterm);
+
+ pfree(sterm);
+ pfree(pterm);
+
+ return ((bool) result);
+}
+
+bool
+char2like(uint16 arg1, struct varlena *p)
+{
+ char *s = (char *) &arg1;
+ return (fixedlen_like(s, p, 2));
+}
+
+bool
+char2nlike(uint16 arg1, struct varlena *p)
+{
+ return (!char2like(arg1, p));
+}
+
+bool
+char4like(uint32 arg1, struct varlena *p)
+{
+ char *s = (char *) &arg1;
+ return (fixedlen_like(s, p, 4));
+}
+
+bool
+char4nlike(uint32 arg1, struct varlena *p)
+{
+ return (!char4like(arg1, p));
+}
+
+bool
+char8like(char *s, struct varlena *p)
+{
+ return (fixedlen_like(s, p, 8));
+}
+
+bool
+char8nlike(char *s, struct varlena *p)
+{
+ return (!char8like(s, p));
+}
+
+bool
+char16like(char *s, struct varlena *p)
+{
+ return (fixedlen_like(s, p, 16));
+}
+bool
+char16nlike(char *s, struct varlena *p)
+{
+ return (!char16like(s, p));
+}
+
+bool
+namelike(NameData *n, struct varlena *p)
+{
+ return (fixedlen_like(n->data, p, NAMEDATALEN));
+}
+
+bool
+namenlike(NameData *s, struct varlena *p)
+{
+ return (!namelike(s, p));
+}
+
+bool
+textlike(struct varlena *s, struct varlena *p)
+{
+ return (fixedlen_like(VARDATA(s), p, VARSIZE(s) - VARHDRSZ));
+}
+
+bool textnlike(struct varlena *s, struct varlena *p)
+{
+ return (!textlike(s, p));
+}
+
+
+/* $Revision: 1.1.1.1 $
+** "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.
+** Rich $alz is now .
+** Special thanks to Lars Mathiesen for the LABORT code.
+**
+** This code was shamelessly stolen from the "pql" code by myself and
+** slightly modified :)
+**
+** All references to the word "star" were replaced by "percent"
+** All references to the word "wild" were replaced by "like"
+**
+** All the nice shell RE matching stuff was replaced by just "_" and "%"
+**
+** As I don't have a copy of the SQL standard handy I wasn't sure whether
+** to leave in the '\' escape character handling. (I suspect the standard
+** handles "%%" as a single literal percent)
+**
+** Keith Parks.
+**
+** [SQL92 lets you specify the escape character by saying
+** LIKE
ESCAPE . We are a small operation+** so we force you to use '\'. - ay 7/95]
+**
+*/
+
+#define LIKE_TRUE 1
+#define LIKE_FALSE 0
+#define LIKE_ABORT -1
+
+/*
+** Match text and p, return LIKE_TRUE, LIKE_FALSE, or LIKE_ABORT.
+*/
+static int
+DoMatch(register char *text, register char *p)
+{
+ register int matched;
+
+ for ( ; *p; text++, p++) {
+ if (*text == '\0' && *p != '%')
+ return LIKE_ABORT;
+ switch (*p) {
+ case '\\':
+ /* Literal match with following character. */
+ p++;
+ /* FALLTHROUGH */
+ default:
+ if (*text != *p)
+ return LIKE_FALSE;
+ continue;
+ case '_':
+ /* Match anything. */
+ continue;
+ case '%':
+ while (*++p == '%')
+ /* Consecutive percents act just like one. */
+ continue;
+ if (*p == '\0')
+ /* Trailing percent matches everything. */
+ return LIKE_TRUE;
+ while (*text)
+ if ((matched = DoMatch(text++, p)) != LIKE_FALSE)
+ return matched;
+ return LIKE_ABORT;
+ }
+ }
+
+ return *text == '\0';
+}
+
+
+/*
+** User-level routine. Returns TRUE or FALSE.
+*/
+int
+like(char *text, char *p)
+{
+ if (p[0] == '%' && p[1] == '\0')
+ return TRUE;
+ return (DoMatch(text, p) == LIKE_TRUE);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * misc.c--
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/misc.c,v 1.1.1.1 1996/07/09 06:22:04 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "postgres.h"
+#include "utils/datum.h"
+#include "catalog/pg_type.h"
+#include "utils/builtins.h"
+
+#if !defined(PORTNAME_linux) && !defined(PORTNAME_BSD44_derived) && \
+ !defined(PORTNAME_irix5) && !defined(PORTNAME_bsdi) && !defined(PORTNAME_aix)
+extern int random();
+extern int srandom(unsigned);
+#endif
+
+
+/*-------------------------------------------------------------------------
+ * Check if data is Null
+ */
+bool
+NullValue(Datum value, bool *isNull)
+{
+ if (*isNull) {
+ *isNull = false;
+ return(true);
+ }
+ return(false);
+
+}
+
+/*----------------------------------------------------------------------*
+ * check if data is not Null *
+ *--------------------------------------------------------------------- */
+bool
+NonNullValue(Datum value, bool *isNull)
+{
+ if (*isNull) {
+ *isNull = false;
+ return(false);
+ }
+ return(true);
+
+}
+
+/*
+ * oidrand (oid o, int4 X)-
+ * takes in an oid and a int4 X, and will return 'true'
+ * about 1/X of the time.
+ * Useful for doing random sampling or subsetting.
+ * if X == 0, this will always return true;
+ *
+ * Example use:
+ * select * from TEMP where oidrand(TEMP.oid, 10)
+ * will return about 1/10 of the tuples in TEMP
+ *
+ */
+bool
+oidrand(Oid o, int32 X)
+{
+ bool result;
+
+ if (X == 0) return true;
+
+ result = (random() % X == 0);
+ return result;
+}
+
+/*
+ oidsrand(int32 X) -
+ seeds the random number generator
+ always return true
+*/
+bool
+oidsrand(int32 X)
+{
+ srand(X);
+ return true;
+}
+
+
+
+int32
+userfntest(int i)
+{
+ return (i);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * nabstime.c--
+ * parse almost any absolute date getdate(3) can (& some it can't)
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/nabstime.c,v 1.1.1.1 1996/07/09 06:22:04 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include
+#include
+#include
+#include "postgres.h"
+#include "access/xact.h"
+#include "utils/nabstime.h"
+#include "utils/palloc.h"
+
+#define MAXDATEFIELDS 25
+
+#define ISSPACE(c) ((c) == ' ' || (c) == '\n' || (c) == '\t')
+
+/* this is fast but dirty. note the return's in the middle. */
+#define GOBBLE_NUM(cp, c, x, ip) \
+ (c) = *(cp)++; \
+ if ((c) < '0' || (c) > '9') \
+ return -1; /* missing digit */ \
+ (x) = (c) - '0'; \
+ (c) = *(cp)++; \
+ if ((c) >= '0' && (c) <= '9') { \
+ (x) = 10*(x) + (c) - '0'; \
+ (c) = *(cp)++; \
+ } \
+ if ((c) != ':' && (c) != '\0' && !ISSPACE(c)) \
+ return -1; /* missing colon */ \
+ *(ip) = (x) /* N.B.: no semi-colon here */
+
+#define EPOCH 1970
+#define DAYS_PER_400YRS (time_t)146097
+#define DAYS_PER_4YRS (time_t)1461
+#define SECS_PER_DAY 86400
+#define SECS_PER_HOUR 3600
+#define DIVBY4(n) ((n) >> 2)
+#define YRNUM(c, y) (DIVBY4(DAYS_PER_400YRS*(c)) + DIVBY4(DAYS_PER_4YRS*(y)))
+#define DAYNUM(c,y,mon,d) (YRNUM((c), (y)) + mdays[mon] + (d))
+#define EPOCH_DAYNUM DAYNUM(19, 69, 10, 1) /* really January 1, 1970 */
+#define MIN_DAYNUM -24856 /* December 13, 1901 */
+#define MAX_DAYNUM 24854 /* January 18, 2038 */
+
+/* definitions for squeezing values into "value" */
+#define ABS_SIGNBIT 0200
+#define VALMASK 0177
+#define NEG(n) ((n)|ABS_SIGNBIT)
+#define SIGNEDCHAR(c) ((c)&ABS_SIGNBIT? -((c)&VALMASK): (c))
+#define FROMVAL(tp) (-SIGNEDCHAR((tp)->value) * 10) /* uncompress */
+#define TOVAL(tp, v) ((tp)->value = ((v) < 0? NEG((-(v))/10): (v)/10))
+#define IsLeapYear(yr) ((yr%4) == 0)
+
+char nmdays[] = {
+ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
+};
+/* days since start of year. mdays[0] is March, mdays[11] is February */
+static short mdays[] = {
+ 0, 31, 61, 92, 122, 153, 184, 214, 245, 275, 306, 337
+};
+
+/* exports */
+static int dtok_numparsed;
+
+/*
+ * to keep this table reasonably small, we divide the lexval for TZ and DTZ
+ * entries by 10 and truncate the text field at MAXTOKLEN characters.
+ * the text field is not guaranteed to be NUL-terminated.
+ */
+static datetkn datetktbl[] = {
+/* text token lexval */
+{ "acsst", DTZ, 63}, /* Cent. Australia */
+{ "acst", TZ, 57}, /* Cent. Australia */
+{ "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 */
+{ "am", AMPM, AM},
+{ "apr", MONTH, 4},
+{ "april", MONTH, 4},
+{ "ast", TZ, NEG(24)}, /* Atlantic Std Time (Canada) */
+{ "at", PG_IGNORE, 0}, /* "at" (throwaway) */
+{ "aug", MONTH, 8},
+{ "august", MONTH, 8},
+{ "awsst", DTZ, 54}, /* W. Australia */
+{ "awst", TZ, 48}, /* W. Australia */
+{ "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 */
+{ "dec", MONTH, 12},
+{ "decemb", MONTH, 12},
+{ "dnt", TZ, 6}, /* Dansk Normal Tid */
+{ "dst", PG_IGNORE, 0},
+{ "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 */
+{ "est", TZ, NEG(30)}, /* Eastern Standard Time */
+{ "feb", MONTH, 2},
+{ "februa", MONTH, 2},
+{ "fri", PG_IGNORE, 5},
+{ "friday", PG_IGNORE, 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, West */
+{ "ist", TZ, 12}, /* Israel */
+{ "it", TZ, 22}, /* Iran Time */
+{ "jan", MONTH, 1},
+{ "januar", 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", PG_IGNORE, 1},
+{ "monday", PG_IGNORE, 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},
+{ "novemb", MONTH, 11},
+{ "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},
+{ "octobe", MONTH, 10},
+{ "on", PG_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", PG_IGNORE, 6},
+{ "saturd", PG_IGNORE, 6},
+{ "sep", MONTH, 9},
+{ "sept", MONTH, 9},
+{ "septem", MONTH, 9},
+{ "set", TZ, NEG(6)}, /* Seychelles Time ?? */
+{ "sst", DTZ, 12}, /* Swedish Summer Time */
+{ "sun", PG_IGNORE, 0},
+{ "sunday", PG_IGNORE, 0},
+{ "swt", TZ, 6}, /* Swedish Winter Time */
+{ "thu", PG_IGNORE, 4},
+{ "thur", PG_IGNORE, 4},
+{ "thurs", PG_IGNORE, 4},
+{ "thursd", PG_IGNORE, 4},
+{ "tue", PG_IGNORE, 2},
+{ "tues", PG_IGNORE, 2},
+{ "tuesda", PG_IGNORE, 2},
+{ "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", PG_IGNORE, 3},
+{ "wednes", PG_IGNORE, 3},
+{ "weds", PG_IGNORE, 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 */
+{ "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. */
+};
+
+static unsigned int szdatetktbl = sizeof datetktbl / sizeof datetktbl[0];
+
+/*
+ * parse and convert absolute date in timestr (the normal interface)
+ *
+ * Returns the number of seconds since epoch (January 1 1970 GMT)
+ */
+AbsoluteTime
+nabstimein(char* timestr)
+{
+ int tz = 0;
+ struct tm date;
+
+ if (!timestr)
+ return INVALID_ABSTIME;
+ while (ISSPACE(*timestr))
+ ++timestr;
+
+ if (!strcasecmp(timestr, "epoch"))
+ return EPOCH_ABSTIME;
+ if (!strcasecmp(timestr, "now"))
+ return GetCurrentTransactionStartTime();
+ if (!strcasecmp(timestr, "current"))
+ return CURRENT_ABSTIME;
+ if (!strcasecmp(timestr, "infinity"))
+ return NOEND_ABSTIME;
+ if (!strcasecmp(timestr, "-infinity"))
+ return NOSTART_ABSTIME;
+ if (prsabsdate(timestr, &date, &tz) < 0)
+ return INVALID_ABSTIME;
+ return dateconv(&date, tz);
+}
+
+/*
+ * just parse the absolute date in timestr and get back a broken-out date.
+ */
+int
+prsabsdate(char *timestr,
+ struct tm *tm,
+ int *tzp) /* - minutes west */
+{
+ register int nf;
+ char *fields[MAXDATEFIELDS];
+ static char delims[] = "- \t\n/,";
+
+ nf = split(timestr, fields, MAXDATEFIELDS, delims+1);
+ if (nf > MAXDATEFIELDS)
+ return -1;
+ if (tryabsdate(fields, nf, tm, tzp) < 0) {
+ register char *p = timestr;
+
+ /*
+ * could be a DEC-date; glue it all back together, split it
+ * with dash as a delimiter and try again. Yes, this is a
+ * hack, but so are DEC-dates.
+ */
+ while (--nf > 0) {
+ while (*p++ != '\0')
+ ;
+ p[-1] = ' ';
+ }
+ nf = split(timestr, fields, MAXDATEFIELDS, delims);
+ if (nf > MAXDATEFIELDS)
+ return -1;
+ if (tryabsdate(fields, nf, tm, tzp) < 0)
+ return -1;
+ }
+ return 0;
+}
+
+/*
+ * try to parse pre-split timestr as an absolute date
+ */
+int
+tryabsdate(char *fields[], int nf, struct tm *tm, int *tzp)
+{
+ register int i;
+ register datetkn *tp;
+ register long flg = 0, ty;
+ int mer = HR24, bigval = -1;
+#ifndef USE_POSIX_TIME
+ struct timeb now; /* the old V7-ism */
+
+ (void) ftime(&now);
+ *tzp = now.timezone;
+#else /* USE_POSIX_TIME */
+#if defined(PORTNAME_hpux) || \
+ defined(PORTNAME_aix) || \
+ defined(PORTNAME_irix5) || \
+ defined(WIN32) || \
+ defined(PORTNAME_sparc_solaris)
+ tzset();
+#ifndef WIN32
+ *tzp = timezone / 60; /* this is an X/Open-ism */
+#else
+ *tzp = _timezone / 60; /* this is an X/Open-ism */
+#endif /* WIN32 */
+#else /* PORTNAME_hpux || PORTNAME_aix || PORTNAME_sparc_solaris || PORTNAME_irix5 */
+ time_t now = time((time_t *) NULL);
+ struct tm *tmnow = localtime(&now);
+
+ *tzp = - tmnow->tm_gmtoff / 60; /* tm_gmtoff is Sun/DEC-ism */
+#endif /* PORTNAME_hpux || PORTNAME_aix */
+#endif /* USE_POSIX_TIME */
+
+ tm->tm_mday = tm->tm_mon = tm->tm_year = -1; /* mandatory */
+ tm->tm_hour = tm->tm_min = tm->tm_sec = 0;
+ tm->tm_isdst = -1; /* assume we don't know. */
+ dtok_numparsed = 0;
+
+ for (i = 0; i < nf; i++) {
+ if (fields[i][0] == '\0')
+ continue;
+ tp = datetoktype(fields[i], &bigval);
+ ty = (1L << tp->type) & ~(1L << PG_IGNORE);
+ if (flg&ty)
+ return -1; /* repeated type */
+ flg |= ty;
+ switch (tp->type) {
+ case YEAR:
+ tm->tm_year = bigval;
+ break;
+ case DAY:
+ tm->tm_mday = bigval;
+ break;
+ case MONTH:
+ tm->tm_mon = tp->value;
+ break;
+ case TIME:
+ if (parsetime(fields[i], tm) < 0)
+ return -1;
+ break;
+ case DTZ:
+ tm->tm_isdst++;
+ /* FALLTHROUGH */
+ case TZ:
+ *tzp = FROMVAL(tp);
+ break;
+ case PG_IGNORE:
+ break;
+ case AMPM:
+ mer = tp->value;
+ break;
+ default:
+ return -1; /* bad token type: CANTHAPPEN */
+ }
+ }
+ if (tm->tm_year == -1 || tm->tm_mon == -1 || tm->tm_mday == -1)
+ return -1; /* missing component */
+ if (mer == PM)
+ tm->tm_hour += 12;
+ return 0;
+}
+
+
+/* return -1 on failure */
+int
+parsetime(char *time, struct tm *tm)
+{
+ register char c;
+ register int x;
+
+ tm->tm_sec = 0;
+ GOBBLE_NUM(time, c, x, &tm->tm_hour);
+ if (c != ':')
+ return -1; /* only hour; too short */
+ GOBBLE_NUM(time, c, x, &tm->tm_min);
+ if (c != ':')
+ return 0; /* no seconds; okay */
+ GOBBLE_NUM(time, c, x, &tm->tm_sec);
+ /* this may be considered too strict. garbage at end of time? */
+ return (c == '\0' || ISSPACE(c)? 0: -1);
+}
+
+
+/*
+ * split - divide a string into fields, like awk split()
+ */
+int /* number of fields, including overflow */
+split(char *string,
+ char *fields[], /* list is not NULL-terminated */
+ int nfields, /* number of entries available in fields[] */
+ char *sep) /* "" white, "c" single char, "ab" [ab]+ */
+{
+ register char *p = string;
+ register char c; /* latest character */
+ register char sepc = sep[0];
+ register char sepc2;
+ register int fn;
+ register char **fp = fields;
+ register char *sepp;
+ register int trimtrail;
+
+ /* white space */
+ if (sepc == '\0') {
+ while ((c = *p++) == ' ' || c == '\t')
+ continue;
+ p--;
+ trimtrail = 1;
+ sep = " \t"; /* note, code below knows this is 2 long */
+ sepc = ' ';
+ } else
+ trimtrail = 0;
+ sepc2 = sep[1]; /* now we can safely pick this up */
+
+ /* catch empties */
+ if (*p == '\0')
+ return(0);
+
+ /* single separator */
+ if (sepc2 == '\0') {
+ fn = nfields;
+ for (;;) {
+ *fp++ = p;
+ fn--;
+ if (fn == 0)
+ break;
+ while ((c = *p++) != sepc)
+ if (c == '\0')
+ return(nfields - fn);
+ *(p-1) = '\0';
+ }
+ /* we have overflowed the fields vector -- just count them */
+ fn = nfields;
+ for (;;) {
+ while ((c = *p++) != sepc)
+ if (c == '\0')
+ return(fn);
+ fn++;
+ }
+ /* not reached */
+ }
+
+ /* two separators */
+ if (sep[2] == '\0') {
+ fn = nfields;
+ for (;;) {
+ *fp++ = p;
+ fn--;
+ while ((c = *p++) != sepc && c != sepc2)
+ if (c == '\0') {
+ if (trimtrail && **(fp-1) == '\0')
+ fn++;
+ return(nfields - fn);
+ }
+ if (fn == 0)
+ break;
+ *(p-1) = '\0';
+ while ((c = *p++) == sepc || c == sepc2)
+ continue;
+ p--;
+ }
+ /* we have overflowed the fields vector -- just count them */
+ fn = nfields;
+ while (c != '\0') {
+ while ((c = *p++) == sepc || c == sepc2)
+ continue;
+ p--;
+ fn++;
+ while ((c = *p++) != '\0' && c != sepc && c != sepc2)
+ continue;
+ }
+ /* might have to trim trailing white space */
+ if (trimtrail) {
+ p--;
+ while ((c = *--p) == sepc || c == sepc2)
+ continue;
+ p++;
+ if (*p != '\0') {
+ if (fn == nfields+1)
+ *p = '\0';
+ fn--;
+ }
+ }
+ return(fn);
+ }
+
+ /* n separators */
+ fn = 0;
+ for (;;) {
+ if (fn < nfields)
+ *fp++ = p;
+ fn++;
+ for (;;) {
+ c = *p++;
+ if (c == '\0')
+ return(fn);
+ sepp = sep;
+ while ((sepc = *sepp++) != '\0' && sepc != c)
+ continue;
+ if (sepc != '\0') /* it was a separator */
+ break;
+ }
+ if (fn < nfields)
+ *(p-1) = '\0';
+ for (;;) {
+ c = *p++;
+ sepp = sep;
+ while ((sepc = *sepp++) != '\0' && sepc != c)
+ continue;
+ if (sepc == '\0') /* it wasn't a separator */
+ break;
+ }
+ p--;
+ }
+
+ /* not reached */
+}
+
+/*
+ * Given an AbsoluteTime return the English text version of the date
+ */
+char *
+nabstimeout(AbsoluteTime time)
+{
+ /*
+ * Fri Jan 28 23:05:29 1994 PST
+ * 0 1 2
+ * 12345678901234567890123456789
+ *
+ * we allocate some extra -- timezones are usually 3 characters but
+ * this is not in the POSIX standard...
+ */
+ char buf[40];
+ char* result;
+
+ switch (time) {
+ case EPOCH_ABSTIME: (void) strcpy(buf, "epoch"); break;
+ case INVALID_ABSTIME: (void) strcpy(buf, "Invalid Abstime"); break;
+ case CURRENT_ABSTIME: (void) strcpy(buf, "current"); break;
+ case NOEND_ABSTIME: (void) strcpy(buf, "infinity"); break;
+ case NOSTART_ABSTIME: (void) strcpy(buf, "-infinity"); break;
+ default:
+ /* hack -- localtime happens to work for negative times */
+ (void) strftime(buf, sizeof(buf), "%a %b %d %H:%M:%S %Y %Z",
+ localtime((time_t *) &time));
+ break;
+ }
+ result = (char*)palloc(strlen(buf) + 1);
+ strcpy(result, buf);
+ return result;
+}
+
+/* turn a (struct tm) and a few variables into a time_t, with range checking */
+AbsoluteTime
+dateconv(register struct tm *tm, int zone)
+{
+ tm->tm_wday = tm->tm_yday = 0;
+
+ /* validate, before going out of range on some members */
+ if (tm->tm_year < 0 || tm->tm_mon < 1 || tm->tm_mon > 12 ||
+ tm->tm_mday < 1 || tm->tm_hour < 0 || tm->tm_hour >= 24 ||
+ tm->tm_min < 0 || tm->tm_min > 59 ||
+ tm->tm_sec < 0 || tm->tm_sec > 59)
+ return -1;
+
+ /*
+ * zone should really be -zone, and tz should be set to tp->value, not
+ * -tp->value. Or the table could be fixed.
+ */
+ tm->tm_min += zone; /* mktime lets it be out of range */
+
+ /* convert to seconds */
+ return qmktime(tm);
+}
+
+
+/*
+ * near-ANSI qmktime suitable for use by dateconv; not necessarily as paranoid
+ * as ANSI requires, and it may not canonicalise the struct tm. Ignores tm_wday
+ * and tm_yday.
+ */
+time_t
+qmktime(struct tm *tp)
+{
+ register int mon = tp->tm_mon;
+ register int day = tp->tm_mday, year = tp->tm_year;
+ register time_t daynum;
+ time_t secondnum;
+ register int century;
+
+ /* If it was a 2 digit year */
+ if (year < 100)
+ year += 1900;
+
+ /*
+ * validate day against days-per-month table, with leap-year
+ * correction
+ */
+ if (day > nmdays[mon])
+ if (mon != 2 || year % 4 == 0 &&
+ (year % 100 != 0 || year % 400 == 0) && day > 29)
+ return -1; /* day too large for month */
+
+ /* split year into century and year-of-century */
+ century = year / 100;
+ year %= 100;
+ /*
+ * We calculate the day number exactly, assuming the calendar has
+ * always had the current leap year rules. (The leap year rules are
+ * to compensate for the fact that the Earth's revolution around the
+ * Sun takes 365.2425 days). We first need to rotate months so March
+ * is 0, since we want the last month to have the reduced number of
+ * days.
+ */
+ if (mon > 2)
+ mon -= 3;
+ else {
+ mon += 9;
+ if (year == 0) {
+ century--;
+ year = 99;
+ } else
+ --year;
+ }
+ daynum = -EPOCH_DAYNUM + DAYNUM(century, year, mon, day);
+
+ /* check for time out of range */
+ if (daynum < MIN_DAYNUM || daynum > MAX_DAYNUM)
+ return INVALID_ABSTIME;
+
+ /* convert to seconds */
+ secondnum =
+ tp->tm_sec + (tp->tm_min +(daynum*24 + tp->tm_hour)*60)*60;
+
+ /* check for overflow */
+ if ((daynum == MAX_DAYNUM && secondnum < 0) ||
+ (daynum == MIN_DAYNUM && secondnum > 0))
+ return INVALID_ABSTIME;
+
+ /* check for "current", "infinity", "-infinity" */
+ if (!AbsoluteTimeIsReal(secondnum))
+ return INVALID_ABSTIME;
+
+ /* daylight correction */
+ if (tp->tm_isdst < 0) /* unknown; find out */
+ {
+ struct tm *result;
+
+ /* NT returns NULL for any time before 1/1/70 */
+ result = localtime(&secondnum);
+ if (result == NULL)
+ return INVALID_ABSTIME;
+ else
+ tp->tm_isdst = result->tm_isdst;
+ }
+ if (tp->tm_isdst > 0)
+ secondnum -= 60*60;
+
+ return secondnum;
+}
+
+datetkn *
+datetoktype(char *s, int *bigvalp)
+{
+ register char *cp = s;
+ register char c = *cp;
+ static datetkn t;
+ register datetkn *tp = &t;
+
+ if (isascii(c) && isdigit(c)) {
+ register int len = strlen(cp);
+
+ if (len > 3 && (cp[1] == ':' || cp[2] == ':'))
+ tp->type = TIME;
+ else {
+ if (bigvalp != NULL)
+ /* won't fit in tp->value */
+ *bigvalp = atoi(cp);
+ if (len == 4)
+ tp->type = YEAR;
+ else if (++dtok_numparsed == 1)
+ tp->type = DAY;
+ else
+ tp->type = YEAR;
+ }
+ } else if (c == '-' || c == '+') {
+ register int val = atoi(cp + 1);
+ register int hr = val / 100;
+ register int min = val % 100;
+
+ val = hr*60 + min;
+ if (c == '-')
+ val = -val;
+ tp->type = TZ;
+ TOVAL(tp, val);
+ } else {
+ char lowtoken[TOKMAXLEN+1];
+ register char *ltp = lowtoken, *endltp = lowtoken+TOKMAXLEN;
+
+ /* copy to lowtoken to avoid modifying s */
+ while ((c = *cp++) != '\0' && ltp < endltp)
+ *ltp++ = (isascii(c) && isupper(c)? tolower(c): c);
+ *ltp = '\0';
+ tp = datebsearch(lowtoken, datetktbl, szdatetktbl);
+ if (tp == NULL) {
+ tp = &t;
+ tp->type = PG_IGNORE;
+ }
+ }
+ return tp;
+}
+
+/*
+ * Binary search -- from Knuth (6.2.1) Algorithm B. Special case like this
+ * is WAY faster than the generic bsearch().
+ */
+datetkn *
+datebsearch(char *key, datetkn *base, unsigned int nel)
+{
+ register datetkn *last = base + nel - 1, *position;
+ register int result;
+
+ while (last >= base) {
+ position = base + ((last - base) >> 1);
+ result = key[0] - position->token[0];
+ if (result == 0) {
+ result = strncmp(key, position->token, TOKMAXLEN);
+ if (result == 0)
+ return position;
+ }
+ if (result < 0)
+ last = position - 1;
+ else
+ base = position + 1;
+ }
+ return 0;
+}
+
+
+/*
+ * AbsoluteTimeIsBefore -- true iff time1 is before time2.
+ */
+
+bool
+AbsoluteTimeIsBefore(AbsoluteTime time1, AbsoluteTime time2)
+{
+ AbsoluteTime tm = GetCurrentTransactionStartTime();
+
+ Assert(AbsoluteTimeIsValid(time1));
+ Assert(AbsoluteTimeIsValid(time2));
+
+ if ((time1 == CURRENT_ABSTIME) || (time2 == CURRENT_ABSTIME))
+ return false;
+ if (time1 == CURRENT_ABSTIME)
+ return (tm < time2);
+ if (time2 == CURRENT_ABSTIME)
+ return (time1 < tm);
+
+ return (time1 < time2);
+}
+
+bool
+AbsoluteTimeIsAfter(AbsoluteTime time1, AbsoluteTime time2)
+{
+ AbsoluteTime tm = GetCurrentTransactionStartTime();
+
+ Assert(AbsoluteTimeIsValid(time1));
+ Assert(AbsoluteTimeIsValid(time2));
+
+ if ((time1 == CURRENT_ABSTIME) || (time2 == CURRENT_ABSTIME))
+ return false;
+ if (time1 == CURRENT_ABSTIME)
+ return (tm > time2);
+ if (time2 == CURRENT_ABSTIME)
+ return (time1 > tm);
+
+ return (time1 > time2);
+}
+
+
+/*
+ * abstimeeq - returns 1, iff arguments are equal
+ * abstimene - returns 1, iff arguments are not equal
+ * abstimelt - returns 1, iff t1 less than t2
+ * abstimegt - returns 1, iff t1 greater than t2
+ * abstimele - returns 1, iff t1 less than or equal to t2
+ * abstimege - returns 1, iff t1 greater than or equal to t2
+ *
+ */
+int32
+abstimeeq(AbsoluteTime t1, AbsoluteTime t2)
+{
+ if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
+ return 0;
+ if (t1 == CURRENT_ABSTIME)
+ t1 = GetCurrentTransactionStartTime();
+ if (t2 == CURRENT_ABSTIME)
+ t2 = GetCurrentTransactionStartTime();
+
+ return(t1 == t2);
+}
+
+int32
+abstimene(AbsoluteTime t1, AbsoluteTime t2)
+{
+ if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
+ return 0;
+ if (t1 == CURRENT_ABSTIME)
+ t1 = GetCurrentTransactionStartTime();
+ if (t2 == CURRENT_ABSTIME)
+ t2 = GetCurrentTransactionStartTime();
+
+ return(t1 != t2);
+}
+
+int32
+abstimelt(AbsoluteTime t1, AbsoluteTime t2)
+{
+ if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
+ return 0;
+ if (t1 == CURRENT_ABSTIME)
+ t1 = GetCurrentTransactionStartTime();
+ if (t2 == CURRENT_ABSTIME)
+ t2 = GetCurrentTransactionStartTime();
+
+ return(t1 < t2);
+}
+
+int32
+abstimegt(AbsoluteTime t1, AbsoluteTime t2)
+{
+ if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
+ return 0;
+ if (t1 == CURRENT_ABSTIME)
+ t1 = GetCurrentTransactionStartTime();
+ if (t2 == CURRENT_ABSTIME)
+ t2 = GetCurrentTransactionStartTime();
+
+ return(t1 > t2);
+}
+
+int32
+abstimele(AbsoluteTime t1, AbsoluteTime t2)
+{
+ if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
+ return 0;
+ if (t1 == CURRENT_ABSTIME)
+ t1 = GetCurrentTransactionStartTime();
+ if (t2 == CURRENT_ABSTIME)
+ t2 = GetCurrentTransactionStartTime();
+
+ return(t1 <= t2);
+}
+
+int32
+abstimege(AbsoluteTime t1, AbsoluteTime t2)
+{
+ if (t1 == INVALID_ABSTIME || t2 == INVALID_ABSTIME)
+ return 0;
+ if (t1 == CURRENT_ABSTIME)
+ t1 = GetCurrentTransactionStartTime();
+ if (t2 == CURRENT_ABSTIME)
+ t2 = GetCurrentTransactionStartTime();
+
+ return(t1 >= t2);
+}
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * name.c--
+ * Functions for the built-in type "name".
+ * name replaces char16 and is carefully implemented so that it
+ * is a string of length NAMEDATALEN. DO NOT use hard-coded constants anywhere
+ * always use NAMEDATALEN as the symbolic constant! - jolly 8/21/95
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/name.c,v 1.1.1.1 1996/07/09 06:22:04 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "postgres.h"
+#include "utils/builtins.h" /* where the declarations go */
+#include "utils/palloc.h" /* where the declarations go */
+
+/*****************************************************************************
+ * USER I/O ROUTINES (none) *
+ *****************************************************************************/
+
+
+/*
+ * namein - converts "..." to internal representation
+ *
+ * Note:
+ * Currently if strlen(s) < NAMEDATALEN, the extra chars are nulls
+ */
+NameData *namein(char *s)
+{
+ NameData *result;
+
+ if (s == NULL)
+ return(NULL);
+ result = (NameData*) palloc(NAMEDATALEN);
+ /* always keep it null-padded */
+ memset(result->data, 0, NAMEDATALEN);
+ (void) strncpy(result->data, s, NAMEDATALEN-1);
+ return(result);
+}
+
+/*
+ * nameout - converts internal reprsentation to "..."
+ */
+char *nameout(NameData *s)
+{
+ if (s == NULL)
+ return "-";
+ else
+ return pstrdup(s->data);
+}
+
+
+/*****************************************************************************
+ * PUBLIC ROUTINES *
+ *****************************************************************************/
+
+/*
+ * nameeq - returns 1 iff arguments are equal
+ * namene - returns 1 iff arguments are not equal
+ *
+ * BUGS:
+ * Assumes that "xy\0\0a" should be equal to "xy\0b".
+ * If not, can do the comparison backwards for efficiency.
+ *
+ * namelt - returns 1 iff a < b
+ * namele - returns 1 iff a <= b
+ * namegt - returns 1 iff a < b
+ * namege - returns 1 iff a <= b
+ *
+ */
+int32 nameeq(NameData *arg1, NameData *arg2)
+{
+ if (!arg1 || !arg2)
+ return 0;
+ else
+ return (strncmp(arg1->data, arg2->data, NAMEDATALEN) == 0);
+}
+
+int32 namene(NameData *arg1, NameData *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ return(strncmp(arg1->data, arg2->data, NAMEDATALEN) != 0);
+}
+
+int32 namelt(NameData *arg1, NameData *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ return((int32) (strncmp(arg1->data, arg2->data, NAMEDATALEN) < 0));
+}
+
+int32 namele(NameData *arg1, NameData *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ return((int32) (strncmp(arg1->data, arg2->data, NAMEDATALEN) <= 0));
+}
+
+int32 namegt(NameData *arg1, NameData *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+
+ return((int32) (strncmp(arg1->data, arg2->data, NAMEDATALEN) > 0));
+}
+
+int32 namege(NameData *arg1, NameData *arg2)
+{
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+
+ return((int32) (strncmp(arg1->data, arg2->data, NAMEDATALEN) >= 0));
+}
+
+
+/* (see char.c for comparison/operation routines) */
+
+int namecpy(Name n1, Name n2)
+{
+ if (!n1 || !n2)
+ return(-1);
+ (void) strncpy(n1->data, n2->data, NAMEDATALEN);
+ return(0);
+}
+
+int namecat(Name n1, Name n2)
+{
+ return(namestrcat(n1, n2->data)); /* n2 can't be any longer than n1 */
+}
+
+int namecmp(Name n1, Name n2)
+{
+ return(strncmp(n1->data, n2->data, NAMEDATALEN));
+}
+
+int
+namestrcpy(Name name, char *str)
+{
+ if (!name || !str)
+ return(-1);
+ memset(name->data, 0, sizeof(NameData));
+ (void) strncpy(name->data, str, NAMEDATALEN);
+ return(0);
+}
+
+int namestrcat(Name name, char *str)
+{
+ int i;
+ char *p, *q;
+
+ if (!name || !str)
+ return(-1);
+ for (i = 0, p = name->data; i < NAMEDATALEN && *p; ++i, ++p)
+ ;
+ for (q = str; i < NAMEDATALEN; ++i, ++p, ++q) {
+ *p = *q;
+ if (!*q)
+ break;
+ }
+ return(0);
+}
+
+int
+namestrcmp(Name name, char *str)
+{
+ if (!name && !str)
+ return(0);
+ if (!name)
+ return(-1); /* NULL < anything */
+ if (!str)
+ return(1); /* NULL < anything */
+ return(strncmp(name->data, str, NAMEDATALEN));
+}
+
+/*****************************************************************************
+ * PRIVATE ROUTINES *
+ *****************************************************************************/
+
+uint32
+NameComputeLength(Name name)
+{
+ char *charP;
+ int length;
+
+ for (length = 0, charP = name->data;
+ length < NAMEDATALEN && *charP != '\0';
+ length++, charP++) {
+ ;
+ }
+ return (uint32)length;
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * not_in.c--
+ * Executes the "not_in" operator for any data type
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/not_in.c,v 1.1.1.1 1996/07/09 06:22:05 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ *
+ * XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+ * X HACK WARNING!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! X
+ * XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+ *
+ * This code is the OLD not-in code that is HACKED
+ * into place until operators that can have arguments as
+ * columns are ******REALLY****** implemented!!!!!!!!!!!
+ *
+ */
+#include
+#include
+#include "postgres.h"
+#include "access/heapam.h"
+#include "access/htup.h"
+#include "access/relscan.h"
+#include "utils/rel.h"
+#include "utils/elog.h"
+#include "utils/builtins.h" /* where function decls go */
+
+/* ----------------------------------------------------------------
+ *
+ * ----------------------------------------------------------------
+ */
+bool
+int4notin(int16 not_in_arg, char *relation_and_attr)
+{
+ Relation relation_to_scan;
+ int left_side_argument, integer_value;
+ HeapTuple current_tuple;
+ HeapScanDesc scan_descriptor;
+ bool dummy, retval;
+ int attrid;
+ char *relation, *attribute;
+ char my_copy[32];
+ Datum value;
+ NameData relNameData;
+ ScanKeyData skeyData;
+
+ strcpy(my_copy, relation_and_attr);
+
+ relation = (char *) strtok(my_copy, ".");
+ attribute = (char *) strtok(NULL, ".");
+
+
+ /* fetch tuple OID */
+
+ left_side_argument = not_in_arg;
+
+ /* Open the relation and get a relation descriptor */
+
+ namestrcpy(&relNameData,relation);
+ relation_to_scan = heap_openr(relNameData.data);
+ attrid = my_varattno(relation_to_scan, attribute);
+
+ /* the last argument should be a ScanKey, not an integer! - jolly*/
+ /* it looks like the arguments are out of order, too */
+ /* but skeyData is never initialized! does this work?? - ay 2/95 */
+ scan_descriptor = heap_beginscan(relation_to_scan, false, NULL, 0,
+ &skeyData);
+
+ retval = true;
+
+ /* do a scan of the relation, and do the check */
+ for (current_tuple = heap_getnext(scan_descriptor, 0, NULL);
+ current_tuple != NULL && retval;
+ current_tuple = heap_getnext(scan_descriptor, 0, NULL))
+ {
+ value = PointerGetDatum(heap_getattr(current_tuple,
+ InvalidBuffer,
+ (AttrNumber) attrid,
+ RelationGetTupleDescriptor(relation_to_scan),
+ &dummy));
+
+ integer_value = DatumGetInt16(value);
+ if (left_side_argument == integer_value)
+ {
+ retval = false;
+ }
+ }
+
+ /* close the relation */
+ heap_close(relation_to_scan);
+ return(retval);
+}
+
+bool oidnotin(Oid the_oid, char *compare)
+{
+ if (the_oid == InvalidOid)
+ return false;
+ return(int4notin(the_oid, compare));
+}
+
+/*
+ * XXX
+ * If varattno (in parser/catalog_utils.h) ever is added to
+ * cinterface.a, this routine should go away
+ */
+int my_varattno(Relation rd, char *a)
+{
+ int i;
+
+ for (i = 0; i < rd->rd_rel->relnatts; i++) {
+ if (!namestrcmp(&rd->rd_att->attrs[i]->attname, a)) {
+ return(i+1);
+ }
+ }
+ return(-1);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * numutils.c--
+ * utility functions for I/O of built-in numeric types.
+ *
+ * integer: itoa, ltoa
+ * floating point: ftoa, atof1
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/numutils.c,v 1.1.1.1 1996/07/09 06:22:05 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* for sprintf() */
+#include
+#include
+#include "postgres.h"
+#include "utils/builtins.h" /* where the declarations go */
+#include "utils/elog.h"
+
+int32
+pg_atoi(char *s, int size, int c)
+{
+ long l;
+ char *badp = (char *) NULL;
+
+ Assert(s);
+
+ errno = 0;
+ l = strtol(s, &badp, 10);
+ if (errno) /* strtol must set ERANGE */
+ elog(WARN, "pg_atoi: error reading \"%s\": %m", s);
+ if (badp && *badp && (*badp != c))
+ elog(WARN, "pg_atoi: error in \"%s\": can\'t parse \"%s\"", s, badp);
+
+ switch (size) {
+ case sizeof(int32):
+#ifdef HAS_LONG_LONG
+ /* won't get ERANGE on these with 64-bit longs... */
+ if (l < -0x80000000L) {
+ errno = ERANGE;
+ elog(WARN, "pg_atoi: error reading \"%s\": %m", s);
+ }
+ if (l > 0x7fffffffL) {
+ errno = ERANGE;
+ elog(WARN, "pg_atoi: error reading \"%s\": %m", s);
+ }
+#endif /* HAS_LONG_LONG */
+ break;
+ case sizeof(int16):
+ if (l < -0x8000) {
+ errno = ERANGE;
+ elog(WARN, "pg_atoi: error reading \"%s\": %m", s);
+ }
+ if (l > 0x7fff) {
+ errno = ERANGE;
+ elog(WARN, "pg_atoi: error reading \"%s\": %m", s);
+ }
+ break;
+ case sizeof(int8):
+ if (l < -0x80) {
+ errno = ERANGE;
+ elog(WARN, "pg_atoi: error reading \"%s\": %m", s);
+ }
+ if (l > 0x7f) {
+ errno = ERANGE;
+ elog(WARN, "pg_atoi: error reading \"%s\": %m", s);
+ }
+ break;
+ default:
+ elog(WARN, "pg_atoi: invalid result size: %d", size);
+ }
+ return((int32) l);
+}
+
+/*
+ * itoa - converts a short int to its string represention
+ *
+ * Note:
+ * previously based on ~ingres/source/gutil/atoi.c
+ * now uses vendor's sprintf conversion
+ */
+void
+itoa(int i, char *a)
+{
+ sprintf(a, "%hd", (short)i);
+}
+
+/*
+ * ltoa - converts a long int to its string represention
+ *
+ * Note:
+ * previously based on ~ingres/source/gutil/atoi.c
+ * now uses vendor's sprintf conversion
+ */
+void
+ltoa(int32 l, char *a)
+{
+ sprintf(a, "%d", l);
+}
+
+/*
+ ** ftoa - FLOATING POINT TO ASCII CONVERSION
+ **
+ ** CODE derived from ingres, ~ingres/source/gutil/ftoa.c
+ **
+ ** 'Value' is converted to an ascii character string and stored
+ ** into 'ascii'. Ascii should have room for at least 'width' + 1
+ ** characters. 'Width' is the width of the output field (max).
+ ** 'Prec' is the number of characters to put after the decimal
+ ** point. The format of the output string is controlled by
+ ** 'format'.
+ **
+ ** 'Format' can be:
+ ** e or E: "E" format output
+ ** f or F: "F" format output
+ ** g or G: "F" format output if it will fit, otherwise
+ ** use "E" format.
+ ** n or N: same as G, but decimal points will not always
+ ** be aligned.
+ **
+ ** If 'format' is upper case, the "E" comes out in upper case;
+ ** otherwise it comes out in lower case.
+ **
+ ** When the field width is not big enough, it fills the field with
+ ** stars ("*****") and returns zero. Normal return is the width
+ ** of the output field (sometimes shorter than 'width').
+ */
+int
+ftoa(double value, char *ascii, int width, int prec1, char format)
+{
+#if defined(PORTNAME_BSD44_derived) || defined(PORTNAME_bsdi)
+ char out[256];
+ char fmt[256];
+ int ret;
+
+ (void) sprintf(fmt, "%%%d.%d%c", width, prec1, format);
+ (void) sprintf(out, fmt, value);
+ if ((ret = strlen(out)) > width) {
+ memset(ascii, '*', width - 2);
+ ascii[width] = 0;
+ return(0);
+ }
+ (void) strcpy(ascii, out);
+ return(ret);
+#else
+ auto int expon;
+ auto int sign;
+ register int avail;
+ register char *a;
+ register char *p;
+ char mode;
+ int lowercase;
+ int prec;
+/* extern char *ecvt(), *fcvt();*/
+
+ prec = prec1;
+ mode = format;
+ lowercase = 'a' - 'A';
+ if (mode >= 'a')
+ mode -= 'a' - 'A';
+ else
+ lowercase = 0;
+
+ if (mode != 'E') {
+ /* try 'F' style output */
+ p = fcvt(value, prec, &expon, &sign);
+ avail = width;
+ a = ascii;
+
+ /* output sign */
+ if (sign) {
+ avail--;
+ *a++ = '-';
+ }
+
+ /* output '0' before the decimal point */
+ if (expon <= 0) {
+ *a++ = '0';
+ avail--;
+ }
+
+ /* compute space length left after dec pt and fraction */
+ avail -= prec + 1;
+ if (mode == 'G')
+ avail -= 4;
+
+ if (avail >= expon) {
+
+ /* it fits. output */
+ while (expon > 0) {
+ /* output left of dp */
+ expon--;
+ if (*p) {
+ *a++ = *p++;
+ } else
+ *a++ = '0';
+ }
+
+ /* output fraction (right of dec pt) */
+ avail = expon;
+ goto frac_out;
+ }
+ /* won't fit; let's hope for G format */
+ }
+
+ if (mode != 'F') {
+ /* try to do E style output */
+ p = ecvt(value, prec + 1, &expon, &sign);
+ avail = width - 5;
+ a = ascii;
+
+ /* output the sign */
+ if (sign) {
+ *a++ = '-';
+ avail--;
+ }
+ }
+
+ /* check for field too small */
+ if (mode == 'F' || avail < prec) {
+ /* sorry joker, you lose */
+ a = ascii;
+ for (avail = width; avail > 0; avail--)
+ *a++ = '*';
+ *a = 0;
+ return (0);
+ }
+
+ /* it fits; output the number */
+ mode = 'E';
+
+ /* output the LHS single digit */
+ *a++ = *p++;
+ expon--;
+
+ /* output the rhs */
+ avail = 1;
+
+ frac_out:
+ *a++ = '.';
+ while (prec > 0) {
+ prec--;
+ if (avail < 0) {
+ avail++;
+ *a++ = '0';
+ } else {
+ if (*p)
+ *a++ = *p++;
+ else
+ *a++ = '0';
+ }
+ }
+
+ /* output the exponent */
+ if (mode == 'E') {
+ *a++ = 'E' + lowercase;
+ if (expon < 0) {
+ *a++ = '-';
+ expon = -expon;
+ } else
+ *a++ = '+';
+ *a++ = (expon / 10) % 10 + '0';
+ *a++ = expon % 10 + '0';
+ }
+
+ /* output spaces on the end in G format */
+ if (mode == 'G') {
+ *a++ = ' ';
+ *a++ = ' ';
+ *a++ = ' ';
+ *a++ = ' ';
+ }
+
+ /* finally, we can return */
+ *a = 0;
+ avail = a - ascii;
+ return (avail);
+#endif /* !PORTNAME_BSD44_derived */
+}
+
+/*
+ ** atof1 - ASCII TO FLOATING CONVERSION
+ **
+ ** CODE derived from ~ingres/source/gutil/atof.c
+ **
+ ** Converts the string 'str' to floating point and stores the
+ ** result into the cell pointed to by 'val'.
+ **
+ ** The syntax which it accepts is pretty much what you would
+ ** expect. Basically, it is:
+ ** {} [+|-] {} {} [.{digit}] {} []
+ ** where is "e" or "E" followed by an integer, is a
+ ** space character, is zero through nine, [] is zero or
+ ** one, and {} is zero or more.
+ **
+ ** Parameters:
+ ** str -- string to convert.
+ ** val -- pointer to place to put the result (which
+ ** must be type double).
+ **
+ ** Returns:
+ ** zero -- ok.
+ ** -1 -- syntax error.
+ ** +1 -- overflow (not implemented).
+ **
+ ** Side Effects:
+ ** clobbers *val.
+ */
+int
+atof1(char *str, double *val)
+{
+ register char *p;
+ double v;
+ double fact;
+ int minus;
+ register char c;
+ int expon;
+ register int gotmant;
+
+ v = 0.0;
+ p = str;
+ minus = 0;
+
+ /* skip leading blanks */
+ while ((c = *p) != '\0') {
+ if (c != ' ')
+ break;
+ p++;
+ }
+
+ /* handle possible sign */
+ switch (c) {
+ case '-':
+ minus++;
+
+ case '+':
+ p++;
+ }
+
+ /* skip blanks after sign */
+ while ((c = *p) != '\0') {
+ if (c != ' ')
+ break;
+ p++;
+ }
+
+ /* start collecting the number to the decimal point */
+ gotmant = 0;
+ for (;;) {
+ c = *p;
+ if (c < '0' || c > '9')
+ break;
+ v = v * 10.0 + (c - '0');
+ gotmant++;
+ p++;
+ }
+
+ /* check for fractional part */
+ if (c == '.') {
+ fact = 1.0;
+ for (;;) {
+ c = *++p;
+ if (c < '0' || c > '9')
+ break;
+ fact *= 0.1;
+ v += (c - '0') * fact;
+ gotmant++;
+ }
+ }
+
+ /* skip blanks before possible exponent */
+ while ((c = *p) != '\0') {
+ if (c != ' ')
+ break;
+ p++;
+ }
+
+ /* test for exponent */
+ if (c == 'e' || c == 'E') {
+ p++;
+ expon = pg_atoi(p, sizeof(expon), '\0');
+ if (!gotmant)
+ v = 1.0;
+ fact = expon;
+ v *= pow(10.0, fact);
+ } else {
+ /* if no exponent, then nothing */
+ if (c != 0)
+ return (-1);
+ }
+
+ /* store the result and exit */
+ if (minus)
+ v = -v;
+ *val = v;
+ return (0);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * oid.c--
+ * Functions for the built-in type Oid.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/oid.c,v 1.1.1.1 1996/07/09 06:22:05 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+#include "utils/palloc.h"
+#include "utils/builtins.h" /* where function declarations go */
+#include "utils/elog.h"
+
+/*****************************************************************************
+ * USER I/O ROUTINES *
+ *****************************************************************************/
+
+/*
+ * oid8in - converts "num num ..." to internal form
+ *
+ * Note:
+ * Fills any nonexistent digits with NULL oids.
+ */
+Oid *oid8in(char *oidString)
+{
+ register Oid (*result)[];
+ int nums;
+
+ if (oidString == NULL)
+ return(NULL);
+ result = (Oid (*)[]) palloc(sizeof(Oid [8]));
+ if ((nums = sscanf(oidString, "%d%d%d%d%d%d%d%d",
+ *result,
+ *result + 1,
+ *result + 2,
+ *result + 3,
+ *result + 4,
+ *result + 5,
+ *result + 6,
+ *result + 7)) != 8) {
+ do
+ (*result)[nums++] = 0;
+ while (nums < 8);
+ }
+ return((Oid *) result);
+}
+
+/*
+ * oid8out - converts internal form to "num num ..."
+ */
+char *oid8out(Oid (*oidArray)[])
+{
+ register int num;
+ register Oid *sp;
+ register char *rp;
+ char *result;
+
+ if (oidArray == NULL) {
+ result = (char *) palloc(2);
+ result[0] = '-';
+ result[1] = '\0';
+ return(result);
+ }
+
+ /* assumes sign, 10 digits, ' ' */
+ rp = result = (char *) palloc(8 * 12);
+ sp = *oidArray;
+ for (num = 8; num != 0; num--) {
+ ltoa(*sp++, rp);
+ while (*++rp != '\0')
+ ;
+ *rp++ = ' ';
+ }
+ *--rp = '\0';
+ return(result);
+}
+
+Oid oidin(char *s)
+{
+ extern int32 int4in();
+
+ return(int4in(s));
+}
+
+char *oidout(Oid o)
+{
+ extern char *int4out();
+
+ return(int4out(o));
+}
+
+/*****************************************************************************
+ * PUBLIC ROUTINES *
+ *****************************************************************************/
+
+int32 oideq(Oid arg1, Oid arg2)
+{
+ return(arg1 == arg2);
+}
+
+int32 oidne(Oid arg1, Oid arg2)
+{
+ return(arg1 != arg2);
+}
+
+int32 oid8eq(Oid arg1[], Oid arg2[])
+{
+ return (int32)(memcmp(arg1, arg2, 8 * sizeof(Oid)) == 0);
+}
+
+bool oideqint4(Oid arg1, int32 arg2)
+{
+/* oid is unsigned, but int4 is signed */
+ return (arg2 >= 0 && arg1 == arg2);
+}
+
+bool int4eqoid(int32 arg1, Oid arg2)
+{
+/* oid is unsigned, but int4 is signed */
+ return (arg1 >= 0 && arg1 == arg2);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * oidint2.c--
+ * Functions for the built-in type "oidint2".
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/oidint2.c,v 1.1.1.1 1996/07/09 06:22:05 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "postgres.h"
+#include "utils/palloc.h"
+#include "utils/builtins.h" /* for pg_atoi() */
+#include "utils/oidcompos.h" /* where function declarations go */
+
+
+OidInt2
+oidint2in(char *o)
+{
+ OidInt2 oi;
+ char *p;
+
+ oi = (OidInt2) palloc(sizeof(OidInt2Data));
+
+ for (p = o; *p != '\0' && *p != '/'; p++)
+ continue;
+
+ oi->oi_oid = (Oid) pg_atoi(o, sizeof(Oid), '/');
+ if (*p == '\0') {
+ oi->oi_int2 = 0;
+ } else {
+ oi->oi_int2 = (int16) pg_atoi(++p, sizeof(int2), '\0');
+ }
+
+ return (oi);
+}
+
+char *
+oidint2out(OidInt2 o)
+{
+ char *r;
+
+ /*
+ * -2147483647/-32767
+ * 0 1
+ * 1234567890123456789
+ */
+ r = (char *) palloc(19);
+ sprintf(r, "%d/%d", o->oi_oid, o->oi_int2);
+
+ return (r);
+}
+
+bool
+oidint2lt(OidInt2 o1, OidInt2 o2)
+{
+ return
+ ((bool) (o1->oi_oid < o2->oi_oid ||
+ (o1->oi_oid == o2->oi_oid && o1->oi_int2 < o2->oi_int2)));
+}
+
+bool
+oidint2le(OidInt2 o1, OidInt2 o2)
+{
+ return ((bool) (o1->oi_oid < o2->oi_oid ||
+ (o1->oi_oid == o2->oi_oid && o1->oi_int2 <= o2->oi_int2)));
+}
+
+bool
+oidint2eq(OidInt2 o1, OidInt2 o2)
+{
+ return ((bool) (o1->oi_oid == o2->oi_oid && o1->oi_int2 == o2->oi_int2));
+}
+
+bool
+oidint2ge(OidInt2 o1, OidInt2 o2)
+{
+ return ((bool) (o1->oi_oid > o2->oi_oid ||
+ (o1->oi_oid == o2->oi_oid && o1->oi_int2 >= o2->oi_int2)));
+}
+
+bool
+oidint2gt(OidInt2 o1, OidInt2 o2)
+{
+ return ((bool) (o1->oi_oid > o2->oi_oid ||
+ (o1->oi_oid == o2->oi_oid && o1->oi_int2 > o2->oi_int2)));
+}
+
+bool
+oidint2ne(OidInt2 o1, OidInt2 o2)
+{
+ return ((bool) (o1->oi_oid != o2->oi_oid || o1->oi_int2 != o2->oi_int2));
+}
+
+int
+oidint2cmp(OidInt2 o1, OidInt2 o2)
+{
+ if (oidint2lt(o1, o2))
+ return (-1);
+ else if (oidint2eq(o1, o2))
+ return (0);
+ else
+ return (1);
+}
+
+OidInt2
+mkoidint2(Oid v_oid, uint16 v_int2)
+{
+ OidInt2 o;
+
+ o = (OidInt2) palloc(sizeof(OidInt2Data));
+ o->oi_oid = v_oid;
+ o->oi_int2 = v_int2;
+ return (o);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * oidint4.c--
+ * Functions for the built-in type "oidint4".
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/oidint4.c,v 1.1.1.1 1996/07/09 06:22:05 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* for sprintf() */
+#include "postgres.h"
+#include "utils/palloc.h"
+#include "utils/builtins.h"
+#include "utils/oidcompos.h" /* where function declarations go */
+
+OidInt4 oidint4in(char *o)
+{
+ OidInt4 oi;
+ char *p;
+
+ oi = (OidInt4) palloc(sizeof(OidInt4Data));
+
+ for (p = o; *p != '\0' && *p != '/'; p++)
+ continue;
+
+ oi->oi_oid = (Oid) pg_atoi(o, sizeof(Oid), '/');
+ if (*p == '\0') {
+ oi->oi_int4 = 0;
+ } else {
+ oi->oi_int4 = pg_atoi(++p, sizeof(int4), '\0');
+ }
+
+ return (oi);
+}
+
+char *oidint4out(OidInt4 o)
+{
+ char *r;
+
+ /*
+ * -2147483647/-2147483647
+ * 0 1 2
+ * 123456789012345678901234
+ */
+ r = (char *) palloc(24);
+ sprintf(r, "%d/%d", o->oi_oid, o->oi_int4);
+
+ return (r);
+}
+
+bool oidint4lt(OidInt4 o1, OidInt4 o2)
+{
+ return
+ ((bool) (o1->oi_oid < o2->oi_oid ||
+ (o1->oi_oid == o2->oi_oid && o1->oi_int4 < o2->oi_int4)));
+}
+
+bool oidint4le(OidInt4 o1, OidInt4 o2)
+{
+ return ((bool) (o1->oi_oid < o2->oi_oid ||
+ (o1->oi_oid == o2->oi_oid && o1->oi_int4 <= o2->oi_int4)));
+}
+
+bool oidint4eq(OidInt4 o1, OidInt4 o2)
+{
+ return ((bool) (o1->oi_oid == o2->oi_oid && o1->oi_int4 == o2->oi_int4));
+}
+
+bool oidint4ge(OidInt4 o1, OidInt4 o2)
+{
+ return ((bool) (o1->oi_oid > o2->oi_oid ||
+ (o1->oi_oid == o2->oi_oid && o1->oi_int4 >= o2->oi_int4)));
+}
+
+bool oidint4gt(OidInt4 o1, OidInt4 o2)
+{
+ return ((bool) (o1->oi_oid > o2->oi_oid ||
+ (o1->oi_oid == o2->oi_oid && o1->oi_int4 > o2->oi_int4)));
+}
+
+bool oidint4ne(OidInt4 o1, OidInt4 o2)
+{
+ return ((bool) (o1->oi_oid != o2->oi_oid || o1->oi_int4 != o2->oi_int4));
+}
+
+int oidint4cmp(OidInt4 o1, OidInt4 o2)
+{
+ if (oidint4lt(o1, o2))
+ return (-1);
+ else if (oidint4eq(o1, o2))
+ return (0);
+ else
+ return (1);
+}
+
+OidInt4 mkoidint4(Oid v_oid, uint32 v_int4)
+{
+ OidInt4 o;
+
+ o = (OidInt4) palloc(sizeof(OidInt4Data));
+ o->oi_oid = v_oid;
+ o->oi_int4 = v_int4;
+ return (o);
+}
+
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * oidname.c--
+ * adt for multiple key indices involving oid and name. Used for cache
+ * index scans (could also be used in the general case with name).
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/oidname.c,v 1.1.1.1 1996/07/09 06:22:05 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+
+#include "postgres.h"
+#include "utils/oidcompos.h" /* where function declarations go */
+#include "utils/builtins.h" /* for pg_atoi() */
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+OidName
+oidnamein(char *inStr)
+{
+ OidName oc;
+ char *inptr;
+
+ oc = (OidName) palloc(sizeof(OidNameData));
+
+ memset(oc, 0, sizeof(OidNameData));
+ for (inptr = inStr; *inptr && *inptr != ','; inptr++)
+ ;
+
+ if (*inptr) {
+ oc->id = (Oid) pg_atoi(inStr, sizeof(Oid), ',');
+ /* copy one less to ensure null-padding */
+ strncpy(oc->name.data,++inptr,NAMEDATALEN-1);
+ /* namestrcpy(&oc->name, ++inptr); */
+ }else
+ elog(WARN, "Bad input data for type oidname");
+
+ return oc;
+}
+
+char *
+oidnameout(OidName oidname)
+{
+ char buf[30+NAMEDATALEN]; /* oidname length + oid length + some safety */
+ char *res;
+
+ sprintf(buf, "%d,%s", oidname->id, oidname->name.data);
+ res = pstrdup(buf);
+ return(res);
+}
+
+bool
+oidnamelt(OidName o1, OidName o2)
+{
+ return (bool)
+ (o1->id < o2->id ||
+ (o1->id == o2->id && namecmp(&o1->name, &o2->name) < 0));
+}
+
+bool
+oidnamele(OidName o1, OidName o2)
+{
+ return (bool)
+ (o1->id < o2->id ||
+ (o1->id == o2->id && namecmp(&o1->name,&o2->name) <= 0));
+}
+
+bool
+oidnameeq(OidName o1, OidName o2)
+{
+ return (bool)
+ (o1->id == o2->id &&
+ (namecmp(&o1->name, &o2->name) == 0));
+}
+
+bool
+oidnamene(OidName o1, OidName o2)
+{
+ return (bool)
+ (o1->id != o2->id ||
+ (namecmp(&o1->name,&o2->name) != 0));
+}
+
+bool
+oidnamege(OidName o1, OidName o2)
+{
+ return (bool) (o1->id > o2->id || (o1->id == o2->id &&
+ namecmp(&o1->name, &o2->name) >= 0));
+}
+
+bool
+oidnamegt(OidName o1, OidName o2)
+{
+ return (bool) (o1->id > o2->id || (o1->id == o2->id &&
+ namecmp(&o1->name, &o2->name) > 0));
+}
+
+int
+oidnamecmp(OidName o1, OidName o2)
+{
+ if (o1->id == o2->id)
+ return (namecmp(&o1->name,&o2->name));
+
+ return (o1->id < o2->id) ? -1 : 1;
+}
+
+OidName
+mkoidname(Oid id, char *name)
+{
+ OidName oidname;
+
+ oidname = (OidName) palloc(sizeof(Oid)+NAMEDATALEN);
+
+ oidname->id = id;
+ namestrcpy(&oidname->name,name);
+ return oidname;
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * regexp.c--
+ * regular expression handling code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/regexp.c,v 1.1.1.1 1996/07/09 06:22:05 scrappy Exp $
+ *
+ * Alistair Crooks added the code for the regex caching
+ * agc - cached the regular expressions used - there's a good chance
+ * that we'll get a hit, so this saves a compile step for every
+ * attempted match. I haven't actually measured the speed improvement,
+ * but it `looks' a lot quicker visually when watching regression
+ * test output.
+ *
+ * agc - incorporated Keith Bostic's Berkeley regex code into
+ * the tree for all ports. To distinguish this regex code from any that
+ * is existent on a platform, I've prepended the string "pg95_" to
+ * the functions regcomp, regerror, regexec and regfree.
+ * Fixed a bug that was originally a typo by me, where `i' was used
+ * instead of `oldest' when compiling regular expressions - benign
+ * results mostly, although occasionally it bit you...
+ *
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "postgres.h" /* postgres system include file */
+#include "utils/elog.h" /* for logging postgres errors */
+#include "utils/palloc.h"
+#include "utils/builtins.h" /* where the function declarations go */
+
+#if defined(DISABLE_XOPEN_NLS)
+#undef _XOPEN_SOURCE
+#endif /* DISABLE_XOPEN_NLS */
+
+#ifndef WIN32
+
+#include
+#include
+
+#endif /* WIN32 why is this necessary? */
+
+/* this is the number of cached regular expressions held. */
+#ifndef MAX_CACHED_RES
+#define MAX_CACHED_RES 32
+#endif
+
+/* this structure describes a cached regular expression */
+struct cached_re_str {
+ struct varlena *cre_text; /* pattern as a text* */
+ char *cre_s; /* pattern as null-terminated string */
+ int cre_type; /* compiled-type: extended,icase etc */
+ regex_t cre_re; /* the compiled regular expression */
+ unsigned long cre_lru; /* lru tag */
+};
+
+static int rec = 0; /* # of cached re's */
+static struct cached_re_str rev[MAX_CACHED_RES]; /* cached re's */
+static unsigned long lru; /* system lru tag */
+
+/* attempt to compile `re' as an re, then match it against text */
+/* cflags - flag to regcomp indicates case sensitivity */
+static int
+RE_compile_and_execute(struct varlena *text_re, char *text, int cflags)
+{
+ int oldest;
+ int n;
+ int i;
+ char *re;
+ int regcomp_result;
+
+ re = textout(text_re);
+ /* find a previously compiled regular expression */
+ for (i = 0 ; i < rec ; i++) {
+ if (rev[i].cre_s) {
+ if (strcmp(rev[i].cre_s, re) == 0) {
+ if (rev[i].cre_type == cflags) {
+ rev[i].cre_lru = ++lru;
+ pfree(re);
+ return(pg95_regexec(&rev[i].cre_re,
+ text, 0,
+ (regmatch_t *) NULL, 0) == 0);
+ }
+ }
+ }
+ }
+
+
+
+ /* we didn't find it - make room in the cache for it */
+ if (rec == MAX_CACHED_RES) {
+ /* cache is full - find the oldest entry */
+ for (oldest = 0, i = 1 ; i < rec ; i++) {
+ if (rev[i].cre_lru < rev[oldest].cre_lru) {
+ oldest = i;
+ }
+ }
+ } else {
+ oldest = rec++;
+ }
+
+ /* if there was an old re, then de-allocate the space it used */
+ if (rev[oldest].cre_s != (char *) NULL) {
+ for (lru = i = 0 ; i < rec ; i++) {
+ rev[i].cre_lru =
+ (rev[i].cre_lru - rev[oldest].cre_lru) / 2;
+ if (rev[i].cre_lru > lru) {
+ lru = rev[i].cre_lru;
+ }
+ }
+ pg95_regfree(&rev[oldest].cre_re);
+ /* use malloc/free for the cre_s field because the storage
+ has to persist across transactions */
+ free(rev[oldest].cre_s);
+ }
+
+ /* compile the re */
+ regcomp_result = pg95_regcomp(&rev[oldest].cre_re, re, cflags);
+ if ( regcomp_result == 0) {
+ n = strlen(re);
+ /* use malloc/free for the cre_s field because the storage
+ has to persist across transactions */
+ rev[oldest].cre_s = (char *) malloc(n + 1);
+ (void) memmove(rev[oldest].cre_s, re, n);
+ rev[oldest].cre_s[n] = 0;
+ rev[oldest].cre_text = text_re;
+ rev[oldest].cre_lru = ++lru;
+ rev[oldest].cre_type = cflags;
+ pfree(re);
+ /* agc - fixed an old typo here */
+ return(pg95_regexec(&rev[oldest].cre_re, text, 0,
+ (regmatch_t *) NULL, 0) == 0);
+ } else {
+ char errMsg[1000];
+ /* re didn't compile */
+ rev[oldest].cre_s = (char *) NULL;
+ pg95_regerror(regcomp_result, &rev[oldest].cre_re, errMsg,
+ sizeof(errMsg));
+ elog(WARN,"regcomp failed with error %s",errMsg);
+ }
+
+ /* not reached */
+ return(0);
+}
+
+
+
+/*
+ * interface routines called by the function manager
+ */
+
+/*
+ fixedlen_regexeq:
+
+ a generic fixed length regexp routine
+ s - the string to match against (not necessarily null-terminated)
+ p - the pattern
+ charlen - the length of the string
+*/
+static bool
+fixedlen_regexeq(char *s, struct varlena* p, int charlen, int cflags)
+{
+ char *sterm;
+ int result;
+
+ if (!s || !p)
+ return FALSE;
+
+ /* be sure sterm is null-terminated */
+ sterm = (char *) palloc(charlen + 1);
+ memset(sterm, 0, charlen + 1);
+ strncpy(sterm, s, charlen);
+
+ result = RE_compile_and_execute(p, sterm, cflags);
+
+ pfree(sterm);
+
+ return ((bool) result);
+
+}
+
+
+/*
+ * routines that use the regexp stuff
+ */
+bool
+char2regexeq(uint16 arg1, struct varlena *p)
+{
+ char *s = (char *) &arg1;
+ return (fixedlen_regexeq(s, p, 2, REG_EXTENDED));
+}
+
+bool
+char2regexne(uint16 arg1, struct varlena *p)
+{
+ return (!char2regexeq(arg1, p));
+}
+
+bool
+char4regexeq(uint32 arg1, struct varlena *p)
+{
+ char *s = (char *) &arg1;
+ return (fixedlen_regexeq(s, p, 4, REG_EXTENDED));
+}
+
+bool
+char4regexne(uint32 arg1, struct varlena *p)
+{
+ return (!char4regexeq(arg1, p));
+}
+
+bool
+char8regexeq(char *s, struct varlena *p)
+{
+ return (fixedlen_regexeq(s, p, 8, REG_EXTENDED));
+}
+
+bool
+char8regexne(char *s, struct varlena *p)
+{
+ return (!char8regexeq(s, p));
+}
+
+bool
+char16regexeq(char *s, struct varlena *p)
+{
+ return (fixedlen_regexeq(s, p, 16, REG_EXTENDED));
+}
+
+bool
+char16regexne(char *s, struct varlena *p)
+{
+ return (!char16regexeq(s, p));
+}
+
+bool
+nameregexeq(NameData *n, struct varlena *p)
+{
+ return (fixedlen_regexeq(n->data, p, NAMEDATALEN, REG_EXTENDED));
+}
+bool
+nameregexne(NameData *s, struct varlena *p)
+{
+ return (!nameregexeq(s, p));
+}
+
+bool
+textregexeq(struct varlena *s, struct varlena *p)
+{
+ return (fixedlen_regexeq(VARDATA(s), p, VARSIZE(s) - VARHDRSZ, REG_EXTENDED));
+}
+
+bool
+textregexne(struct varlena *s, struct varlena *p)
+{
+ return (!textregexeq(s, p));
+}
+
+
+/*
+* routines that use the regexp stuff, but ignore the case.
+ * for this, we use the REG_ICASE flag to pg95_regcomp
+ */
+bool
+char2icregexeq(uint16 arg1, struct varlena *p)
+{
+ char *s = (char *) &arg1;
+ return (fixedlen_regexeq(s, p, 2, REG_ICASE | REG_EXTENDED));
+}
+
+
+bool
+char2icregexne(uint16 arg1, struct varlena *p)
+{
+ return (!char2icregexeq(arg1, p));
+}
+
+bool
+char4icregexeq(uint32 arg1, struct varlena *p)
+{
+ char *s = (char *) &arg1;
+ return (fixedlen_regexeq(s, p, 4, REG_ICASE | REG_EXTENDED ));
+}
+
+bool
+char4icregexne(uint32 arg1, struct varlena *p)
+{
+ return (!char4icregexeq(arg1, p));
+}
+
+bool
+char8icregexeq(char *s, struct varlena *p)
+{
+ return (fixedlen_regexeq(s, p, 8, REG_ICASE | REG_EXTENDED));
+}
+
+bool
+char8icregexne(char *s, struct varlena *p)
+{
+ return (!char8icregexeq(s, p));
+}
+
+bool
+char16icregexeq(char *s, struct varlena *p)
+{
+ return (fixedlen_regexeq(s, p, 16, REG_ICASE | REG_EXTENDED));
+}
+
+bool
+char16icregexne(char *s, struct varlena *p)
+{
+ return (!char16icregexeq(s, p));
+}
+
+bool
+texticregexeq(struct varlena *s, struct varlena *p)
+{
+ return (fixedlen_regexeq(VARDATA(s), p, VARSIZE(s) - VARHDRSZ,
+ REG_ICASE | REG_EXTENDED));
+}
+
+bool
+texticregexne(struct varlena *s, struct varlena *p)
+{
+ return (!texticregexeq(s, p));
+}
+
+bool
+nameicregexeq(NameData *n, struct varlena *p)
+{
+ return (fixedlen_regexeq(n->data, p, NAMEDATALEN,
+ REG_ICASE | REG_EXTENDED));
+}
+bool
+nameicregexne(NameData *s, struct varlena *p)
+{
+ return (!nameicregexeq(s, p));
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * regproc.c--
+ * Functions for the built-in type "RegProcedure".
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.1.1.1 1996/07/09 06:22:05 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "postgres.h"
+#include "access/heapam.h"
+#include "access/relscan.h"
+#include "access/skey.h"
+#include "utils/tqual.h" /* for NowTimeQual */
+#include "fmgr.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+#include "catalog/catname.h"
+#include "utils/builtins.h" /* where function declarations go */
+
+/*****************************************************************************
+ * USER I/O ROUTINES *
+ *****************************************************************************/
+
+/*
+ * regprocin - converts "proname" to proid
+ *
+ * proid of NULL signifies unknown
+ */
+int32 regprocin(char *proname)
+{
+ Relation proc;
+ HeapScanDesc procscan;
+ HeapTuple proctup;
+ ScanKeyData key;
+ RegProcedure result;
+ bool isnull;
+
+ if (proname == NULL)
+ return(0);
+ proc = heap_openr(ProcedureRelationName);
+ if (!RelationIsValid(proc)) {
+ elog(WARN, "regprocin: could not open %s",
+ ProcedureRelationName);
+ return(0);
+ }
+ ScanKeyEntryInitialize(&key,
+ (bits16)0,
+ (AttrNumber)1,
+ (RegProcedure)F_CHAR16EQ,
+ (Datum)proname);
+
+ procscan = heap_beginscan(proc, 0, NowTimeQual, 1, &key);
+ if (!HeapScanIsValid(procscan)) {
+ heap_close(proc);
+ elog(WARN, "regprocin: could not being scan of %s",
+ ProcedureRelationName);
+ return(0);
+ }
+ proctup = heap_getnext(procscan, 0, (Buffer *) NULL);
+ switch (HeapTupleIsValid(proctup)) {
+ case 1:
+ result = (RegProcedure) heap_getattr(proctup,
+ InvalidBuffer,
+ ObjectIdAttributeNumber,
+ RelationGetTupleDescriptor(proc),
+ &isnull);
+ if (isnull) {
+ elog(FATAL, "regprocin: null procedure %s", proname);
+ }
+ break;
+ case 0:
+ result = (RegProcedure) 0;
+#ifdef EBUG
+ elog(DEBUG, "regprocin: no such procedure %s", proname);
+#endif /* defined(EBUG) */
+ }
+ heap_endscan(procscan);
+ heap_close(proc);
+ return((int32) result);
+}
+
+/*
+ * regprocout - converts proid to "proname"
+ */
+char *regprocout(RegProcedure proid)
+{
+ Relation proc;
+ HeapScanDesc procscan;
+ HeapTuple proctup;
+ char *result;
+ ScanKeyData key;
+
+ result = (char *)palloc(NAMEDATALEN);
+ proc = heap_openr(ProcedureRelationName);
+ if (!RelationIsValid(proc)) {
+ elog(WARN, "regprocout: could not open %s",
+ ProcedureRelationName);
+ return(0);
+ }
+ ScanKeyEntryInitialize(&key,
+ (bits16)0,
+ (AttrNumber)ObjectIdAttributeNumber,
+ (RegProcedure)F_INT4EQ,
+ (Datum)proid);
+
+ procscan = heap_beginscan(proc, 0, NowTimeQual, 1, &key);
+ if (!HeapScanIsValid(procscan)) {
+ heap_close(proc);
+ elog(WARN, "regprocin: could not being scan of %s",
+ ProcedureRelationName);
+ return(0);
+ }
+ proctup = heap_getnext(procscan, 0, (Buffer *)NULL);
+ switch (HeapTupleIsValid(proctup)) {
+ char *s;
+ bool isnull;
+ case 1:
+ s = (char *) heap_getattr(proctup, InvalidBuffer, 1,
+ RelationGetTupleDescriptor(proc), &isnull);
+ if (!isnull) {
+ strncpy(result, s, 16);
+ break;
+ }
+ elog(FATAL, "regprocout: null procedure %d", proid);
+ /*FALLTHROUGH*/
+ case 0:
+ memset(result, 0, 16);
+ result[0] = '-';
+#ifdef EBUG
+ elog(DEBUG, "regprocout: no such procedure %d", proid);
+#endif /* defined(EBUG) */
+ }
+ heap_endscan(procscan);
+ heap_close(proc);
+ return(result);
+}
+
+
+/*****************************************************************************
+ * PUBLIC ROUTINES *
+ *****************************************************************************/
+
+Oid RegprocToOid(RegProcedure rp)
+{
+ return (Oid)rp;
+}
+
+/* (see int.c for comparison/operation routines) */
+
+
+/* ========== PRIVATE ROUTINES ========== */
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * selfuncs.c--
+ * Selectivity functions for system catalogs and builtin types
+ *
+ * These routines are registered in the operator catalog in the
+ * "oprrest" and "oprjoin" attributes.
+ *
+ * XXX check all the functions--I suspect them to be 1-based.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.1.1.1 1996/07/09 06:22:05 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+
+#include "access/heapam.h"
+#include "utils/tqual.h" /* for NowTimeQual */
+#include "fmgr.h"
+#include "utils/builtins.h" /* for textout() prototype
+ and where the declarations go */
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+#include "catalog/catname.h"
+#include "utils/syscache.h"
+#include "utils/lsyscache.h" /* for get_oprrest() */
+#include "catalog/pg_statistic.h"
+
+
+/* N is not a valid var/constant or relation id */
+#define NONVALUE(N) ((N) == -1)
+
+/*
+ * generalize the test for functional index selectivity request
+ */
+#define FunctionalSelectivity(nIndKeys,attNum) (attNum==InvalidAttrNumber)
+
+static int32 getattnvals(Oid relid, AttrNumber attnum);
+static void gethilokey(Oid relid, AttrNumber attnum, Oid opid,
+ char **high, char **low);
+
+
+/*
+ * eqsel - Selectivity of "=" for any data type.
+ */
+float64
+eqsel(Oid opid,
+ Oid relid,
+ AttrNumber attno,
+ char *value,
+ int32 flag)
+{
+ int32 nvals;
+ float64 result;
+
+ result = (float64) palloc(sizeof(float64data));
+ if (NONVALUE(attno) || NONVALUE(relid))
+ *result = 0.1;
+ else {
+ nvals = getattnvals(relid, (int) attno);
+ if (nvals == 0)
+ *result = 0.0;
+ else
+ *result = 1.0 / nvals;
+ }
+ return(result);
+}
+
+/*
+ * neqsel - Selectivity of "!=" for any data type.
+ */
+float64
+neqsel(Oid opid,
+ Oid relid,
+ AttrNumber attno,
+ char *value,
+ int32 flag)
+{
+ float64 result;
+
+ result = eqsel(opid, relid, attno, value, flag);
+ *result = 1.0 - *result;
+ return(result);
+}
+
+/*
+ * intltsel - Selectivity of "<" for integers.
+ * Should work for both longs and shorts.
+ */
+float64
+intltsel(Oid opid,
+ Oid relid,
+ AttrNumber attno,
+ int32 value,
+ int32 flag)
+{
+ float64 result;
+ char *highchar, *lowchar;
+ long val, high, low, top, bottom;
+
+ result = (float64) palloc(sizeof(float64data));
+ if (NONVALUE(attno) || NONVALUE(relid))
+ *result = 1.0 / 3;
+ else {
+ /* XXX val = atol(value);*/
+ val = value;
+ gethilokey(relid, (int) attno, opid, &highchar, &lowchar);
+ if (*highchar == 'n' || *lowchar == 'n') {
+ *result = 1.0/3.0;
+ return (result);
+ }
+ high = atol(highchar);
+ low = atol(lowchar);
+ if ((flag & SEL_RIGHT && val < low) ||
+ (!(flag & SEL_RIGHT) && val > high)) {
+ int nvals;
+ nvals = getattnvals(relid, (int) attno);
+ if (nvals == 0)
+ *result = 1.0 / 3.0;
+ else
+ *result = 3.0 / nvals;
+ }else {
+ bottom = high - low;
+ if (bottom == 0)
+ ++bottom;
+ if (flag & SEL_RIGHT)
+ top = val - low;
+ else
+ top = high - val;
+ if (top > bottom)
+ *result = 1.0;
+ else {
+ if (top == 0)
+ ++top;
+ *result = ((1.0 * top) / bottom);
+ }
+ }
+ }
+ return(result);
+}
+
+/*
+ * intgtsel - Selectivity of ">" for integers.
+ * Should work for both longs and shorts.
+ */
+float64
+intgtsel(Oid opid,
+ Oid relid,
+ AttrNumber attno,
+ int32 value,
+ int32 flag)
+{
+ float64 result;
+ int notflag;
+
+ if (flag & 0)
+ notflag = flag & ~SEL_RIGHT;
+ else
+ notflag = flag | SEL_RIGHT;
+ result = intltsel(opid, relid, attno, value, (int32) notflag);
+ return(result);
+}
+
+/*
+ * eqjoinsel - Join selectivity of "="
+ */
+float64
+eqjoinsel(Oid opid,
+ Oid relid1,
+ AttrNumber attno1,
+ Oid relid2,
+ AttrNumber attno2)
+{
+ float64 result;
+ int32 num1, num2, max;
+
+ result = (float64) palloc(sizeof(float64data));
+ if (NONVALUE(attno1) || NONVALUE(relid1) ||
+ NONVALUE(attno2) || NONVALUE(relid2))
+ *result = 0.1;
+ else {
+ num1 = getattnvals(relid1, (int) attno1);
+ num2 = getattnvals(relid2, (int) attno2);
+ max = (num1 > num2) ? num1 : num2;
+ if (max == 0)
+ *result = 1.0;
+ else
+ *result = 1.0 / max;
+ }
+ return(result);
+}
+
+/*
+ * neqjoinsel - Join selectivity of "!="
+ */
+float64
+neqjoinsel(Oid opid,
+ Oid relid1,
+ AttrNumber attno1,
+ Oid relid2,
+ AttrNumber attno2)
+{
+ float64 result;
+
+ result = eqjoinsel(opid, relid1, attno1, relid2, attno2);
+ *result = 1.0 - *result;
+ return(result);
+}
+
+/*
+ * intltjoinsel - Join selectivity of "<"
+ */
+float64
+intltjoinsel(Oid opid,
+ Oid relid1,
+ AttrNumber attno1,
+ Oid relid2,
+ AttrNumber attno2)
+{
+ float64 result;
+
+ result = (float64) palloc(sizeof(float64data));
+ *result = 1.0 / 3.0;
+ return(result);
+}
+
+/*
+ * intgtjoinsel - Join selectivity of ">"
+ */
+float64
+intgtjoinsel(Oid opid,
+ Oid relid1,
+ AttrNumber attno1,
+ Oid relid2,
+ AttrNumber attno2)
+{
+ float64 result;
+
+ result = (float64) palloc(sizeof(float64data));
+ *result = 1.0 / 3.0;
+ return(result);
+}
+
+/*
+ * getattnvals - Retrieves the number of values within an attribute.
+ *
+ * Note:
+ * getattnvals and gethilokey both currently use keyed
+ * relation scans and amgetattr. Alternatively,
+ * the relation scan could be non-keyed and the tuple
+ * returned could be cast (struct X *) tuple + tuple->t_hoff.
+ * The first method is good for testing the implementation,
+ * but the second may ultimately be faster?!? In any case,
+ * using the cast instead of amgetattr would be
+ * more efficient. However, the cast will not work
+ * for gethilokey which accesses stahikey in struct statistic.
+ */
+static int32
+getattnvals(Oid relid, AttrNumber attnum)
+{
+ HeapTuple atp;
+ int nvals;
+
+ atp = SearchSysCacheTuple(ATTNUM,
+ ObjectIdGetDatum(relid),
+ Int16GetDatum(attnum),
+ 0,0);
+ if (!HeapTupleIsValid(atp)) {
+ elog(WARN, "getattnvals: no attribute tuple %d %d",
+ relid, attnum);
+ return(0);
+ }
+ nvals = ((AttributeTupleForm ) GETSTRUCT(atp))->attnvals;
+ if (nvals > 0) return(nvals);
+
+ atp = SearchSysCacheTuple(RELOID, ObjectIdGetDatum(relid),
+ 0,0,0);
+ /* XXX -- use number of tuples as number of distinctive values
+ just for now, in case number of distinctive values is
+ not cached */
+ if (!HeapTupleIsValid(atp)) {
+ elog(WARN, "getattnvals: no relation tuple %d", relid);
+ return(0);
+ }
+ nvals = ((Form_pg_class) GETSTRUCT(atp))->reltuples;
+ return(nvals);
+}
+
+/*
+ * gethilokey - Returns a pointer to strings containing
+ * the high and low keys within an attribute.
+ *
+ * Currently returns "0", and "0" in high and low if the statistic
+ * catalog does not contain the proper tuple. Eventually, the
+ * statistic demon should have the tuple maintained, and it should
+ * elog() if the tuple is missing.
+ *
+ * XXX Question: is this worth sticking in the catalog caches,
+ * or will this get invalidated too often?
+ */
+static void
+gethilokey(Oid relid,
+ AttrNumber attnum,
+ Oid opid,
+ char **high,
+ char **low)
+{
+ register Relation rdesc;
+ register HeapScanDesc sdesc;
+ static ScanKeyData key[3] = {
+ { 0, Anum_pg_statistic_starelid, F_OIDEQ },
+ { 0, Anum_pg_statistic_staattnum, F_INT2EQ },
+ { 0, Anum_pg_statistic_staop, F_OIDEQ }
+ };
+ bool isnull;
+ HeapTuple tuple;
+
+ rdesc = heap_openr(StatisticRelationName);
+
+ key[0].sk_argument = ObjectIdGetDatum(relid);
+ key[1].sk_argument = Int16GetDatum((int16) attnum);
+ key[2].sk_argument = ObjectIdGetDatum(opid);
+ sdesc = heap_beginscan(rdesc, 0, NowTimeQual, 3, key);
+ tuple = heap_getnext(sdesc, 0, (Buffer *) NULL);
+ if (!HeapTupleIsValid(tuple)) {
+ *high = "n";
+ *low = "n";
+ /* XXX elog(WARN, "gethilokey: statistic tuple not found");*/
+ return;
+ }
+ *high = textout((struct varlena *)
+ heap_getattr(tuple,
+ InvalidBuffer,
+ Anum_pg_statistic_stahikey,
+ RelationGetTupleDescriptor(rdesc),
+ &isnull));
+ if (isnull)
+ elog(DEBUG, "gethilokey: high key is null");
+ *low = textout((struct varlena *)
+ heap_getattr(tuple,
+ InvalidBuffer,
+ Anum_pg_statistic_stalokey,
+ RelationGetTupleDescriptor(rdesc),
+ &isnull));
+ if (isnull)
+ elog(DEBUG, "gethilokey: low key is null");
+ heap_endscan(sdesc);
+ heap_close(rdesc);
+}
+
+float64
+btreesel(Oid operatorObjectId,
+ Oid indrelid,
+ AttrNumber attributeNumber,
+ char *constValue,
+ int32 constFlag,
+ int32 nIndexKeys,
+ Oid indexrelid)
+{
+ float64 result;
+ float64data resultData;
+
+ if (FunctionalSelectivity(nIndexKeys, attributeNumber)) {
+ /*
+ * Need to call the functions selectivity
+ * function here. For now simply assume it's
+ * 1/3 since functions don't currently
+ * have selectivity functions
+ */
+ resultData = 1.0 / 3.0;
+ result = &resultData;
+ }
+ else {
+ result = (float64)fmgr(get_oprrest (operatorObjectId),
+ (char*)operatorObjectId,
+ (char*)indrelid,
+ (char*)attributeNumber,
+ (char*)constValue,
+ (char*)constFlag,
+ NULL);
+ }
+
+ if (!PointerIsValid(result))
+ elog(WARN, "Btree Selectivity: bad pointer");
+ if (*result < 0.0 || *result > 1.0)
+ elog(WARN, "Btree Selectivity: bad value %lf", *result);
+
+ return(result);
+}
+
+float64
+btreenpage(Oid operatorObjectId,
+ Oid indrelid,
+ AttrNumber attributeNumber,
+ char *constValue,
+ int32 constFlag,
+ int32 nIndexKeys,
+ Oid indexrelid)
+{
+ float64 temp, result;
+ float64data tempData;
+ HeapTuple atp;
+ int npage;
+
+ if (FunctionalSelectivity(nIndexKeys, attributeNumber)) {
+ /*
+ * Need to call the functions selectivity
+ * function here. For now simply assume it's
+ * 1/3 since functions don't currently
+ * have selectivity functions
+ */
+ tempData = 1.0 / 3.0;
+ temp = &tempData;
+ }
+ else {
+ temp = (float64)fmgr(get_oprrest (operatorObjectId),
+ (char*)operatorObjectId,
+ (char*)indrelid,
+ (char*)attributeNumber,
+ (char*)constValue,
+ (char*)constFlag,
+ NULL);
+ }
+ atp = SearchSysCacheTuple(RELOID,
+ ObjectIdGetDatum(indexrelid),
+ 0,0,0);
+ if (!HeapTupleIsValid(atp)) {
+ elog(WARN, "btreenpage: no index tuple %d", indexrelid);
+ return(0);
+ }
+
+ npage = ((Form_pg_class) GETSTRUCT(atp))->relpages;
+ result = (float64)palloc(sizeof(float64data));
+ *result = *temp * npage;
+ return(result);
+}
+
+float64
+hashsel(Oid operatorObjectId,
+ Oid indrelid,
+ AttrNumber attributeNumber,
+ char *constValue,
+ int32 constFlag,
+ int32 nIndexKeys,
+ Oid indexrelid)
+{
+
+ float64 result;
+ float64data resultData;
+ HeapTuple atp;
+ int ntuples;
+
+ if (FunctionalSelectivity(nIndexKeys, attributeNumber)) {
+ /*
+ * Need to call the functions selectivity
+ * function here. For now simply use 1/Number of Tuples
+ * since functions don't currently
+ * have selectivity functions
+ */
+
+ atp = SearchSysCacheTuple(RELOID, ObjectIdGetDatum(indexrelid),
+ 0,0,0);
+ if (!HeapTupleIsValid(atp)) {
+ elog(WARN, "hashsel: no index tuple %d", indexrelid);
+ return(0);
+ }
+ ntuples = ((Form_pg_class) GETSTRUCT(atp))->reltuples;
+ if (ntuples > 0) {
+ resultData = 1.0 / (float64data) ntuples;
+ }
+ else {
+ resultData = (float64data) (1.0 / 100.0);
+ }
+ result = &resultData;
+
+ }
+ else {
+ result = (float64)fmgr(get_oprrest (operatorObjectId),
+ (char*)operatorObjectId,
+ (char*)indrelid,
+ (char*)attributeNumber,
+ (char*)constValue,
+ (char*)constFlag,
+ NULL);
+ }
+
+ if (!PointerIsValid(result))
+ elog(WARN, "Hash Table Selectivity: bad pointer");
+ if (*result < 0.0 || *result > 1.0)
+ elog(WARN, "Hash Table Selectivity: bad value %lf", *result);
+
+ return(result);
+
+
+}
+
+float64
+hashnpage(Oid operatorObjectId,
+ Oid indrelid,
+ AttrNumber attributeNumber,
+ char *constValue,
+ int32 constFlag,
+ int32 nIndexKeys,
+ Oid indexrelid)
+{
+ float64 temp, result;
+ float64data tempData;
+ HeapTuple atp;
+ int npage;
+ int ntuples;
+
+ atp = SearchSysCacheTuple(RELOID, ObjectIdGetDatum(indexrelid),
+ 0,0,0);
+ if (!HeapTupleIsValid(atp)) {
+ elog(WARN, "hashsel: no index tuple %d", indexrelid);
+ return(0);
+ }
+
+
+ if (FunctionalSelectivity(nIndexKeys, attributeNumber)) {
+ /*
+ * Need to call the functions selectivity
+ * function here. For now, use 1/Number of Tuples
+ * since functions don't currently
+ * have selectivity functions
+ */
+
+ ntuples = ((Form_pg_class) GETSTRUCT(atp))->reltuples;
+ if (ntuples > 0) {
+ tempData = 1.0 / (float64data) ntuples;
+ }
+ else {
+ tempData = (float64data) (1.0 / 100.0);
+ }
+ temp = &tempData;
+
+ }
+ else {
+ temp = (float64)fmgr(get_oprrest (operatorObjectId),
+ (char*)operatorObjectId,
+ (char*)indrelid,
+ (char*)attributeNumber,
+ (char*)constValue,
+ (char*)constFlag,
+ NULL);
+ }
+
+ npage = ((Form_pg_class) GETSTRUCT(atp))->relpages;
+ result = (float64)palloc(sizeof(float64data));
+ *result = *temp * npage;
+ return(result);
+}
+
+
+float64
+rtsel(Oid operatorObjectId,
+ Oid indrelid,
+ AttrNumber attributeNumber,
+ char *constValue,
+ int32 constFlag,
+ int32 nIndexKeys,
+ Oid indexrelid)
+{
+ return (btreesel(operatorObjectId, indrelid, attributeNumber,
+ constValue, constFlag, nIndexKeys, indexrelid));
+}
+
+float64
+rtnpage(Oid operatorObjectId,
+ Oid indrelid,
+ AttrNumber attributeNumber,
+ char *constValue,
+ int32 constFlag,
+ int32 nIndexKeys,
+ Oid indexrelid)
+{
+ return (btreenpage(operatorObjectId, indrelid, attributeNumber,
+ constValue, constFlag, nIndexKeys, indexrelid));
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * sets.c--
+ * Functions for sets, which are defined by queries.
+ * Example: a set is defined as being the result of the query
+ * retrieve (X.all)
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/sets.c,v 1.1.1.1 1996/07/09 06:22:05 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* for sprintf() */
+#include "postgres.h"
+#include "utils/elog.h"
+#include "nodes/pg_list.h" /* for LispValue and List */
+#include "access/htup.h" /* for HeapTuple */
+#include "access/heapam.h"
+#include "access/relscan.h"
+#include "access/xact.h"
+#include "catalog/pg_proc.h" /* for Form_pg_proc */
+#include "utils/syscache.h" /* for PROOID */
+#include "catalog/catname.h" /* for ProcedureRelationName */
+#include "catalog/indexing.h" /* for Num_pg_proc_indices */
+#include "storage/lmgr.h"
+#include "utils/sets.h" /* for GENERICSETNAME */
+#include "tcop/dest.h"
+#include "fmgr.h"
+
+extern CommandDest whereToSendOutput; /* defined in tcop/postgres.c */
+
+
+/*
+ * SetDefine - converts query string defining set to an oid
+ *
+ * The query string is used to store the set as a function in
+ * pg_proc. The name of the function is then changed to use the
+ * OID of its tuple in pg_proc.
+ */
+Oid
+SetDefine(char *querystr, char *typename)
+{
+ Oid setoid;
+ char *procname = GENERICSETNAME;
+ char *fileName = "-";
+ char realprocname[16];
+ HeapTuple tup, newtup;
+ Form_pg_proc proc;
+ Relation procrel;
+ int i;
+ Datum replValue[Natts_pg_proc];
+ char replNull[Natts_pg_proc];
+ char repl[Natts_pg_proc];
+ HeapScanDesc pg_proc_scan;
+ Buffer buffer;
+ ItemPointerData ipdata;
+
+ static ScanKeyData oidKey[1] = {
+ { 0, ObjectIdAttributeNumber, ObjectIdEqualRegProcedure }};
+
+
+ setoid = ProcedureCreate(procname, /* changed below, after oid known */
+ true, /* returnsSet */
+ typename, /* returnTypeName */
+ "sql", /* languageName */
+ querystr, /* sourceCode */
+ fileName, /* fileName */
+ false, /* canCache */
+ true, /* trusted */
+ 100, /* byte_pct */
+ 0, /* perbyte_cpu */
+ 0, /* percall_cpu */
+ 100, /* outin_ratio */
+ NIL, /* argList */
+ whereToSendOutput);
+ /* Since we're still inside this command of the transaction, we can't
+ * see the results of the procedure definition unless we pretend
+ * we've started the next command. (Postgres's solution to the
+ * Halloween problem is to not allow you to see the results of your
+ * command until you start the next command.)
+ */
+ CommandCounterIncrement();
+ tup = SearchSysCacheTuple(PROOID,
+ ObjectIdGetDatum(setoid),
+ 0,0,0);
+ if (!HeapTupleIsValid(tup))
+ elog(WARN, "setin: unable to define set %s", querystr);
+
+ /* We can tell whether the set was already defined by checking
+ * the name. If it's GENERICSETNAME, the set is new. If it's
+ * "set" it's already defined.
+ */
+ proc = (Form_pg_proc)GETSTRUCT(tup);
+ if (!strcmp((char*)procname, (char*)&(proc->proname))) {
+ /* make the real proc name */
+ sprintf(realprocname, "set%u", setoid);
+
+ /* set up the attributes to be modified or kept the same */
+ repl[0] = 'r';
+ for (i = 1; i < Natts_pg_proc; i++) repl[i] = ' ';
+ replValue[0] = (Datum)realprocname;
+ for (i = 1; i < Natts_pg_proc; i++) replValue[i] = (Datum)0;
+ for (i = 0; i < Natts_pg_proc; i++) replNull[i] = ' ';
+
+ /* change the pg_proc tuple */
+ procrel = heap_openr(ProcedureRelationName);
+ RelationSetLockForWrite(procrel);
+ fmgr_info(ObjectIdEqualRegProcedure,
+ &oidKey[0].sk_func,
+ &oidKey[0].sk_nargs);
+ oidKey[0].sk_argument = ObjectIdGetDatum(setoid);
+ pg_proc_scan = heap_beginscan(procrel,
+ 0,
+ SelfTimeQual,
+ 1,
+ oidKey);
+ tup = heap_getnext(pg_proc_scan, 0, &buffer);
+ if (HeapTupleIsValid(tup)) {
+ newtup = heap_modifytuple(tup,
+ buffer,
+ procrel,
+ replValue,
+ replNull,
+ repl);
+
+ /* XXX may not be necessary */
+ ItemPointerCopy(&tup->t_ctid, &ipdata);
+
+ setheapoverride(true);
+ (void) heap_replace(procrel, &ipdata, newtup);
+ setheapoverride(false);
+
+ setoid = newtup->t_oid;
+ } else
+ elog(WARN, "setin: could not find new set oid tuple");
+ heap_endscan(pg_proc_scan);
+
+ if (RelationGetRelationTupleForm(procrel)->relhasindex)
+ {
+ Relation idescs[Num_pg_proc_indices];
+
+ CatalogOpenIndices(Num_pg_proc_indices, Name_pg_proc_indices, idescs);
+ CatalogIndexInsert(idescs, Num_pg_proc_indices, procrel, newtup);
+ CatalogCloseIndices(Num_pg_proc_indices, idescs);
+ }
+ RelationUnsetLockForWrite(procrel);
+ heap_close(procrel);
+ }
+ return setoid;
+}
+
+/* This function is a placeholder. The parser uses the OID of this
+ * function to fill in the :funcid field of a set. This routine is
+ * never executed. At runtime, the OID of the actual set is substituted
+ * into the :funcid.
+ */
+int
+seteval(Oid funcoid)
+{
+ return 17;
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * tid.c--
+ * Functions for the built-in type tuple id
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/tid.c,v 1.1.1.1 1996/07/09 06:22:05 scrappy Exp $
+ *
+ * NOTES
+ * input routine largely stolen from boxin().
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* for sprintf() */
+#include
+#include "postgres.h"
+#include "storage/block.h"
+#include "storage/off.h"
+#include "storage/itemptr.h"
+#include "storage/bufpage.h"
+
+#include "utils/palloc.h"
+#include "utils/builtins.h" /* where function declarations go */
+
+
+#define LDELIM '('
+#define RDELIM ')'
+#define DELIM ','
+#define NTIDARGS 2
+
+/* ----------------------------------------------------------------
+ * tidin
+ * ----------------------------------------------------------------
+ */
+ItemPointer
+tidin(char *str)
+{
+ char *p, *coord[NTIDARGS];
+ int i;
+ ItemPointer result;
+
+ BlockNumber blockNumber;
+ OffsetNumber offsetNumber;
+
+ if (str == NULL)
+ return NULL;
+
+ for (i = 0, p = str; *p && i < NTIDARGS && *p != RDELIM; p++)
+ if (*p == DELIM || (*p == LDELIM && !i))
+ coord[i++] = p + 1;
+
+ if (i < NTIDARGS - 1)
+ return NULL;
+
+ blockNumber = (BlockNumber) atoi(coord[0]);
+ offsetNumber = (OffsetNumber) atoi(coord[1]);
+
+ result = (ItemPointer) palloc(sizeof(ItemPointerData));
+
+ ItemPointerSet(result, blockNumber, offsetNumber);
+
+ return result;
+}
+
+/* ----------------------------------------------------------------
+ * tidout
+ * ----------------------------------------------------------------
+ */
+char *
+tidout(ItemPointer itemPtr)
+{
+ BlockNumber blockNumber;
+ OffsetNumber offsetNumber;
+ BlockId blockId;
+ char buf[32];
+ char *str;
+
+ blockId = &(itemPtr->ip_blkid);
+
+ blockNumber = BlockIdGetBlockNumber(blockId);
+ offsetNumber = itemPtr->ip_posid;
+
+ sprintf(buf, "(%d,%d)", blockNumber, offsetNumber);
+
+ str = (char *) palloc(strlen(buf)+1);
+ strcpy(str, buf);
+
+ return str;
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * char.c--
+ * Functions for the built-in type char() and varchar().
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/varchar.c,v 1.1.1.1 1996/07/09 06:22:05 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* for sprintf() */
+#include
+#include "postgres.h"
+#include "utils/palloc.h"
+#include "utils/elog.h"
+
+/*
+ * CHAR() and VARCHAR() types are part of the ANSI SQL standard. CHAR()
+ * is for blank-padded string whose length is specified in CREATE TABLE.
+ * VARCHAR is for storing string whose length is at most the length specified
+ * at CREATE TABLE time.
+ *
+ * It's hard to implement these types because we cannot figure out what
+ * the length of the type from the type itself. I change (hopefully all) the
+ * fmgr calls that invoke input functions of a data type to supply the
+ * length also. (eg. in INSERTs, we have the tupleDescriptor which contains
+ * the length of the attributes and hence the exact length of the char() or
+ * varchar(). We pass this to bpcharin() or varcharin().) In the case where
+ * we cannot determine the length, we pass in -1 instead and the input string
+ * must be null-terminated.
+ *
+ * We actually implement this as a varlena so that we don't have to pass in
+ * the length for the comparison functions. (The difference between "text"
+ * is that we truncate and possibly blank-pad the string at insertion time.)
+ *
+ * - ay 6/95
+ */
+
+
+/*****************************************************************************
+ * bpchar - char() *
+ *****************************************************************************/
+
+/*
+ * bpcharin -
+ * converts a string of char() type to the internal representation.
+ * len is the length specified in () plus 4 bytes. (XXX dummy is here
+ * because we pass typelem as the second argument for array_in.)
+ */
+char *
+bpcharin(char *s, int dummy, int typlen)
+{
+ char *result, *r;
+ int len = typlen - 4;
+ int i;
+
+ if (s == NULL)
+ return((char *) NULL);
+
+ if (typlen == -1) {
+ /*
+ * this is here because some functions can't supply the typlen
+ */
+ len = strlen(s);
+ typlen = len + 4;
+ }
+
+ if (len < 1 || len > 4096)
+ elog(WARN, "bpcharin: length of char() must be between 1 and 4096");
+
+ result = (char *) palloc(typlen);
+ *(int32*)result = typlen;
+ r = result + 4;
+ for(i=0; i < len; i++, r++, s++) {
+ *r = *s;
+ if (*r == '\0')
+ break;
+ }
+ /* blank pad the string if necessary */
+ for(; i < len; i++) {
+ *r++ = ' ';
+ }
+ return(result);
+}
+
+char *
+bpcharout(char *s)
+{
+ char *result;
+ int len;
+
+ if (s == NULL) {
+ result = (char *) palloc(2);
+ result[0] = '-';
+ result[1] = '\0';
+ } else {
+ len = *(int32*)s - 4;
+ result = (char *) palloc(len+1);
+ strncpy(result, s+4, len); /* these are blank-padded */
+ result[len] = '\0';
+ }
+ return(result);
+}
+
+/*****************************************************************************
+ * varchar - varchar() *
+ *****************************************************************************/
+
+/*
+ * vcharin -
+ * converts a string of varchar() type to the internal representation.
+ * len is the length specified in () plus 4 bytes. (XXX dummy is here
+ * because we pass typelem as the second argument for array_in.)
+ */
+char *
+varcharin(char *s, int dummy, int typlen)
+{
+ char *result;
+ int len = typlen - 4;
+
+ if (s == NULL)
+ return((char *) NULL);
+
+ if (typlen == -1) {
+ /*
+ * this is here because some functions can't supply the typlen
+ */
+ len = strlen(s);
+ typlen = len + 4;
+ }
+
+ if (len < 1 || len > 4096)
+ elog(WARN, "bpcharin: length of char() must be between 1 and 4096");
+
+ result = (char *) palloc(typlen);
+ *(int32*)result = typlen;
+ memset(result+4, 0, len);
+ (void) strncpy(result+4, s, len);
+
+ return(result);
+}
+
+char *
+varcharout(char *s)
+{
+ char *result;
+ int len;
+
+ if (s == NULL) {
+ result = (char *) palloc(2);
+ result[0] = '-';
+ result[1] = '\0';
+ } else {
+ len = *(int32*)s - 4;
+ result = (char *) palloc(len+1);
+ memset(result, 0, len+1);
+ strncpy(result, s+4, len);
+ }
+ return(result);
+}
+
+/*****************************************************************************
+ * Comparison Functions used for bpchar
+ *****************************************************************************/
+
+static int
+bcTruelen(char *arg)
+{
+ char *s = arg + 4;
+ int i;
+ int len;
+
+ len = *(int32*)arg - 4;
+ for(i=len-1; i >= 0; i--) {
+ if (s[i] != ' ')
+ break;
+ }
+ return (i+1);
+}
+
+int32
+bpchareq(char *arg1, char *arg2)
+{
+ int len1, len2;
+
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ len1 = bcTruelen(arg1);
+ len2 = bcTruelen(arg2);
+
+ if (len1!=len2)
+ return 0;
+
+ return(strncmp(arg1+4, arg2+4, len1) == 0);
+}
+
+int32
+bpcharne(char *arg1, char *arg2)
+{
+ int len1, len2;
+
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ len1 = bcTruelen(arg1);
+ len2 = bcTruelen(arg2);
+
+ if (len1!=len2)
+ return 1;
+
+ return(strncmp(arg1+4, arg2+4, len1) != 0);
+}
+
+int32
+bpcharlt(char *arg1, char *arg2)
+{
+ int len1, len2;
+ int cmp;
+
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ len1 = bcTruelen(arg1);
+ len2 = bcTruelen(arg2);
+
+ cmp = strncmp(arg1+4, arg2+4, Min(len1,len2));
+ if (cmp == 0)
+ return (len1
+ else
+ return (cmp < 0);
+}
+
+int32
+bpcharle(char *arg1, char *arg2)
+{
+ int len1, len2;
+
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ len1 = bcTruelen(arg1);
+ len2 = bcTruelen(arg2);
+
+ return(strncmp(arg1+4, arg2+4, Min(len1,len2)) <= 0);
+}
+
+int32
+bpchargt(char *arg1, char *arg2)
+{
+ int len1, len2;
+ int cmp;
+
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ len1 = bcTruelen(arg1);
+ len2 = bcTruelen(arg2);
+
+ cmp = strncmp(arg1+4, arg2+4, Min(len1,len2));
+ if (cmp == 0)
+ return (len1 > len2);
+ else
+ return (cmp > 0);
+}
+
+int32
+bpcharge(char *arg1, char *arg2)
+{
+ int len1, len2;
+
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ len1 = bcTruelen(arg1);
+ len2 = bcTruelen(arg2);
+
+ return(strncmp(arg1+4, arg2+4, Min(len1,len2)) >= 0);
+}
+
+int32
+bpcharcmp(char *arg1, char *arg2)
+{
+ int len1, len2;
+
+ len1 = bcTruelen(arg1);
+ len2 = bcTruelen(arg2);
+
+ return(strncmp(arg1+4, arg2+4, Min(len1,len2)));
+}
+
+/*****************************************************************************
+ * Comparison Functions used for varchar
+ *****************************************************************************/
+
+static int
+vcTruelen(char *arg)
+{
+ char *s = arg + 4;
+ int i;
+ int len;
+
+ len = *(int32*)arg - 4;
+ for(i=0; i < len; i++) {
+ if (*s++ == '\0')
+ break;
+ }
+ return i;
+}
+
+int32
+varchareq(char *arg1, char *arg2)
+{
+ int len1, len2;
+
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ len1 = vcTruelen(arg1);
+ len2 = vcTruelen(arg2);
+
+ if (len1!=len2)
+ return 0;
+
+ return(strncmp(arg1+4, arg2+4, len1) == 0);
+}
+
+int32
+varcharne(char *arg1, char *arg2)
+{
+ int len1, len2;
+
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ len1 = vcTruelen(arg1);
+ len2 = vcTruelen(arg2);
+
+ if (len1!=len2)
+ return 1;
+
+ return(strncmp(arg1+4, arg2+4, len1) != 0);
+}
+
+int32
+varcharlt(char *arg1, char *arg2)
+{
+ int len1, len2;
+ int cmp;
+
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ len1 = vcTruelen(arg1);
+ len2 = vcTruelen(arg2);
+
+ cmp = strncmp(arg1+4, arg2+4, Min(len1,len2));
+ if (cmp == 0)
+ return (len1
+ else
+ return (cmp < 0);
+}
+
+int32
+varcharle(char *arg1, char *arg2)
+{
+ int len1, len2;
+
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ len1 = vcTruelen(arg1);
+ len2 = vcTruelen(arg2);
+
+ return(strncmp(arg1+4, arg2+4, Min(len1,len2)) <= 0);
+}
+
+int32
+varchargt(char *arg1, char *arg2)
+{
+ int len1, len2;
+ int cmp;
+
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ len1 = vcTruelen(arg1);
+ len2 = vcTruelen(arg2);
+
+ cmp = strncmp(arg1+4, arg2+4, Min(len1,len2));
+ if (cmp == 0)
+ return (len1 > len2);
+ else
+ return (cmp > 0);
+}
+
+int32
+varcharge(char *arg1, char *arg2)
+{
+ int len1, len2;
+
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+ len1 = vcTruelen(arg1);
+ len2 = vcTruelen(arg2);
+
+ return(strncmp(arg1+4, arg2+4, Min(len1,len2)) >= 0);
+}
+
+int32
+varcharcmp(char *arg1, char *arg2)
+{
+ int len1, len2;
+
+ len1 = vcTruelen(arg1);
+ len2 = vcTruelen(arg2);
+
+ return(strncmp(arg1+4, arg2+4, Min(len1,len2)));
+}
+
+/*****************************************************************************
+ * Hash functions (modified from hashtext in access/hash/hashfunc.c)
+ *****************************************************************************/
+
+uint32 hashbpchar(struct varlena *key)
+{
+ int keylen;
+ char *keydata;
+ uint32 n;
+ int loop;
+
+ keydata = VARDATA(key);
+ keylen = bcTruelen((char*)key);
+
+#define HASHC n = *keydata++ + 65599 * n
+
+ n = 0;
+ if (keylen > 0) {
+ loop = (keylen + 8 - 1) >> 3;
+
+ switch (keylen & (8 - 1)) {
+ case 0:
+ do { /* All fall throughs */
+ HASHC;
+ case 7:
+ HASHC;
+ case 6:
+ HASHC;
+ case 5:
+ HASHC;
+ case 4:
+ HASHC;
+ case 3:
+ HASHC;
+ case 2:
+ HASHC;
+ case 1:
+ HASHC;
+ } while (--loop);
+ }
+ }
+ return (n);
+}
+
+uint32 hashvarchar(struct varlena *key)
+{
+ int keylen;
+ char *keydata;
+ uint32 n;
+ int loop;
+
+ keydata = VARDATA(key);
+ keylen = vcTruelen((char*)key);
+
+#define HASHC n = *keydata++ + 65599 * n
+
+ n = 0;
+ if (keylen > 0) {
+ loop = (keylen + 8 - 1) >> 3;
+
+ switch (keylen & (8 - 1)) {
+ case 0:
+ do { /* All fall throughs */
+ HASHC;
+ case 7:
+ HASHC;
+ case 6:
+ HASHC;
+ case 5:
+ HASHC;
+ case 4:
+ HASHC;
+ case 3:
+ HASHC;
+ case 2:
+ HASHC;
+ case 1:
+ HASHC;
+ } while (--loop);
+ }
+ }
+ return (n);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * varlena.c--
+ * Functions for the variable-length built-in types.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.1.1.1 1996/07/09 06:22:06 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+
+#include "postgres.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/builtins.h" /* where function declarations go */
+
+/*****************************************************************************
+ * USER I/O ROUTINES *
+ *****************************************************************************/
+
+
+#define VAL(CH) ((CH) - '0')
+#define DIG(VAL) ((VAL) + '0')
+
+/*
+ * byteain - converts from printable representation of byte array
+ *
+ * Non-printable characters must be passed as '\nnn' (octal) and are
+ * converted to internal form. '\' must be passed as '\\'.
+ * elog(WARN, ...) if bad form.
+ *
+ * BUGS:
+ * The input is scaned twice.
+ * The error checking of input is minimal.
+ */
+struct varlena *
+byteain(char *inputText)
+{
+ register char *tp;
+ register char *rp;
+ register int byte;
+ struct varlena *result;
+
+ if (inputText == NULL)
+ elog(WARN, "Bad input string for type bytea");
+
+ for (byte = 0, tp = inputText; *tp != '\0'; byte++)
+ if (*tp++ == '\\')
+ {
+ if (*tp == '\\')
+ tp++;
+ else if (!isdigit(*tp++) ||
+ !isdigit(*tp++) ||
+ !isdigit(*tp++))
+ elog(WARN, "Bad input string for type bytea");
+ }
+ tp = inputText;
+ byte += sizeof(int32); /* varlena? */
+ result = (struct varlena *) palloc(byte);
+ result->vl_len = byte; /* varlena? */
+ rp = result->vl_dat;
+ while (*tp != '\0')
+ if (*tp != '\\' || *++tp == '\\')
+ *rp++ = *tp++;
+ else {
+ byte = VAL(*tp++);
+ byte <<= 3;
+ byte += VAL(*tp++);
+ byte <<= 3;
+ *rp++ = byte + VAL(*tp++);
+ }
+ return(result);
+}
+
+/*
+ * Shoves a bunch of memory pointed at by bytes into varlena.
+ * BUGS: Extremely unportable as things shoved can be string
+ * representations of structs, etc.
+ */
+struct varlena *
+shove_bytes(unsigned char *stuff, int len)
+{
+ struct varlena *result;
+
+ result = (struct varlena *) palloc(len + sizeof(int32));
+ result->vl_len = len;
+ memmove(result->vl_dat,
+ stuff + sizeof(int32),
+ len - sizeof(int32));
+ return(result);
+}
+
+
+
+/*
+ * byteaout - converts to printable representation of byte array
+ *
+ * Non-printable characters are inserted as '\nnn' (octal) and '\' as
+ * '\\'.
+ *
+ * NULL vlena should be an error--returning string with NULL for now.
+ */
+char *
+byteaout(struct varlena *vlena)
+{
+ register char *vp;
+ register char *rp;
+ register int val; /* holds unprintable chars */
+ int i;
+ int len;
+ static char *result;
+
+ if (vlena == NULL) {
+ result = (char *) palloc(2);
+ result[0] = '-';
+ result[1] = '\0';
+ return(result);
+ }
+ vp = vlena->vl_dat;
+ len = 1; /* empty string has 1 char */
+ for (i = vlena->vl_len - sizeof(int32); i != 0; i--, vp++) /* varlena? */
+ if (*vp == '\\')
+ len += 2;
+ else if (isascii(*vp) && isprint(*vp))
+ len++;
+ else
+ len += 4;
+ rp = result = (char *) palloc(len);
+ vp = vlena->vl_dat;
+ for (i = vlena->vl_len - sizeof(int32); i != 0; i--) /* varlena? */
+ if (*vp == '\\') {
+ *vp++;
+ *rp++ = '\\';
+ *rp++ = '\\';
+ } else if (isascii(*vp) && isprint(*vp))
+ *rp++ = *vp++;
+ else {
+ val = *vp++;
+ *rp = '\\';
+ rp += 3;
+ *rp-- = DIG(val & 07);
+ val >>= 3;
+ *rp-- = DIG(val & 07);
+ val >>= 3;
+ *rp = DIG(val & 03);
+ rp += 3;
+ }
+ *rp = '\0';
+ return(result);
+}
+
+
+/*
+ * textin - converts "..." to internal representation
+ */
+struct varlena *
+textin(char *inputText)
+{
+ struct varlena *result;
+ int len;
+
+ if (inputText == NULL)
+ return(NULL);
+ len = strlen(inputText) + VARHDRSZ;
+ result = (struct varlena *) palloc(len);
+ VARSIZE(result) = len;
+ memmove(VARDATA(result), inputText, len - VARHDRSZ);
+ return(result);
+}
+
+/*
+ * textout - converts internal representation to "..."
+ */
+char *
+textout(struct varlena *vlena)
+{
+ int len;
+ char *result;
+
+ if (vlena == NULL) {
+ result = (char *) palloc(2);
+ result[0] = '-';
+ result[1] = '\0';
+ return(result);
+ }
+ len = VARSIZE(vlena) - VARHDRSZ;
+ result = (char *) palloc(len + 1);
+ memmove(result, VARDATA(vlena), len);
+ result[len] = '\0';
+ return(result);
+}
+
+
+/* ========== PUBLIC ROUTINES ========== */
+
+/*
+ * textcat -
+ * takes two text* and returns a text* that is the concatentation of
+ * the two
+ */
+text*
+textcat(text* t1, text* t2)
+{
+ int newlen;
+ char *str1, *str2;
+ text* result;
+
+ if (t1 == NULL) return t2;
+ if (t2 == NULL) return t1;
+
+ /* since t1, and t2 are non-null, str1 and str2 must also be non-null */
+ str1 = textout(t1);
+ str2 = textout(t2);
+ /* we use strlen here to calculate the length because the size fields
+ of t1, t2 may be longer than necessary to hold the string */
+ newlen = strlen(str1) + strlen(str2) + VARHDRSZ;
+ result = (text*)palloc(newlen);
+ strcpy(VARDATA(result), str1);
+ strncat(VARDATA(result), str2, newlen - VARHDRSZ);
+ /* [TRH] Was:
+ strcat(VARDATA(result), str2);
+ which may corrupt the malloc arena due to writing trailing \0. */
+
+ pfree(str1);
+ pfree(str2);
+ return result;
+}
+
+/*
+ * texteq - returns 1 iff arguments are equal
+ * textne - returns 1 iff arguments are not equal
+ */
+int32
+texteq(struct varlena *arg1, struct varlena *arg2)
+{
+ register int len;
+ register char *a1p, *a2p;
+
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) NULL);
+ if ((len = arg1->vl_len) != arg2->vl_len)
+ return((int32) 0);
+ a1p = arg1->vl_dat;
+ a2p = arg2->vl_dat;
+ /*
+ * Varlenas are stored as the total size (data + size variable)
+ * followed by the data. The size variable is an int32 so the
+ * length of the data is the total length less sizeof(int32)
+ */
+ len -= sizeof(int32);
+ while (len-- != 0)
+ if (*a1p++ != *a2p++)
+ return((int32) 0);
+ return((int32) 1);
+}
+
+int32
+textne(struct varlena *arg1, struct varlena *arg2)
+{
+ return((int32) !texteq(arg1, arg2));
+}
+
+int32
+text_lt(struct varlena *arg1, struct varlena *arg2)
+{
+ int len;
+ char *a1p, *a2p;
+
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+
+ a1p = VARDATA(arg1);
+ a2p = VARDATA(arg2);
+
+ if ((len = arg1->vl_len) > arg2->vl_len)
+ len = arg2->vl_len;
+ len -= sizeof(int32);
+
+ while (len != 0 && *a1p == *a2p)
+ {
+ a1p++;
+ a2p++;
+ len--;
+ }
+ if (len)
+ return (int32) (*a1p < *a2p);
+ else
+ return (int32) (arg1->vl_len < arg2->vl_len);
+}
+
+int32
+text_le(struct varlena *arg1, struct varlena *arg2)
+{
+ int len;
+ char *a1p, *a2p;
+
+ if (arg1 == NULL || arg2 == NULL)
+ return((int32) 0);
+
+ a1p = VARDATA(arg1);
+ a2p = VARDATA(arg2);
+
+ if ((len = arg1->vl_len) > arg2->vl_len)
+ len = arg2->vl_len;
+ len -= sizeof(int32); /* varlena! */
+
+ while (len != 0 && *a1p == *a2p)
+ {
+ a1p++;
+ a2p++;
+ len--;
+ }
+ if (len)
+ return (int32) (*a1p < *a2p);
+ else
+ return ((int32) VARSIZE(arg1) <= VARSIZE(arg2));
+}
+
+int32
+text_gt(struct varlena *arg1, struct varlena *arg2)
+{
+ return ((int32) !text_le(arg1, arg2));
+}
+
+int32
+text_ge(struct varlena *arg1, struct varlena *arg2)
+{
+ return ((int32) !text_lt(arg1, arg2));
+}
+
+/*-------------------------------------------------------------
+ * byteaGetSize
+ *
+ * get the number of bytes contained in an instance of type 'bytea'
+ *-------------------------------------------------------------
+ */
+int32
+byteaGetSize(struct varlena *v)
+{
+ register int len;
+
+ len = v->vl_len - sizeof(v->vl_len);
+
+ return(len);
+}
+
+/*-------------------------------------------------------------
+ * byteaGetByte
+ *
+ * this routine treats "bytea" as an array of bytes.
+ * It returns the Nth byte (a number between 0 and 255) or
+ * it dies if the length of this array is less than n.
+ *-------------------------------------------------------------
+ */
+int32
+byteaGetByte(struct varlena *v, int32 n)
+{
+ int len;
+ int byte;
+
+ len = byteaGetSize(v);
+
+ if (n>=len) {
+ elog(WARN, "byteaGetByte: index (=%d) out of range [0..%d]",
+ n,len-1);
+ }
+
+ byte = (unsigned char) (v->vl_dat[n]);
+
+ return((int32) byte);
+}
+
+/*-------------------------------------------------------------
+ * byteaGetBit
+ *
+ * This routine treats a "bytea" type like an array of bits.
+ * It returns the value of the Nth bit (0 or 1).
+ * If 'n' is out of range, it dies!
+ *
+ *-------------------------------------------------------------
+ */
+int32
+byteaGetBit(struct varlena *v, int32 n)
+{
+ int byteNo, bitNo;
+ int byte;
+
+ byteNo = n/8;
+ bitNo = n%8;
+
+ byte = byteaGetByte(v, byteNo);
+
+ if (byte & (1<
+ return((int32)1);
+ } else {
+ return((int32)0);
+ }
+}
+/*-------------------------------------------------------------
+ * byteaSetByte
+ *
+ * Given an instance of type 'bytea' creates a new one with
+ * the Nth byte set to the given value.
+ *
+ *-------------------------------------------------------------
+ */
+struct varlena *
+byteaSetByte(struct varlena *v, int32 n, int32 newByte)
+{
+ int len;
+ struct varlena *res;
+
+ len = byteaGetSize(v);
+
+ if (n>=len) {
+ elog(WARN,
+ "byteaSetByte: index (=%d) out of range [0..%d]",
+ n, len-1);
+ }
+
+ /*
+ * Make a copy of the original varlena.
+ */
+ res = (struct varlena *) palloc(VARSIZE(v));
+ if (res==NULL) {
+ elog(WARN, "byteaSetByte: Out of memory (%d bytes requested)",
+ VARSIZE(v));
+ }
+ memmove((char *)res, (char *)v, VARSIZE(v));
+
+ /*
+ * Now set the byte.
+ */
+ res->vl_dat[n] = newByte;
+
+ return(res);
+}
+
+/*-------------------------------------------------------------
+ * byteaSetBit
+ *
+ * Given an instance of type 'bytea' creates a new one with
+ * the Nth bit set to the given value.
+ *
+ *-------------------------------------------------------------
+ */
+struct varlena *
+byteaSetBit(struct varlena *v, int32 n, int32 newBit)
+{
+ struct varlena *res;
+ int oldByte, newByte;
+ int byteNo, bitNo;
+
+ /*
+ * sanity check!
+ */
+ if (newBit != 0 && newBit != 1) {
+ elog(WARN, "byteaSetByte: new bit must be 0 or 1");
+ }
+
+ /*
+ * get the byte where the bit we want is stored.
+ */
+ byteNo = n / 8;
+ bitNo = n % 8;
+ oldByte = byteaGetByte(v, byteNo);
+
+ /*
+ * calculate the new value for that byte
+ */
+ if (newBit == 0) {
+ newByte = oldByte & (~(1<
+ } else {
+ newByte = oldByte | (1<
+ }
+
+ /*
+ * NOTE: 'byteaSetByte' creates a copy of 'v' & sets the byte.
+ */
+ res = byteaSetByte(v, byteNo, newByte);
+
+ return(res);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * array.h--
+ * Utilities for the new array code. Contain prototypes from the
+ * following files:
+ * utils/adt/arrayfuncs.c
+ * utils/adt/arrayutils.c
+ * utils/adt/chunk.c
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: array.h,v 1.1.1.1 1996/07/09 06:22:01 scrappy Exp $
+ *
+ * NOTES
+ * XXX the data array should be LONGALIGN'd -- notice that the array
+ * allocation code does not allocate the extra space required for this,
+ * even though the array-packing code does the LONGALIGNs.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ARRAY_H
+#define ARRAY_H
+
+#include /* for FILE (XXX should use File) */
+#include "utils/memutils.h"
+
+typedef struct {
+ int size; /* total array size (in bytes) */
+ int ndim; /* # of dimensions */
+ int flags; /* implementation flags */
+} ArrayType;
+
+/*
+ * bitmask of ArrayType flags field:
+ * 1st bit - large object flag
+ * 2nd bit - chunk flag (array is chunked if set)
+ * 3rd,4th,&5th bit - large object type (used only if bit 1 is set)
+ */
+#define ARR_LOB_FLAG (0x1)
+#define ARR_CHK_FLAG (0x2)
+#define ARR_OBJ_MASK (0x1c)
+
+#define ARR_FLAGS(a) ((ArrayType *) a)->flags
+#define ARR_SIZE(a) (((ArrayType *) a)->size)
+
+#define ARR_NDIM(a) (((ArrayType *) a)->ndim)
+#define ARR_NDIM_PTR(a) (&(((ArrayType *) a)->ndim))
+
+#define ARR_IS_LO(a) \
+ (((ArrayType *) a)->flags & ARR_LOB_FLAG)
+#define SET_LO_FLAG(f,a) \
+ (((ArrayType *) a)->flags |= ((f) ? ARR_LOB_FLAG : 0x0))
+
+#define ARR_IS_CHUNKED(a) \
+ (((ArrayType *) a)->flags & ARR_CHK_FLAG)
+#define SET_CHUNK_FLAG(f,a) \
+ (((ArrayType *) a)->flags |= ((f) ? ARR_CHK_FLAG : 0x0))
+
+#define ARR_OBJ_TYPE(a) \
+ ((ARR_FLAGS(a) & ARR_OBJ_MASK) >> 2)
+#define SET_OBJ_TYPE(f,a) \
+ ((ARR_FLAGS(a)&= ~ARR_OBJ_MASK), (ARR_FLAGS(a)|=((f<<2)&ARR_OBJ_MASK)))
+
+/*
+ * ARR_DIMS returns a pointer to an array of array dimensions (number of
+ * elements along the various array axes).
+ *
+ * ARR_LBOUND returns a pointer to an array of array lower bounds.
+ *
+ * That is: if the third axis of an array has elements 5 through 10, then
+ * ARR_DIMS(a)[2] == 6 and ARR_LBOUND[2] == 5.
+ *
+ * Unlike C, the default lower bound is 1.
+ */
+#define ARR_DIMS(a) \
+ ((int *) (((char *) a) + sizeof(ArrayType)))
+#define ARR_LBOUND(a) \
+ ((int *) (((char *) a) + sizeof(ArrayType) + \
+ (sizeof(int) * (((ArrayType *) a)->ndim))))
+
+/*
+ * Returns a pointer to the actual array data.
+ */
+#define ARR_DATA_PTR(a) \
+ (((char *) a) + \
+ DOUBLEALIGN(sizeof(ArrayType) + 2 * (sizeof(int) * (a)->ndim)))
+
+/*
+ * The total array header size for an array of dimension n (in bytes).
+ */
+#define ARR_OVERHEAD(n) \
+ (DOUBLEALIGN(sizeof(ArrayType) + 2 * (n) * sizeof(int)))
+
+/*------------------------------------------------------------------------
+ * Miscellaneous helper definitions and routines for arrayfuncs.c
+ *------------------------------------------------------------------------
+ */
+
+/* #if defined(PORTNAME_irix5) */
+/* #define RETURN_NULL {*isNull = true; return(0); }*/
+/* #else*/ /* PORTNAME_irix5 */
+#define RETURN_NULL {*isNull = true; return(0); }
+/* #endif */ /* PORTNAME_irix5 */
+#define NAME_LEN 30
+#define MAX_BUFF_SIZE (1 << 13)
+
+typedef struct {
+ char lo_name[NAME_LEN];
+ int C[MAXDIM];
+} CHUNK_INFO;
+
+/*
+ * prototypes for functions defined in arrayfuncs.c
+ */
+extern char *array_in(char *string, Oid element_type);
+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,
+ int elmlen, int arraylen, bool *isNull);
+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,
+ int reftype, int elmlen, int arraylen, bool *isNull);
+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 SanityCheckInput(int ndim, int n, int dim[], int lb[], int indx[]);
+extern char *array_seek(char *ptr, int eltsize, int nitems);
+extern int array_read(char *destptr, int eltsize, int nitems, char *srcptr);
+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 arrayutils.c
+ * [these names seem to be too generic. Add prefix for arrays? -- AY]
+ */
+
+extern int GetOffset(int n, int dim[], int lb[], int indx[]);
+extern int getNitems(int n, int a[]);
+extern int compute_size(int st[], int endp[], int n, int base);
+extern void mda_get_offset_values(int n, int dist[], int PC[], int span[]);
+extern void mda_get_range(int n, int span[], int st[], int endp[]);
+extern void mda_get_prod(int n, int range[], int P[]);
+extern int tuple2linear(int n, int tup[], int scale[]);
+extern void array2chunk_coord(int n, int C[], int a_coord[], int c_coord[]);
+extern int next_tuple(int n, int curr[], int span[]);
+
+/*
+ * prototypes for functions defined in chunk.c
+ */
+extern char * _ChunkArray(int fd, FILE *afd, int ndim, int dim[], int baseSize,
+ int *nbytes, char *chunkfile);
+extern int GetChunkSize(FILE *fd, int ndim, int dim[MAXDIM], int baseSize,
+ int d[MAXDIM]);
+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,
+ ArrayType *array, bool *isNull);
+
+
+#endif /* ARRAY_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * bit.h--
+ * Standard bit array definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: bit.h,v 1.1.1.1 1996/07/09 06:22:01 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BIT_H
+#define BIT_H
+
+typedef bits8 *BitArray;
+typedef uint32 BitIndex;
+
+#define BitsPerByte 8
+
+/*
+ * BitArraySetBit --
+ * Sets (to 1) the value of a bit in a bit array.
+ */
+extern void BitArraySetBit(BitArray bitArray, BitIndex bitIndex);
+
+/*
+ * BitArrayClearBit --
+ * Clears (to 0) the value of a bit in a bit array.
+ */
+extern void BitArrayClearBit(BitArray bitArray, BitIndex bitIndex);
+
+/*
+ * BitArrayBitIsSet --
+ * True iff the bit is set (1) in a bit array.
+ */
+extern bool BitArrayBitIsSet(BitArray bitArray, BitIndex bitIndex);
+
+#endif /* BIT_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * builtins.h--
+ * Declarations for operations on built-in types.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: builtins.h,v 1.1.1.1 1996/07/09 06:22:01 scrappy Exp $
+ *
+ * NOTES
+ * This should normally only be included by fmgr.h.
+ * Under no circumstances should it ever be included before
+ * including fmgr.h!
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BUILTINS_H
+#define BUILTINS_H
+
+#include "postgres.h"
+
+#include "storage/itemptr.h"
+
+#include "storage/large_object.h"
+
+#include "utils/geo-decls.h"
+
+/*
+ * Defined in adt/
+ */
+/* bool.c */
+extern int32 boolin(char *b);
+extern char *boolout(long b);
+extern int32 booleq(int8 arg1, int8 arg2);
+extern int32 boolne(int8 arg1, int8 arg2);
+
+/* char.c */
+extern int32 charin(char *ch);
+extern char *charout(int32 ch);
+extern int32 cidin(char *s);
+extern char *cidout(int32 c);
+extern char *char16in(char *s);
+extern char *char16out(char *s);
+extern int32 chareq(int8 arg1, int8 arg2);
+extern int32 charne(int8 arg1, int8 arg2);
+extern int32 charlt(int8 arg1, int8 arg2);
+extern int32 charle(int8 arg1, int8 arg2);
+extern int32 chargt(int8 arg1, int8 arg2);
+extern int32 charge(int8 arg1, int8 arg2);
+extern int8 charpl(int8 arg1, int8 arg2);
+extern int8 charmi(int8 arg1, int8 arg2);
+extern int8 charmul(int8 arg1, int8 arg2);
+extern int8 chardiv(int8 arg1, int8 arg2);
+extern int32 cideq(int8 arg1, int8 arg2);
+extern int32 char16eq(char *arg1, char *arg2);
+extern int32 char16ne(char *arg1, char *arg2);
+extern int32 char16lt(char *arg1, char *arg2);
+extern int32 char16le(char *arg1, char *arg2);
+extern int32 char16gt(char *arg1, char *arg2);
+extern int32 char16ge(char *arg1, char *arg2);
+extern uint16 char2in(char *s);
+extern char *char2out(uint16 s);
+extern int32 char2eq(uint16 a, uint16 b);
+extern int32 char2ne(uint16 a, uint16 b);
+extern int32 char2lt(uint16 a, uint16 b);
+extern int32 char2le(uint16 a, uint16 b);
+extern int32 char2gt(uint16 a, uint16 b);
+extern int32 char2ge(uint16 a, uint16 b);
+extern int32 char2cmp(uint16 a, uint16 b);
+extern uint32 char4in(char *s);
+extern char *char4out(uint32 s);
+extern int32 char4eq(uint32 a, uint32 b);
+extern int32 char4ne(uint32 a, uint32 b);
+extern int32 char4lt(uint32 a, uint32 b);
+extern int32 char4le(uint32 a, uint32 b);
+extern int32 char4gt(uint32 a, uint32 b);
+extern int32 char4ge(uint32 a, uint32 b);
+extern int32 char4cmp(uint32 a, uint32 b);
+extern char *char8in(char *s);
+extern char *char8out(char *s);
+extern int32 char8eq(char *arg1, char *arg2);
+extern int32 char8ne(char *arg1, char *arg2);
+extern int32 char8lt(char *arg1, char *arg2);
+extern int32 char8le(char *arg1, char *arg2);
+extern int32 char8gt(char *arg1, char *arg2);
+extern int32 char8ge(char *arg1, char *arg2);
+extern int32 char8cmp(char *arg1, char *arg2);
+
+/* int.c */
+extern int32 int2in(char *num);
+extern char *int2out(int16 sh);
+extern int16 *int28in(char *shs);
+extern char *int28out(int16 (*shs)[]);
+extern int32 *int44in(char *input_string);
+extern char *int44out(int32 an_array[]);
+extern int32 int4in(char *num);
+extern char *int4out(int32 l);
+extern int32 i2toi4(int16 arg1);
+extern int16 i4toi2(int32 arg1);
+extern int32 int4eq(int32 arg1, int32 arg2);
+extern int32 int4ne(int32 arg1, int32 arg2);
+extern int32 int4lt(int32 arg1, int32 arg2);
+extern int32 int4le(int32 arg1, int32 arg2);
+extern int32 int4gt(int32 arg1, int32 arg2);
+extern int32 int4ge(int32 arg1, int32 arg2);
+extern int32 int2eq(int16 arg1, int16 arg2);
+extern int32 int2ne(int16 arg1, int16 arg2);
+extern int32 int2lt(int16 arg1, int16 arg2);
+extern int32 int2le(int16 arg1, int16 arg2);
+extern int32 int2gt(int16 arg1, int16 arg2);
+extern int32 int2ge(int16 arg1, int16 arg2);
+extern int32 int24eq(int32 arg1, int32 arg2);
+extern int32 int24ne(int32 arg1, int32 arg2);
+extern int32 int24lt(int32 arg1, int32 arg2);
+extern int32 int24le(int32 arg1, int32 arg2);
+extern int32 int24gt(int32 arg1, int32 arg2);
+extern int32 int24ge(int32 arg1, int32 arg2);
+extern int32 int42eq(int32 arg1, int32 arg2);
+extern int32 int42ne(int32 arg1, int32 arg2);
+extern int32 int42lt(int32 arg1, int32 arg2);
+extern int32 int42le(int32 arg1, int32 arg2);
+extern int32 int42gt(int32 arg1, int32 arg2);
+extern int32 int42ge(int32 arg1, int32 arg2);
+extern int32 keyfirsteq(int16 *arg1, int16 arg2);
+extern int32 int4um(int32 arg);
+extern int32 int4pl(int32 arg1, int32 arg2);
+extern int32 int4mi(int32 arg1, int32 arg2);
+extern int32 int4mul(int32 arg1, int32 arg2);
+extern int32 int4div(int32 arg1, int32 arg2);
+extern int32 int4inc(int32 arg);
+extern int16 int2um(int16 arg);
+extern int16 int2pl(int16 arg1, int16 arg2);
+extern int16 int2mi(int16 arg1, int16 arg2);
+extern int16 int2mul(int16 arg1, int16 arg2);
+extern int16 int2div(int16 arg1, int16 arg2);
+extern int16 int2inc(int16 arg);
+extern int32 int24pl(int32 arg1, int32 arg2);
+extern int32 int24mi(int32 arg1, int32 arg2);
+extern int32 int24mul(int32 arg1, int32 arg2);
+extern int32 int24div(int32 arg1, int32 arg2);
+extern int32 int42pl(int32 arg1, int32 arg2);
+extern int32 int42mi(int32 arg1, int32 arg2);
+extern int32 int42mul(int32 arg1, int32 arg2);
+extern int32 int42div(int32 arg1, int32 arg2);
+extern int32 int4mod(int32 arg1, int32 arg2);
+extern int32 int2mod(int16 arg1, int16 arg2);
+extern int32 int24mod(int32 arg1, int32 arg2);
+extern int32 int42mod(int32 arg1, int32 arg2);
+extern int32 int4fac(int32 arg1);
+extern int32 int2fac(int16 arg1);
+extern int16 int2larger(int16 arg1, int16 arg2);
+extern int16 int2smaller(int16 arg1, int16 arg2);
+extern int32 int4larger(int32 arg1, int32 arg2);
+extern int32 int4smaller(int32 arg1, int32 arg2);
+
+/* name.c */
+extern NameData *namein(char *s);
+extern char *nameout(NameData *s);
+extern int32 nameeq(NameData *arg1, NameData *arg2);
+extern int32 namene(NameData *arg1, NameData *arg2);
+extern int32 namelt(NameData *arg1, NameData *arg2);
+extern int32 namele(NameData *arg1, NameData *arg2);
+extern int32 namegt(NameData *arg1, NameData *arg2);
+extern int32 namege(NameData *arg1, NameData *arg2);
+extern int namecmp(Name n1, Name n2);
+extern int namecpy(Name n1, Name n2);
+extern int namecat(Name n1, Name n2);
+extern int namestrcpy(Name name, char *str);
+extern int namestrcat(Name name, char *str);
+extern int namestrcmp(Name name, char *str);
+extern uint32 NameComputeLength(Name name);
+
+/* numutils.c */
+/* XXX hack. HP-UX has a ltoa (with different arguments) already. */
+#ifdef PORTNAME_hpux
+#define ltoa pg_ltoa
+#endif /* PORTNAME_hpux */
+extern int32 pg_atoi(char *s, int size, int c);
+extern void itoa(int i, char *a);
+extern void ltoa(int32 l, char *a);
+extern int ftoa(double value, char *ascii, int width, int prec1, char format);
+extern int atof1(char *str, double *val);
+
+/*
+ * Per-opclass comparison functions for new btrees. These are
+ * stored in pg_amproc and defined in nbtree/
+ */
+extern int32 btint2cmp();
+extern int32 btint4cmp();
+extern int32 btint24cmp();
+extern int32 btint42cmp();
+extern int32 btfloat4cmp();
+extern int32 btfloat8cmp();
+extern int32 btoidcmp();
+extern int32 btabstimecmp();
+extern int32 btcharcmp();
+extern int32 btchar16cmp();
+extern int32 bttextcmp();
+
+/*
+ * RTree code.
+ * Defined in access/index-rtree/
+ */
+extern char *rtinsert();
+extern char *rtdelete();
+extern char *rtgettuple();
+extern char *rtbeginscan();
+extern void rtendscan();
+extern void rtreebuild();
+extern void rtmarkpos();
+extern void rtrestrpos();
+extern void rtrescan();
+extern void rtbuild();
+
+/* support routines for the rtree access method, by opclass */
+extern BOX *rt_box_union();
+extern BOX *rt_box_inter();
+extern float *rt_box_size();
+extern float *rt_bigbox_size();
+extern float *rt_poly_size();
+extern POLYGON *rt_poly_union();
+extern POLYGON *rt_poly_inter();
+
+/* projection utilities */
+/* extern char *GetAttributeByName();
+ extern char *GetAttributeByNum(); ,
+ in executor/executor.h*/
+
+
+extern int32 pqtest();
+
+/* arrayfuncs.c */
+#include "utils/array.h"
+
+/* date.c */
+extern int32 reltimein(char *timestring);
+extern char *reltimeout(int32 timevalue);
+extern TimeInterval tintervalin(char *intervalstr);
+extern char *tintervalout(TimeInterval interval);
+extern TimeInterval mktinterval(AbsoluteTime t1, AbsoluteTime t2);
+extern AbsoluteTime timepl(AbsoluteTime t1, RelativeTime t2);
+extern AbsoluteTime timemi(AbsoluteTime t1, RelativeTime t2);
+/* extern RelativeTime abstimemi(AbsoluteTime t1, AbsoluteTime t2); static*/
+extern int ininterval(AbsoluteTime t, TimeInterval interval);
+extern RelativeTime intervalrel(TimeInterval interval);
+extern AbsoluteTime timenow(void);
+extern int32 reltimeeq(RelativeTime t1, RelativeTime t2);
+extern int32 reltimene(RelativeTime t1, RelativeTime t2);
+extern int32 reltimelt(RelativeTime t1, RelativeTime t2);
+extern int32 reltimegt(RelativeTime t1, RelativeTime t2);
+extern int32 reltimele(RelativeTime t1, RelativeTime t2);
+extern int32 reltimege(RelativeTime t1, RelativeTime t2);
+extern int32 intervaleq(TimeInterval i1, TimeInterval i2);
+extern int32 intervalleneq(TimeInterval i, RelativeTime t);
+extern int32 intervallenne(TimeInterval i, RelativeTime t);
+extern int32 intervallenlt(TimeInterval i, RelativeTime t);
+extern int32 intervallengt(TimeInterval i, RelativeTime t);
+extern int32 intervallenle(TimeInterval i, RelativeTime t);
+extern int32 intervallenge(TimeInterval i, RelativeTime t);
+extern int32 intervalct(TimeInterval i1, TimeInterval i2);
+extern int32 intervalov(TimeInterval i1, TimeInterval i2);
+extern AbsoluteTime intervalstart(TimeInterval i);
+extern AbsoluteTime intervalend(TimeInterval i);
+extern int isreltime(char *timestring, int *sign, long *quantity, int *unitnr);
+
+/* dt.c */
+extern int32 dtin(char *datetime);
+extern char *dtout(int32 datetime);
+
+/* filename.c */
+extern char *filename_in(char *file);
+extern char *filename_out(char *s);
+
+/* float.c */
+extern float32 float4in(char *num);
+extern char *float4out(float32 num);
+extern float64 float8in(char *num);
+extern char *float8out(float64 num);
+extern float32 float4abs(float32 arg1);
+extern float32 float4um(float32 arg1);
+extern float32 float4larger(float32 arg1, float32 arg2);
+extern float32 float4smaller(float32 arg1, float32 arg2);
+extern float64 float8abs(float64 arg1);
+extern float64 float8um(float64 arg1);
+extern float64 float8larger(float64 arg1, float64 arg2);
+extern float64 float8smaller(float64 arg1, float64 arg2);
+extern float32 float4pl(float32 arg1, float32 arg2);
+extern float32 float4mi(float32 arg1, float32 arg2);
+extern float32 float4mul(float32 arg1, float32 arg2);
+extern float32 float4div(float32 arg1, float32 arg2);
+extern float32 float4inc(float32 arg1);
+extern float64 float8pl(float64 arg1, float64 arg2);
+extern float64 float8mi(float64 arg1, float64 arg2);
+extern float64 float8mul(float64 arg1, float64 arg2);
+extern float64 float8div(float64 arg1, float64 arg2);
+extern float64 float8inc(float64 arg1);
+extern long float4eq(float32 arg1, float32 arg2);
+extern long float4ne(float32 arg1, float32 arg2);
+extern long float4lt(float32 arg1, float32 arg2);
+extern long float4le(float32 arg1, float32 arg2);
+extern long float4gt(float32 arg1, float32 arg2);
+extern long float4ge(float32 arg1, float32 arg2);
+extern long float8eq(float64 arg1, float64 arg2);
+extern long float8ne(float64 arg1, float64 arg2);
+extern long float8lt(float64 arg1, float64 arg2);
+extern long float8le(float64 arg1, float64 arg2);
+extern long float8gt(float64 arg1, float64 arg2);
+extern long float8ge(float64 arg1, float64 arg2);
+extern float64 ftod(float32 num);
+extern float32 dtof(float64 num);
+extern float64 dround(float64 arg1);
+extern float64 dtrunc(float64 arg1);
+extern float64 dsqrt(float64 arg1);
+extern float64 dcbrt(float64 arg1);
+extern float64 dpow(float64 arg1, float64 arg2);
+extern float64 dexp(float64 arg1);
+extern float64 dlog1(float64 arg1);
+extern float64 float48pl(float32 arg1, float64 arg2);
+extern float64 float48mi(float32 arg1, float64 arg2);
+extern float64 float48mul(float32 arg1, float64 arg2);
+extern float64 float48div(float32 arg1, float64 arg2);
+extern float64 float84pl(float64 arg1, float32 arg2);
+extern float64 float84mi(float64 arg1, float32 arg2);
+extern float64 float84mul(float64 arg1, float32 arg2);
+extern float64 float84div(float64 arg1, float32 arg2);
+extern long float48eq(float32 arg1, float64 arg2);
+extern long float48ne(float32 arg1, float64 arg2);
+extern long float48lt(float32 arg1, float64 arg2);
+extern long float48le(float32 arg1, float64 arg2);
+extern long float48gt(float32 arg1, float64 arg2);
+extern long float48ge(float32 arg1, float64 arg2);
+extern long float84eq(float64 arg1, float32 arg2);
+extern long float84ne(float64 arg1, float32 arg2);
+extern long float84lt(float64 arg1, float32 arg2);
+extern long float84le(float64 arg1, float32 arg2);
+extern long float84gt(float64 arg1, float32 arg2);
+extern long float84ge(float64 arg1, float32 arg2);
+
+/* geo-ops.c, geo-selfuncs.c */
+#include "utils/geo-decls.h"
+
+/* misc.c */
+extern bool NullValue(Datum value, bool *isNull);
+extern bool NonNullValue(Datum value, bool *isNull);
+extern int32 userfntest(int i);
+
+/* not_in.c */
+extern bool int4notin(int16 not_in_arg, char *relation_and_attr);
+extern bool oidnotin(Oid the_oid, char *compare);
+extern int my_varattno(Relation rd, char *a);
+
+/* oid.c */
+extern Oid *oid8in(char *oidString);
+extern char *oid8out(Oid (*oidArray)[]);
+extern Oid oidin(char *s);
+extern char *oidout(Oid o);
+extern int32 oideq(Oid arg1, Oid arg2);
+extern int32 oidne(Oid arg1, Oid arg2);
+extern int32 oid8eq(Oid arg1[], Oid arg2[]);
+
+/* regexp.c */
+extern bool char2regexeq(uint16 arg1, struct varlena *p);
+extern bool char2regexne(uint16 arg1, struct varlena *p);
+extern bool char4regexeq(uint32 arg1, struct varlena *p);
+extern bool char4regexne(uint32 arg1, struct varlena *p);
+extern bool char8regexeq(char *s, struct varlena *p);
+extern bool char8regexne(char *s, struct varlena *p);
+extern bool char16regexeq(char *s, struct varlena *p);
+extern bool char16regexne(char *s, struct varlena *p);
+extern bool textregexeq(struct varlena *s, struct varlena *p);
+extern bool textregexne(struct varlena *s, struct varlena *p);
+extern bool char2icregexeq(uint16 arg1, struct varlena *p);
+extern bool char2icregexne(uint16 arg1, struct varlena *p);
+extern bool char4icregexeq(uint32 arg1, struct varlena *p);
+extern bool char4icregexne(uint32 arg1, struct varlena *p);
+extern bool char8icregexeq(char *s, struct varlena *p);
+extern bool char8icregexne(char *s, struct varlena *p);
+extern bool char16icregexeq(char *s, struct varlena *p);
+extern bool char16icregexne(char *s, struct varlena *p);
+extern bool nameicregexeq(NameData *s, struct varlena *p);
+extern bool nameicregexne(NameData *s, struct varlena *p);
+extern bool texticregexeq(struct varlena *s, struct varlena *p);
+extern bool texticregexne(struct varlena *s, struct varlena *p);
+
+
+/* regproc.c */
+extern int32 regprocin(char *proname);
+extern char *regprocout(RegProcedure proid);
+extern Oid RegprocToOid(RegProcedure rp);
+
+/* selfuncs.c */
+extern float64 eqsel(Oid opid, Oid relid, AttrNumber attno, char *value, int32 flag);
+extern float64 neqsel(Oid opid, Oid relid, AttrNumber attno, char *value, int32 flag);
+extern float64 intltsel(Oid opid, Oid relid, AttrNumber attno, int32 value, int32 flag);
+extern float64 intgtsel(Oid opid, Oid relid, AttrNumber attno, int32 value, int32 flag);
+extern float64 eqjoinsel(Oid opid, Oid relid1, AttrNumber attno1, Oid relid2, AttrNumber attno2);
+extern float64 neqjoinsel(Oid opid, Oid relid1, AttrNumber attno1, Oid relid2, AttrNumber attno2);
+extern float64 intltjoinsel(Oid opid, Oid relid1, AttrNumber attno1, Oid relid2, AttrNumber attno2);
+extern float64 intgtjoinsel(Oid opid, Oid relid1, AttrNumber attno1, Oid relid2, AttrNumber attno2);
+extern float64 btreesel(Oid operatorOid, Oid indrelid, AttrNumber attributeNumber, char *constValue, int32 constFlag, int32 nIndexKeys, Oid indexrelid);
+extern float64 btreenpage(Oid operatorOid, Oid indrelid, AttrNumber attributeNumber, char *constValue, int32 constFlag, int32 nIndexKeys, Oid indexrelid);
+extern float64 hashsel(Oid operatorOid, Oid indrelid, AttrNumber attributeNumber, char *constValue, int32 constFlag, int32 nIndexKeys, Oid indexrelid);
+extern float64 hashnpage(Oid operatorOid, Oid indrelid, AttrNumber attributeNumber, char *constValue, int32 constFlag, int32 nIndexKeys, Oid indexrelid);
+extern float64 rtsel(Oid operatorOid, Oid indrelid, AttrNumber attributeNumber, char *constValue, int32 constFlag, int32 nIndexKeys, Oid indexrelid);
+extern float64 rtnpage(Oid operatorOid, Oid indrelid, AttrNumber attributeNumber, char *constValue, int32 constFlag, int32 nIndexKeys, Oid indexrelid);
+
+/* tid.c */
+extern ItemPointer tidin(char *str);
+extern char *tidout(ItemPointer itemPtr);
+
+/* varlena.c */
+extern struct varlena *byteain(char *inputText);
+extern struct varlena *shove_bytes(unsigned char *stuff, int len);
+extern char *byteaout(struct varlena *vlena);
+extern struct varlena *textin(char *inputText);
+extern char *textout(struct varlena *vlena);
+extern int32 texteq(struct varlena *arg1, struct varlena *arg2);
+extern int32 textne(struct varlena *arg1, struct varlena *arg2);
+extern int32 text_lt(struct varlena *arg1, struct varlena *arg2);
+extern int32 text_le(struct varlena *arg1, struct varlena *arg2);
+extern int32 text_gt(struct varlena *arg1, struct varlena *arg2);
+extern int32 text_ge(struct varlena *arg1, struct varlena *arg2);
+extern int32 byteaGetSize(struct varlena *v);
+extern int32 byteaGetByte(struct varlena *v, int32 n);
+extern int32 byteaGetBit(struct varlena *v, int32 n);
+extern struct varlena *byteaSetByte(struct varlena *v, int32 n, int32 newByte);
+extern struct varlena *byteaSetBit(struct varlena *v, int32 n, int32 newBit);
+
+/* acl.c */
+#include "utils/acl.h"
+
+#endif /* BUILTINS_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for utils/cache
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/utils/cache/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:22:06 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= catcache.c inval.c rel.c relcache.c syscache.c lsyscache.c fcache.c
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * catcache.c--
+ * System catalog cache for tuples matching a key.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.1.1.1 1996/07/09 06:22:06 scrappy Exp $
+ *
+ * Notes:
+ * XXX This needs to use exception.h to handle recovery when
+ * an abort occurs during DisableCache.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "postgres.h"
+#include "access/heapam.h"
+#include "access/genam.h"
+#include "utils/builtins.h"
+#include "utils/tqual.h"
+#include "storage/bufpage.h"
+#include "access/valid.h"
+#include "miscadmin.h"
+#include "utils/portal.h"
+#include "utils/catcache.h"
+#include "fmgr.h" /* for F_BOOLEQ, etc. DANGER */
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/mcxt.h"
+#include "utils/rel.h"
+#include "catalog/pg_type.h" /* for OID of int28 type */
+#include "lib/dllist.h"
+
+/* ----------------
+ * variables, macros and other stuff
+ *
+ * note CCSIZE allocates 51 buckets .. one was already allocated in
+ * the catcache structure.
+ * ----------------
+ */
+
+#ifdef CACHEDEBUG
+#define CACHE1_elog(a,b) elog(a,b)
+#define CACHE2_elog(a,b,c) elog(a,b,c)
+#define CACHE3_elog(a,b,c,d) elog(a,b,c,d)
+#define CACHE4_elog(a,b,c,d,e) elog(a,b,c,d,e)
+#define CACHE5_elog(a,b,c,d,e,f) elog(a,b,c,d,e,f)
+#define CACHE6_elog(a,b,c,d,e,f,g) elog(a,b,c,d,e,f,g)
+#else
+#define CACHE1_elog(a,b)
+#define CACHE2_elog(a,b,c)
+#define CACHE3_elog(a,b,c,d)
+#define CACHE4_elog(a,b,c,d,e)
+#define CACHE5_elog(a,b,c,d,e,f)
+#define CACHE6_elog(a,b,c,d,e,f,g)
+#endif
+
+CatCache *Caches = NULL;
+GlobalMemory CacheCxt;
+
+static int DisableCache;
+
+/* ----------------
+ * EQPROC is used in CatalogCacheInitializeCache
+ * XXX this should be replaced by catalog lookups soon
+ * ----------------
+ */
+static long eqproc[] = {
+ F_BOOLEQ, 0l, F_CHAREQ, F_CHAR16EQ, 0l,
+ F_INT2EQ, F_KEYFIRSTEQ, F_INT4EQ, 0l, F_TEXTEQ,
+ F_OIDEQ, 0l, 0l, 0l, F_OID8EQ
+};
+
+#define EQPROC(SYSTEMTYPEOID) eqproc[(SYSTEMTYPEOID)-16]
+
+/* ----------------------------------------------------------------
+ * internal support functions
+ * ----------------------------------------------------------------
+ */
+/* --------------------------------
+ * CatalogCacheInitializeCache
+ * --------------------------------
+ */
+#ifdef CACHEDEBUG
+#define CatalogCacheInitializeCache_DEBUG1 \
+ elog(DEBUG, "CatalogCacheInitializeCache: cache @%08lx", cache); \
+ if (relation) \
+ elog(DEBUG, "CatalogCacheInitializeCache: called w/relation(inval)"); \
+ else \
+ elog(DEBUG, "CatalogCacheInitializeCache: called w/relname %s", \
+ cache->cc_relname)
+#define CatalogCacheInitializeCache_DEBUG2 \
+ if (cache->cc_key[i] > 0) { \
+ elog(DEBUG, "CatalogCacheInitializeCache: load %d/%d w/%d, %d", \
+ i+1, cache->cc_nkeys, cache->cc_key[i], \
+ relation->rd_att->attrs[cache->cc_key[i] - 1]->attlen); \
+ } else { \
+ elog(DEBUG, "CatalogCacheInitializeCache: load %d/%d w/%d", \
+ i+1, cache->cc_nkeys, cache->cc_key[i]); \
+ }
+#else
+#define CatalogCacheInitializeCache_DEBUG1
+#define CatalogCacheInitializeCache_DEBUG2
+#endif
+
+void
+CatalogCacheInitializeCache(struct catcache *cache,
+ Relation relation)
+{
+ MemoryContext oldcxt;
+ short didopen = 0;
+ short i;
+ TupleDesc tupdesc;
+
+ CatalogCacheInitializeCache_DEBUG1;
+
+ /* ----------------
+ * first switch to the cache context so our allocations
+ * do not vanish at the end of a transaction
+ * ----------------
+ */
+ if (!CacheCxt)
+ CacheCxt = CreateGlobalMemory("Cache");
+ oldcxt = MemoryContextSwitchTo((MemoryContext)CacheCxt);
+
+ /* ----------------
+ * If no relation was passed we must open it to get access to
+ * its fields. If one of the other caches has already opened
+ * it we use heap_open() instead of heap_openr()
+ * ----------------
+ */
+ if (! RelationIsValid(relation)) {
+ struct catcache *cp;
+ /* ----------------
+ * scan the caches to see if any other cache has opened the relation
+ * ----------------
+ */
+ for (cp = Caches; cp; cp = cp->cc_next) {
+ if (strncmp(cp->cc_relname, cache->cc_relname, NAMEDATALEN) == 0) {
+ if (cp->relationId != InvalidOid)
+ break;
+ }
+ }
+
+ /* ----------------
+ * open the relation by name or by id
+ * ----------------
+ */
+ if (cp)
+ relation = heap_open(cp->relationId);
+ else
+ {
+ relation = heap_openr(cache->cc_relname);
+ }
+
+ didopen = 1;
+ }
+
+ /* ----------------
+ * initialize the cache's relation id
+ * ----------------
+ */
+ Assert(RelationIsValid(relation));
+ cache->relationId = RelationGetRelationId(relation);
+ tupdesc = cache->cc_tupdesc = RelationGetTupleDescriptor(relation);
+
+ CACHE3_elog(DEBUG, "CatalogCacheInitializeCache: relid %d, %d keys",
+ cache->relationId, cache->cc_nkeys);
+
+ /* ----------------
+ * initialize cache's key information
+ * ----------------
+ */
+ for (i = 0; i < cache->cc_nkeys; ++i) {
+ CatalogCacheInitializeCache_DEBUG2;
+
+ if (cache->cc_key[i] > 0) {
+
+ /*
+ * Yoiks. The implementation of the hashing code and the
+ * implementation of int28's are at loggerheads. The right
+ * thing to do is to throw out the implementation of int28's
+ * altogether; until that happens, we do the right thing here
+ * to guarantee that the hash key generator doesn't try to
+ * dereference an int2 by mistake.
+ */
+
+ if (tupdesc->attrs[cache->cc_key[i]-1]->atttypid == INT28OID)
+ cache->cc_klen[i] = sizeof (short);
+ else
+ cache->cc_klen[i] = tupdesc->attrs[cache->cc_key[i]-1]->attlen;
+
+ cache->cc_skey[i].sk_procedure =
+ EQPROC(tupdesc->attrs[cache->cc_key[i]-1]->atttypid);
+
+ fmgr_info(cache->cc_skey[i].sk_procedure,
+ (func_ptr *) &cache->cc_skey[i].sk_func,
+ (int *) &cache->cc_skey[i].sk_nargs);
+
+ CACHE5_elog(DEBUG, "CatalogCacheInit %16s %d %d %x",
+ &relation->rd_rel->relname,
+ i,
+ tupdesc->attrs[ cache->cc_key[i]-1 ]->attlen,
+ cache);
+ }
+ }
+
+ /* ----------------
+ * close the relation if we opened it
+ * ----------------
+ */
+ if (didopen)
+ heap_close(relation);
+
+ /* ----------------
+ * initialize index information for the cache. this
+ * should only be done once per cache.
+ * ----------------
+ */
+ if (cache->cc_indname != NULL && cache->indexId == InvalidOid)
+ {
+ if (RelationGetRelationTupleForm(relation)->relhasindex)
+ {
+ /*
+ * If the index doesn't exist we are in trouble.
+ */
+ relation = index_openr( cache->cc_indname);
+ Assert(relation);
+ cache->indexId = RelationGetRelationId(relation);
+ index_close(relation);
+ }
+ else
+ cache->cc_indname = NULL;
+ }
+
+ /* ----------------
+ * return to the proper memory context
+ * ----------------
+ */
+ MemoryContextSwitchTo(oldcxt);
+}
+
+/* --------------------------------
+ * CatalogCacheSetId
+ *
+ * XXX temporary function
+ * --------------------------------
+ */
+void
+CatalogCacheSetId(CatCache *cacheInOutP, int id)
+{
+ Assert(id == InvalidCatalogCacheId || id >= 0);
+ cacheInOutP->id = id;
+}
+
+/* ----------------
+ * comphash --
+ * Compute a hash value, somehow.
+ *
+ * XXX explain algorithm here.
+ *
+ * l is length of the attribute value, v
+ * v is the attribute value ("Datum")
+ * ----------------
+ */
+long
+comphash(long l, register char *v)
+{
+ long i;
+ NameData n;
+
+ CACHE3_elog(DEBUG, "comphash (%d,%x)", l, v);
+
+ switch (l) {
+ case 1:
+ case 2:
+ case 4:
+ return((long) v);
+ }
+
+ if (l == NAMEDATALEN) {
+ /* if it's a name, make sure that the values
+ are null-padded.
+
+ Note that this other fixed-length types can also have
+ the same typelen so this may break them - XXX
+ */
+ namestrcpy(&n,v);
+ v = n.data;
+ } else
+ if (l < 0)
+ l = VARSIZE(v);
+
+ i = 0;
+ while (l--) {
+ i += *v++;
+ }
+ return(i);
+}
+
+/* --------------------------------
+ * CatalogCacheComputeHashIndex
+ * --------------------------------
+ */
+Index
+CatalogCacheComputeHashIndex(struct catcache *cacheInP)
+{
+ Index hashIndex;
+ hashIndex = 0x0;
+ CACHE6_elog(DEBUG,"CatalogCacheComputeHashIndex %s %d %d %d %x",
+ cacheInP->cc_relname,
+ cacheInP->cc_nkeys,
+ cacheInP->cc_klen[0],
+ cacheInP->cc_klen[1],
+ cacheInP);
+
+ switch (cacheInP->cc_nkeys) {
+ case 4:
+ hashIndex ^= comphash(cacheInP->cc_klen[3],
+ (char*)cacheInP->cc_skey[3].sk_argument) << 9;
+ /* FALLTHROUGH */
+ case 3:
+ hashIndex ^= comphash(cacheInP->cc_klen[2],
+ (char*)cacheInP->cc_skey[2].sk_argument) << 6;
+ /* FALLTHROUGH */
+ case 2:
+ hashIndex ^= comphash(cacheInP->cc_klen[1],
+ (char*)cacheInP->cc_skey[1].sk_argument) << 3;
+ /* FALLTHROUGH */
+ case 1:
+ hashIndex ^= comphash(cacheInP->cc_klen[0],
+ (char*)cacheInP->cc_skey[0].sk_argument);
+ break;
+ default:
+ elog(FATAL, "CCComputeHashIndex: %d cc_nkeys", cacheInP->cc_nkeys);
+ break;
+ }
+ hashIndex %= cacheInP->cc_size;
+ return (hashIndex);
+}
+
+/* --------------------------------
+ * CatalogCacheComputeTupleHashIndex
+ * --------------------------------
+ */
+Index
+CatalogCacheComputeTupleHashIndex(struct catcache *cacheInOutP,
+ Relation relation,
+ HeapTuple tuple)
+{
+ bool isNull = '\0';
+ if (cacheInOutP->relationId == InvalidOid)
+ CatalogCacheInitializeCache(cacheInOutP, relation);
+ switch (cacheInOutP->cc_nkeys) {
+ case 4:
+ cacheInOutP->cc_skey[3].sk_argument =
+ (cacheInOutP->cc_key[3] == ObjectIdAttributeNumber)
+ ? (Datum)tuple->t_oid
+ : (Datum)fastgetattr(tuple,
+ cacheInOutP->cc_key[3],
+ RelationGetTupleDescriptor(relation),
+ &isNull);
+ Assert(!isNull);
+ /* FALLTHROUGH */
+ case 3:
+ cacheInOutP->cc_skey[2].sk_argument =
+ (cacheInOutP->cc_key[2] == ObjectIdAttributeNumber)
+ ? (Datum)tuple->t_oid
+ : (Datum)fastgetattr(tuple,
+ cacheInOutP->cc_key[2],
+ RelationGetTupleDescriptor(relation),
+ &isNull);
+ Assert(!isNull);
+ /* FALLTHROUGH */
+ case 2:
+ cacheInOutP->cc_skey[1].sk_argument =
+ (cacheInOutP->cc_key[1] == ObjectIdAttributeNumber)
+ ? (Datum)tuple->t_oid
+ : (Datum)fastgetattr(tuple,
+ cacheInOutP->cc_key[1],
+ RelationGetTupleDescriptor(relation),
+ &isNull);
+ Assert(!isNull);
+ /* FALLTHROUGH */
+ case 1:
+ cacheInOutP->cc_skey[0].sk_argument =
+ (cacheInOutP->cc_key[0] == ObjectIdAttributeNumber)
+ ? (Datum)tuple->t_oid
+ : (Datum)fastgetattr(tuple,
+ cacheInOutP->cc_key[0],
+ RelationGetTupleDescriptor(relation),
+ &isNull);
+ Assert(!isNull);
+ break;
+ default:
+ elog(FATAL, "CCComputeTupleHashIndex: %d cc_nkeys",
+ cacheInOutP->cc_nkeys
+ );
+ break;
+ }
+
+ return
+ CatalogCacheComputeHashIndex(cacheInOutP);
+}
+
+/* --------------------------------
+ * CatCacheRemoveCTup
+ * --------------------------------
+ */
+void
+CatCacheRemoveCTup(CatCache *cache, Dlelem *elt)
+{
+ CatCTup *ct;
+ CatCTup *other_ct;
+ Dlelem *other_elt;
+
+ if (elt)
+ ct = (CatCTup*) DLE_VAL(elt);
+ else
+ return;
+
+ other_elt = ct->ct_node;
+ other_ct = (CatCTup*)DLE_VAL(other_elt);
+ DLRemove(other_elt);
+ DLFreeElem(other_elt);
+ free(other_ct);
+ DLRemove(elt);
+ DLFreeElem(elt);
+ free(ct);
+ --cache->cc_ntup;
+}
+
+/* --------------------------------
+ * CatalogCacheIdInvalidate()
+ *
+ * Invalidate a tuple given a cache id. In this case the id should always
+ * be found (whether the cache has opened its relation or not). Of course,
+ * if the cache has yet to open its relation, there will be no tuples so
+ * no problem.
+ * --------------------------------
+ */
+void
+CatalogCacheIdInvalidate(int cacheId, /* XXX */
+ Index hashIndex,
+ ItemPointer pointer)
+{
+ CatCache *ccp;
+ CatCTup *ct;
+ Dlelem *elt;
+ MemoryContext oldcxt;
+
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ Assert(hashIndex < NCCBUCK);
+ Assert(ItemPointerIsValid(pointer));
+ CACHE1_elog(DEBUG, "CatalogCacheIdInvalidate: called");
+
+ /* ----------------
+ * switch to the cache context for our memory allocations
+ * ----------------
+ */
+ if (!CacheCxt)
+ CacheCxt = CreateGlobalMemory("Cache");
+ oldcxt = MemoryContextSwitchTo((MemoryContext)CacheCxt);
+
+ /* ----------------
+ * inspect every cache that could contain the tuple
+ * ----------------
+ */
+ for (ccp = Caches; ccp; ccp = ccp->cc_next) {
+ if (cacheId != ccp->id)
+ continue;
+ /* ----------------
+ * inspect the hash bucket until we find a match or exhaust
+ * ----------------
+ */
+ for (elt = DLGetHead(ccp->cc_cache[hashIndex]);
+ elt;
+ elt = DLGetSucc(elt))
+ {
+ ct = (CatCTup*) DLE_VAL(elt);
+ if (ItemPointerEquals(pointer, &ct->ct_tup->t_ctid))
+ break;
+ }
+
+ /* ----------------
+ * if we found a matching tuple, invalidate it.
+ * ----------------
+ */
+
+ if (elt) {
+ CatCacheRemoveCTup(ccp, elt);
+
+ CACHE1_elog(DEBUG, "CatalogCacheIdInvalidate: invalidated");
+ }
+
+ if (cacheId != InvalidCatalogCacheId)
+ break;
+ }
+
+ /* ----------------
+ * return to the proper memory context
+ * ----------------
+ */
+ MemoryContextSwitchTo(oldcxt);
+ /* sendpm('I', "Invalidated tuple"); */
+}
+
+/* ----------------------------------------------------------------
+ * public functions
+ *
+ * ResetSystemCache
+ * InitIndexedSysCache
+ * InitSysCache
+ * SearchSysCache
+ * RelationInvalidateCatalogCacheTuple
+ * ----------------------------------------------------------------
+ */
+/* --------------------------------
+ * ResetSystemCache
+ * --------------------------------
+ */
+void
+ResetSystemCache()
+{
+ MemoryContext oldcxt;
+ struct catcache *cache;
+
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ CACHE1_elog(DEBUG, "ResetSystemCache called");
+ if (DisableCache) {
+ elog(WARN, "ResetSystemCache: Called while cache disabled");
+ return;
+ }
+
+ /* ----------------
+ * first switch to the cache context so our allocations
+ * do not vanish at the end of a transaction
+ * ----------------
+ */
+ if (!CacheCxt)
+ CacheCxt = CreateGlobalMemory("Cache");
+
+ oldcxt = MemoryContextSwitchTo((MemoryContext)CacheCxt);
+
+ /* ----------------
+ * here we purge the contents of all the caches
+ *
+ * for each system cache
+ * for each hash bucket
+ * for each tuple in hash bucket
+ * remove the tuple
+ * ----------------
+ */
+ for (cache = Caches; PointerIsValid(cache); cache = cache->cc_next) {
+ int hash;
+ for (hash = 0; hash < NCCBUCK; hash += 1) {
+ Dlelem *elt, *nextelt;
+ for (elt = DLGetHead(cache->cc_cache[hash]); elt; elt = nextelt) {
+ nextelt = DLGetSucc(elt);
+ CatCacheRemoveCTup(cache, elt);
+ if (cache->cc_ntup == -1)
+ elog(WARN, "ResetSystemCache: cc_ntup<0 (software error)");
+ }
+ }
+ cache->cc_ntup = 0; /* in case of WARN error above */
+ }
+
+ CACHE1_elog(DEBUG, "end of ResetSystemCache call");
+
+ /* ----------------
+ * back to the old context before we return...
+ * ----------------
+ */
+ MemoryContextSwitchTo(oldcxt);
+}
+
+/* --------------------------------
+ * InitIndexedSysCache
+ *
+ * This allocates and initializes a cache for a system catalog relation.
+ * Actually, the cache is only partially initialized to avoid opening the
+ * relation. The relation will be opened and the rest of the cache
+ * structure initialized on the first access.
+ * --------------------------------
+ */
+#ifdef CACHEDEBUG
+#define InitSysCache_DEBUG1 \
+elog(DEBUG, "InitSysCache: rid=%d id=%d nkeys=%d size=%d\n", \
+ cp->relationId, cp->id, cp->cc_nkeys, cp->cc_size); \
+ for (i = 0; i < nkeys; i += 1) { \
+ elog(DEBUG, "InitSysCache: key=%d len=%d skey=[%d %d %d %d]\n", \
+ cp->cc_key[i], cp->cc_klen[i], \
+ cp->cc_skey[i].sk_flags, \
+ cp->cc_skey[i].sk_attno, \
+ cp->cc_skey[i].sk_procedure, \
+ cp->cc_skey[i].sk_argument); \
+ }
+#else
+#define InitSysCache_DEBUG1
+#endif
+
+CatCache*
+InitSysCache(char *relname,
+ char *iname,
+ int id,
+ int nkeys,
+ int key[],
+ HeapTuple (*iScanfuncP)())
+{
+ CatCache *cp;
+ register int i;
+ MemoryContext oldcxt;
+
+ char *indname;
+
+ indname = (iname) ? iname : NULL;
+
+ /* ----------------
+ * first switch to the cache context so our allocations
+ * do not vanish at the end of a transaction
+ * ----------------
+ */
+ if (!CacheCxt)
+ CacheCxt = CreateGlobalMemory("Cache");
+
+ oldcxt = MemoryContextSwitchTo((MemoryContext)CacheCxt);
+
+ /* ----------------
+ * allocate a new cache structure
+ * ----------------
+ */
+ cp = (CatCache *)palloc(sizeof(CatCache));
+ memset((char*)cp, 0, sizeof(CatCache));
+
+ /* ----------------
+ * initialize the cache buckets (each bucket is a list header)
+ * and the LRU tuple list
+ * ----------------
+ */
+ for (i = 0; i <= NCCBUCK; ++i) {
+ cp->cc_cache[i] = DLNewList();
+ }
+
+ cp->cc_lrulist = DLNewList();
+
+ /* ----------------
+ * Caches is the pointer to the head of the list of all the
+ * system caches. here we add the new cache to the top of the list.
+ * ----------------
+ */
+ cp->cc_next = Caches; /* list of caches (single link) */
+ Caches = cp;
+
+ /* ----------------
+ * initialize the cache's relation information for the relation
+ * corresponding to this cache and initialize some of the the new
+ * cache's other internal fields.
+ * ----------------
+ */
+ cp->relationId = InvalidOid;
+ cp->indexId = InvalidOid;
+ cp->cc_relname = relname;
+ cp->cc_indname = indname;
+ cp->cc_tupdesc = (TupleDesc) NULL;
+ cp->id = id;
+ cp->cc_maxtup = MAXTUP;
+ cp->cc_size = NCCBUCK;
+ cp->cc_nkeys = nkeys;
+ cp->cc_iscanfunc = iScanfuncP;
+
+ /* ----------------
+ * initialize the cache's key information
+ * ----------------
+ */
+ for (i = 0; i < nkeys; ++i) {
+ cp->cc_key[i] = key[i];
+ if (!key[i]) {
+ elog(FATAL, "InitSysCache: called with 0 key[%d]", i);
+ }
+ if (key[i] < 0) {
+ if (key[i] != ObjectIdAttributeNumber) {
+ elog(FATAL, "InitSysCache: called with %d key[%d]", key[i], i);
+ } else {
+ cp->cc_klen[i] = sizeof(Oid);
+ /*
+ * ScanKeyEntryData and struct skey are equivalent. It looks
+ * like a move was made to obsolete struct skey, but it
+ * didn't reach this file. Someday we should clean up this
+ * code and consolidate to ScanKeyEntry - mer 10 Nov 1991
+ */
+ ScanKeyEntryInitialize(&cp->cc_skey[i],
+ (bits16)0,
+ (AttrNumber)key[i],
+ (RegProcedure)F_OIDEQ,
+ (Datum)0);
+ continue;
+ }
+ }
+
+ cp->cc_skey[i].sk_attno = key[i];
+ }
+
+ /* ----------------
+ * all done. new cache is initialized. print some debugging
+ * information, if appropriate.
+ * ----------------
+ */
+ InitSysCache_DEBUG1;
+
+ /* ----------------
+ * back to the old context before we return...
+ * ----------------
+ */
+ MemoryContextSwitchTo(oldcxt);
+ return(cp);
+}
+
+
+/* --------------------------------
+ * SearchSysCache
+ *
+ * This call searches a system cache for a tuple, opening the relation
+ * if necessary (the first access to a particular cache).
+ * --------------------------------
+ */
+HeapTuple
+SearchSysCache(struct catcache *cache,
+ Datum v1,
+ Datum v2,
+ Datum v3,
+ Datum v4)
+{
+ unsigned hash;
+ CatCTup *ct;
+ CatCTup *nct;
+ CatCTup *nct2;
+ Dlelem *elt;
+ HeapTuple ntp;
+ Buffer buffer;
+
+ Relation relation;
+ MemoryContext oldcxt;
+
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ if (cache->relationId == InvalidOid)
+ CatalogCacheInitializeCache(cache, NULL);
+
+ /* ----------------
+ * initialize the search key information
+ * ----------------
+ */
+ cache->cc_skey[0].sk_argument = v1;
+ cache->cc_skey[1].sk_argument = v2;
+ cache->cc_skey[2].sk_argument = v3;
+ cache->cc_skey[3].sk_argument = v4;
+
+ /* ----------------
+ * find the hash bucket in which to look for the tuple
+ * ----------------
+ */
+ hash = CatalogCacheComputeHashIndex(cache);
+
+ /* ----------------
+ * scan the hash bucket until we find a match or exhaust our tuples
+ * ----------------
+ */
+ for (elt = DLGetHead(cache->cc_cache[hash]);
+ elt;
+ elt = DLGetSucc(elt))
+ {
+ ct = (CatCTup*)DLE_VAL(elt);
+ /* ----------------
+ * see if the cached tuple matches our key.
+ * (should we be worried about time ranges? -cim 10/2/90)
+ * ----------------
+ */
+ if (heap_keytest(ct->ct_tup,
+ cache->cc_tupdesc,
+ cache->cc_nkeys,
+ cache->cc_skey))
+ break;
+ }
+
+ /* ----------------
+ * if we found a tuple in the cache, move it to the top of the
+ * lru list, and return it.
+ * ----------------
+ */
+ if (elt) {
+ Dlelem* old_lru_elt;
+ old_lru_elt = ((CatCTup*)DLE_VAL(elt))->ct_node;
+ DLRemove(old_lru_elt);
+ DLAddHead(cache->cc_lrulist, old_lru_elt);
+
+#ifdef CACHEDEBUG
+ relation = heap_open(cache->relationId);
+ CACHE3_elog(DEBUG, "SearchSysCache(%s): found in bucket %d",
+ RelationGetRelationName(relation), hash);
+ heap_close(relation);
+#endif /* CACHEDEBUG */
+
+ return (ct->ct_tup);
+ }
+
+ /* ----------------
+ * Tuple was not found in cache, so we have to try and
+ * retrieve it directly from the relation. If it's found,
+ * we add it to the cache. We must avoid recursion here,
+ * so we disable cache operations. If operations are
+ * currently disabled and we couldn't find the requested item
+ * in the cache, then this may be a recursive request, and we
+ * abort with an error.
+ * ----------------
+ */
+
+ if (DisableCache) {
+ elog(WARN, "SearchSysCache: Called while cache disabled");
+ return((HeapTuple) NULL);
+ }
+
+ /* ----------------
+ * open the relation associated with the cache
+ * ----------------
+ */
+ relation = heap_open(cache->relationId);
+ CACHE2_elog(DEBUG, "SearchSysCache(%s)",
+ RelationGetRelationName(relation));
+
+ /* ----------------
+ * DisableCache and then switch to the cache memory context.
+ * ----------------
+ */
+ DisableCache = 1;
+
+ if (!CacheCxt)
+ CacheCxt = CreateGlobalMemory("Cache");
+
+ oldcxt = MemoryContextSwitchTo((MemoryContext)CacheCxt);
+
+ /* ----------------
+ * Scan the relation to find the tuple. If there's an index, and
+ * if this isn't bootstrap (initdb) time, use the index.
+ * ----------------
+ */
+ CACHE2_elog(DEBUG, "SearchSysCache: performing scan (override==%d)",
+ heapisoverride());
+
+ if ((RelationGetRelationTupleForm(relation))->relhasindex
+ && !IsBootstrapProcessingMode())
+ {
+ Assert(cache->cc_iscanfunc);
+ switch(cache->cc_nkeys)
+ {
+ case 4: ntp = cache->cc_iscanfunc(relation,v1,v2,v3,v4); break;
+ case 3: ntp = cache->cc_iscanfunc(relation,v1,v2,v3); break;
+ case 2: ntp = cache->cc_iscanfunc(relation,v1,v2); break;
+ case 1: ntp = cache->cc_iscanfunc(relation,v1); break;
+ }
+ }
+ else
+ {
+ HeapScanDesc sd;
+
+ sd = heap_beginscan(relation, 0, NowTimeQual,
+ cache->cc_nkeys, cache->cc_skey);
+
+ ntp = heap_getnext(sd, 0, &buffer);
+
+ if (HeapTupleIsValid(ntp)) {
+ CACHE1_elog(DEBUG, "SearchSysCache: found tuple");
+ ntp = heap_copytuple(ntp);
+ }
+
+ heap_endscan(sd);
+ }
+
+ DisableCache = 0;
+
+ /* ----------------
+ * scan is complete. if tup is valid, we copy it and add the copy to
+ * the cache.
+ * ----------------
+ */
+ if (HeapTupleIsValid(ntp)) {
+ /* ----------------
+ * allocate a new cache tuple holder, store the pointer
+ * to the heap tuple there and initialize the list pointers.
+ * ----------------
+ */
+ Dlelem *lru_elt;
+
+ /* this is a little cumbersome here because we want the Dlelem's
+ in both doubly linked lists to point to one another.
+ That makes it easier to remove something from both the cache bucket
+ and the lru list at the same time */
+ nct = (CatCTup*) malloc(sizeof(CatCTup));
+ nct->ct_tup = ntp;
+ elt = DLNewElem(nct);
+ nct2 = (CatCTup*) malloc(sizeof(CatCTup));
+ nct2->ct_tup = ntp;
+ lru_elt = DLNewElem(nct2);
+ nct2->ct_node = elt;
+ nct->ct_node = lru_elt;
+
+ DLAddHead(cache->cc_lrulist, lru_elt);
+ DLAddHead(cache->cc_cache[hash], elt);
+
+ /* ----------------
+ * deal with hash bucket overflow
+ * ----------------
+ */
+ if (++cache->cc_ntup > cache->cc_maxtup) {
+ CatCTup *ct;
+ elt = DLGetTail(cache->cc_lrulist);
+ ct = (CatCTup *) DLE_VAL(elt);
+
+ if (ct != nct) {
+ CACHE2_elog(DEBUG, "SearchSysCache(%s): Overflow, LRU removal",
+ RelationGetRelationName(relation));
+
+ CatCacheRemoveCTup(cache, elt);
+
+ }
+ }
+
+ CACHE4_elog(DEBUG, "SearchSysCache(%s): Contains %d/%d tuples",
+ RelationGetRelationName(relation),
+ cache->cc_ntup, cache->cc_maxtup);
+ CACHE3_elog(DEBUG, "SearchSysCache(%s): put in bucket %d",
+ RelationGetRelationName(relation), hash);
+ }
+
+ /* ----------------
+ * close the relation, switch back to the original memory context
+ * and return the tuple we found (or NULL)
+ * ----------------
+ */
+ heap_close(relation);
+
+ MemoryContextSwitchTo(oldcxt);
+ return ntp;
+}
+
+/* --------------------------------
+ * RelationInvalidateCatalogCacheTuple()
+ *
+ * Invalidate a tuple from a specific relation. This call determines the
+ * cache in question and calls CatalogCacheIdInvalidate(). It is -ok-
+ * if the relation cannot be found, it simply means this backend has yet
+ * to open it.
+ * --------------------------------
+ */
+void
+RelationInvalidateCatalogCacheTuple(Relation relation,
+ HeapTuple tuple,
+ void (*function)())
+{
+ struct catcache *ccp;
+ MemoryContext oldcxt;
+ Oid relationId;
+
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ Assert(RelationIsValid(relation));
+ Assert(HeapTupleIsValid(tuple));
+ CACHE1_elog(DEBUG, "RelationInvalidateCatalogCacheTuple: called");
+
+ /* ----------------
+ * switch to the cache memory context
+ * ----------------
+ */
+ if (!CacheCxt)
+ CacheCxt = CreateGlobalMemory("Cache");
+ oldcxt = MemoryContextSwitchTo((MemoryContext)CacheCxt);
+
+ /* ----------------
+ * for each cache
+ * if the cache contains tuples from the specified relation
+ * call the invalidation function on the tuples
+ * in the proper hash bucket
+ * ----------------
+ */
+ relationId = RelationGetRelationId(relation);
+
+ for (ccp = Caches; ccp; ccp = ccp->cc_next) {
+ if (relationId != ccp->relationId)
+ continue;
+
+ /* OPT inline simplification of CatalogCacheIdInvalidate */
+ if (!PointerIsValid(function)) {
+ function = CatalogCacheIdInvalidate;
+ }
+
+ (*function)(ccp->id,
+ CatalogCacheComputeTupleHashIndex(ccp, relation, tuple),
+ &tuple->t_ctid);
+
+ heap_close(relation);
+ }
+
+ /* ----------------
+ * return to the proper memory context
+ * ----------------
+ */
+ MemoryContextSwitchTo(oldcxt);
+
+ /* sendpm('I', "Invalidated tuple"); */
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * fcache.c--
+ * Code for the 'function cache' used in Oper and Func nodes....
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/Attic/fcache.c,v 1.1.1.1 1996/07/09 06:22:06 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "c.h"
+#include "access/htup.h"
+#include "utils/catcache.h"
+#include "utils/syscache.h"
+#include "catalog/pg_type.h"
+#include "catalog/pg_proc.h"
+#include "catalog/pg_language.h"
+#include "catalog/pg_class.h"
+#include "parser/parsetree.h" /* for getrelname() */
+#include "utils/builtins.h"
+#include "utils/fcache.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "nodes/primnodes.h"
+#include "nodes/execnodes.h"
+
+static Oid GetDynamicFuncArgType(Var *arg, ExprContext *econtext);
+static FunctionCachePtr init_fcache(Oid foid,
+ bool use_syscache,
+ List *argList,
+ ExprContext *econtext);
+
+/*-----------------------------------------------------------------
+ *
+ * Initialize the 'FunctionCache' given the PG_PROC oid.
+ *
+ *
+ * NOTE: This function can be called when the system cache is being
+ * initialized. Therefore, use_syscache should ONLY be true
+ * when the function return type is interesting (ie: set_fcache).
+ *-----------------------------------------------------------------
+ */
+#define FuncArgTypeIsDynamic(arg) \
+ (IsA(arg,Var) && ((Var*)arg)->varattno == InvalidAttrNumber)
+
+static Oid
+GetDynamicFuncArgType(Var *arg, ExprContext *econtext)
+{
+ char *relname;
+ int rtid;
+ HeapTuple tup;
+
+ Assert(IsA(arg,Var));
+
+ rtid = ((Var*)arg)->varno;
+ relname = (char*)getrelname(rtid, econtext->ecxt_range_table);
+
+
+ tup = SearchSysCacheTuple(TYPNAME, PointerGetDatum(relname),
+ 0,0,0);
+ if (!tup)
+ elog(WARN, "Lookup failed on type tuple for class %s",
+ relname);
+
+ return tup->t_oid;
+}
+
+static FunctionCachePtr
+init_fcache(Oid foid,
+ bool use_syscache,
+ List *argList,
+ ExprContext *econtext)
+{
+ HeapTuple procedureTuple;
+ HeapTuple typeTuple;
+ Form_pg_proc procedureStruct;
+ TypeTupleForm typeStruct;
+ FunctionCachePtr retval;
+ text *tmp;
+ int nargs;
+
+ /* ----------------
+ * get the procedure tuple corresponding to the given
+ * functionOid. If this fails, returnValue has been
+ * pre-initialized to "null" so we just return it.
+ * ----------------
+ */
+ retval = (FunctionCachePtr) palloc(sizeof(FunctionCache));
+
+ if (!use_syscache)
+ elog(WARN, "what the ????, init the fcache without the catalogs?");
+
+ procedureTuple = SearchSysCacheTuple(PROOID,
+ ObjectIdGetDatum(foid),
+ 0,0,0);
+
+ if (!HeapTupleIsValid(procedureTuple))
+ elog(WARN,
+ "init_fcache: %s %d",
+ "Cache lookup failed for procedure", foid);
+
+ /* ----------------
+ * get the return type from the procedure tuple
+ * ----------------
+ */
+ procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple);
+
+ /* ----------------
+ * get the type tuple corresponding to the return type
+ * If this fails, returnValue has been pre-initialized
+ * to "null" so we just return it.
+ * ----------------
+ */
+ typeTuple = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(procedureStruct->prorettype),
+ 0,0,0);
+
+ if (!HeapTupleIsValid(typeTuple))
+ elog(WARN,
+ "init_fcache: %s %d",
+ "Cache lookup failed for type",
+ (procedureStruct)->prorettype);
+
+ /* ----------------
+ * get the type length and by-value from the type tuple and
+ * save the information in our one element cache.
+ * ----------------
+ */
+ typeStruct = (TypeTupleForm) GETSTRUCT(typeTuple);
+
+ retval->typlen = (typeStruct)->typlen;
+ if ((typeStruct)->typrelid == InvalidOid) {
+ /* The return type is not a relation, so just use byval */
+ retval->typbyval = (typeStruct)->typbyval ? true : false ;
+ } else {
+ /* This is a hack. We assume here that any function returning
+ * a relation returns it by reference. This needs to be
+ * fixed.
+ */
+ retval->typbyval = false;
+ }
+ retval->foid = foid;
+ retval->language = procedureStruct->prolang;
+ retval->func_state = (char *)NULL;
+ retval->setArg = NULL;
+ retval->hasSetArg = false;
+ retval->oneResult = ! procedureStruct->proretset;
+ retval->istrusted = procedureStruct->proistrusted;
+
+ /*
+ * If we are returning exactly one result then we have to copy
+ * tuples and by reference results because we have to end the execution
+ * before we return the results. When you do this everything allocated
+ * by the executor (i.e. slots and tuples) is freed.
+ */
+ if ((retval->language == SQLlanguageId) &&
+ (retval->oneResult) &&
+ !(retval->typbyval))
+ {
+ Form_pg_class relationStruct;
+ HeapTuple relationTuple;
+ TupleDesc td;
+ TupleTableSlot *slot;
+
+ slot = makeNode(TupleTableSlot);
+ slot->ttc_shouldFree = true;
+ slot->ttc_descIsNew = true;
+ slot->ttc_tupleDescriptor = (TupleDesc) NULL;
+ slot->ttc_buffer = InvalidBuffer;
+ slot->ttc_whichplan = -1;
+ retval->funcSlot = (Pointer)slot;
+
+ relationTuple = (HeapTuple)
+ SearchSysCacheTuple(RELNAME,
+ PointerGetDatum(&typeStruct->typname),
+ 0,0,0);
+
+ if (relationTuple)
+ {
+ relationStruct = (Form_pg_class)GETSTRUCT(relationTuple);
+ td = CreateTemplateTupleDesc(relationStruct->relnatts);
+ }
+ else
+ td = CreateTemplateTupleDesc(1);
+
+ ((TupleTableSlot*)retval->funcSlot)->ttc_tupleDescriptor = td;
+ }
+ else
+ retval->funcSlot = (char *)NULL;
+
+ nargs = procedureStruct->pronargs;
+ retval->nargs = nargs;
+
+ if (nargs > 0)
+ {
+ Oid *argTypes;
+
+ retval->nullVect = (bool *)palloc((retval->nargs)*sizeof(bool));
+
+ if (retval->language == SQLlanguageId)
+ {
+ int i;
+ List *oneArg;
+
+ retval->argOidVect =
+ (Oid *)palloc(retval->nargs*sizeof(Oid));
+ argTypes = procedureStruct->proargtypes;
+ memmove(retval->argOidVect,
+ argTypes,
+ (retval->nargs)*sizeof(Oid));
+
+ for (i=0;
+ argList;
+ i++, argList = lnext(argList))
+ {
+ oneArg = lfirst(argList);
+ if (FuncArgTypeIsDynamic(oneArg))
+ retval->argOidVect[i] = GetDynamicFuncArgType((Var*)oneArg,
+ econtext);
+ }
+ }
+ else
+ retval->argOidVect = (Oid *)NULL;
+ }
+ else
+ {
+ retval->argOidVect = (Oid *)NULL;
+ retval->nullVect = (BoolPtr)NULL;
+ }
+
+ /*
+ * XXX this is the first varlena in the struct. If the order
+ * changes for some reason this will fail.
+ */
+ if (procedureStruct->prolang == SQLlanguageId)
+ {
+ retval->src = textout(&(procedureStruct->prosrc));
+ retval->bin = (char *) NULL;
+ }
+ else
+ {
+
+ /*
+ * I'm not sure that we even need to do this at all.
+ */
+
+ /*
+ * We do for untrusted functions.
+ */
+
+ if (procedureStruct->proistrusted)
+ retval->bin = (char *) NULL;
+ else {
+ tmp = (text *)
+ SearchSysCacheGetAttribute(PROOID,
+ Anum_pg_proc_probin,
+ ObjectIdGetDatum(foid),
+ 0,0,0);
+ retval->bin = textout(tmp);
+ }
+ retval->src = (char *) NULL;
+ }
+
+
+
+
+ if (retval->language != SQLlanguageId)
+ fmgr_info(foid, &(retval->func), &(retval->nargs));
+ else
+ retval->func = (func_ptr)NULL;
+
+
+ return(retval);
+}
+
+void
+setFcache(Node *node, Oid foid, List *argList, ExprContext *econtext)
+{
+ Func *fnode;
+ Oper *onode;
+ FunctionCachePtr fcache;
+
+ fcache = init_fcache(foid, true, argList, econtext);
+
+ if (IsA(node,Oper)) {
+ onode = (Oper*) node;
+ onode->op_fcache = fcache;
+ }else if (IsA(node,Func)) {
+ fnode = (Func*) node;
+ fnode->func_fcache = fcache;
+ }else {
+ elog(WARN, "init_fcache: node must be Oper or Func!");
+ }
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * inval.c--
+ * POSTGRES cache invalidation dispatcher code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/inval.c,v 1.1.1.1 1996/07/09 06:22:06 scrappy Exp $
+ *
+ * Note - this code is real crufty...
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+#include "access/heapam.h" /* XXX to support hacks below */
+#include "access/htup.h"
+#include "catalog/catalog.h"
+#include "storage/bufpage.h"
+#include "storage/buf.h" /* XXX for InvalidBuffer */
+#include "storage/ipc.h"
+#include "storage/sinval.h"
+#include "utils/catcache.h"
+#include "utils/inval.h"
+#include "utils/elog.h"
+#include "utils/rel.h"
+#include "utils/relcache.h"
+#include "catalog/catname.h" /* XXX to support hacks below */
+#include "utils/syscache.h" /* XXX to support the hacks below */
+
+/* ----------------
+ * private invalidation structures
+ * ----------------
+ */
+typedef struct CatalogInvalidationData {
+ Index cacheId;
+ Index hashIndex;
+ ItemPointerData pointerData;
+} CatalogInvalidationData;
+
+typedef struct RelationInvalidationData {
+ Oid relationId;
+ Oid objectId;
+} RelationInvalidationData;
+
+typedef union AnyInvalidation {
+ CatalogInvalidationData catalog;
+ RelationInvalidationData relation;
+} AnyInvalidation;
+
+typedef struct InvalidationMessageData {
+ char kind;
+ AnyInvalidation any;
+} InvalidationMessageData;
+
+typedef InvalidationMessageData *InvalidationMessage;
+
+/* ----------------
+ * variables and macros
+ * ----------------
+ */
+static LocalInvalid Invalid = EmptyLocalInvalid; /* XXX global */
+static bool RefreshWhenInvalidate = false;
+
+Oid MyRelationRelationId = InvalidOid;
+Oid MyAttributeRelationId = InvalidOid;
+Oid MyAMRelationId = InvalidOid;
+Oid MyAMOPRelationId = InvalidOid;
+
+#define ValidateHacks() \
+ if (!OidIsValid(MyRelationRelationId)) getmyrelids()
+
+/* ----------------------------------------------------------------
+ * "local" invalidation support functions
+ * ----------------------------------------------------------------
+ */
+
+/* --------------------------------
+ * InvalidationEntryAllocate--
+ * Allocates an invalidation entry.
+ * --------------------------------
+ */
+InvalidationEntry
+InvalidationEntryAllocate(uint16 size)
+{
+ InvalidationEntryData *entryDataP;
+ entryDataP = (InvalidationEntryData *)
+ malloc(sizeof (char *) + size); /* XXX alignment */
+ entryDataP->nextP = NULL;
+ return ((Pointer) &entryDataP->userData);
+}
+
+/* --------------------------------
+ * LocalInvalidRegister --
+ * Returns a new local cache invalidation state containing a new entry.
+ * --------------------------------
+ */
+LocalInvalid
+LocalInvalidRegister(LocalInvalid invalid,
+ InvalidationEntry entry)
+{
+ Assert(PointerIsValid(entry));
+
+ ((InvalidationUserData *)entry)->dataP[-1] =
+ (InvalidationUserData *)invalid;
+
+ return (entry);
+}
+
+/* --------------------------------
+ * LocalInvalidInvalidate--
+ * Processes, then frees all entries in a local cache
+ * invalidation state.
+ * --------------------------------
+ */
+void
+LocalInvalidInvalidate(LocalInvalid invalid, void (*function)())
+{
+ InvalidationEntryData *entryDataP;
+
+ while (PointerIsValid(invalid)) {
+ entryDataP = (InvalidationEntryData *)
+ &((InvalidationUserData *)invalid)->dataP[-1];
+
+ if (PointerIsValid(function)) {
+ (*function)((Pointer) &entryDataP->userData);
+ }
+
+ invalid = (Pointer) entryDataP->nextP;
+
+ /* help catch errors */
+ entryDataP->nextP = (InvalidationUserData *) NULL;
+
+ free((Pointer)entryDataP);
+ }
+}
+
+/* ----------------------------------------------------------------
+ * private support functions
+ * ----------------------------------------------------------------
+ */
+/* --------------------------------
+ * CacheIdRegisterLocalInvalid
+ * --------------------------------
+ */
+#ifdef INVALIDDEBUG
+#define CacheIdRegisterLocalInvalid_DEBUG1 \
+elog(DEBUG, "CacheIdRegisterLocalInvalid(%d, %d, [%d, %d])", \
+ cacheId, hashIndex, ItemPointerGetBlockNumber(pointer), \
+ ItemPointerGetOffsetNumber(pointer))
+#else
+#define CacheIdRegisterLocalInvalid_DEBUG1
+#endif /* INVALIDDEBUG */
+
+static void
+CacheIdRegisterLocalInvalid(Index cacheId,
+ Index hashIndex,
+ ItemPointer pointer)
+{
+ InvalidationMessage message;
+
+ /* ----------------
+ * debugging stuff
+ * ----------------
+ */
+ CacheIdRegisterLocalInvalid_DEBUG1;
+
+ /* ----------------
+ * create a message describing the system catalog tuple
+ * we wish to invalidate.
+ * ----------------
+ */
+ message = (InvalidationMessage)
+ InvalidationEntryAllocate(sizeof (InvalidationMessageData));
+
+ message->kind = 'c';
+ message->any.catalog.cacheId = cacheId;
+ message->any.catalog.hashIndex = hashIndex;
+
+ ItemPointerCopy(pointer, &message->any.catalog.pointerData);
+
+ /* ----------------
+ * Note: Invalid is a global variable
+ * ----------------
+ */
+ Invalid = LocalInvalidRegister(Invalid, (InvalidationEntry)message);
+}
+
+/* --------------------------------
+ * RelationIdRegisterLocalInvalid
+ * --------------------------------
+ */
+static void
+RelationIdRegisterLocalInvalid(Oid relationId, Oid objectId)
+{
+ InvalidationMessage message;
+
+ /* ----------------
+ * debugging stuff
+ * ----------------
+ */
+#ifdef INVALIDDEBUG
+ elog(DEBUG, "RelationRegisterLocalInvalid(%d, %d)", relationId,
+ objectId);
+#endif /* defined(INVALIDDEBUG) */
+
+ /* ----------------
+ * create a message describing the relation descriptor
+ * we wish to invalidate.
+ * ----------------
+ */
+ message = (InvalidationMessage)
+ InvalidationEntryAllocate(sizeof (InvalidationMessageData));
+
+ message->kind = 'r';
+ message->any.relation.relationId = relationId;
+ message->any.relation.objectId = objectId;
+
+ /* ----------------
+ * Note: Invalid is a global variable
+ * ----------------
+ */
+ Invalid = LocalInvalidRegister(Invalid, (InvalidationEntry)message);
+}
+
+/* --------------------------------
+ * getmyrelids
+ * --------------------------------
+ */
+void
+getmyrelids()
+{
+ HeapTuple tuple;
+
+ tuple = SearchSysCacheTuple(RELNAME,
+ PointerGetDatum(RelationRelationName),
+ 0,0,0);
+ Assert(HeapTupleIsValid(tuple));
+ MyRelationRelationId = tuple->t_oid;
+
+ tuple = SearchSysCacheTuple(RELNAME,
+ PointerGetDatum(AttributeRelationName),
+ 0,0,0);
+ Assert(HeapTupleIsValid(tuple));
+ MyAttributeRelationId = tuple->t_oid;
+
+ tuple = SearchSysCacheTuple(RELNAME,
+ PointerGetDatum(AccessMethodRelationName),
+ 0,0,0);
+ Assert(HeapTupleIsValid(tuple));
+ MyAMRelationId = tuple->t_oid;
+
+ tuple = SearchSysCacheTuple(RELNAME,
+ PointerGetDatum(AccessMethodOperatorRelationName),
+ 0,0,0);
+ Assert(HeapTupleIsValid(tuple));
+ MyAMOPRelationId = tuple->t_oid;
+}
+
+/* --------------------------------
+ * CacheIdInvalidate
+ *
+ * This routine can invalidate an tuple in a system catalog cache
+ * or a cached relation descriptor. You pay your money and you
+ * take your chances...
+ * --------------------------------
+ */
+#ifdef INVALIDDEBUG
+#define CacheIdInvalidate_DEBUG1 \
+elog(DEBUG, "CacheIdInvalidate(%d, %d, 0x%x[%d])", cacheId, hashIndex,\
+ pointer, ItemPointerIsValid(pointer))
+#else
+#define CacheIdInvalidate_DEBUG1
+#endif /* defined(INVALIDDEBUG) */
+
+static void
+CacheIdInvalidate(Index cacheId,
+ Index hashIndex,
+ ItemPointer pointer)
+{
+ /* ----------------
+ * assume that if the item pointer is valid, then we are
+ * invalidating an item in the specified system catalog cache.
+ * ----------------
+ */
+ if (ItemPointerIsValid(pointer)) {
+ CatalogCacheIdInvalidate(cacheId, hashIndex, pointer);
+ return;
+ }
+
+ CacheIdInvalidate_DEBUG1;
+
+ ValidateHacks(); /* XXX */
+
+ /* ----------------
+ * if the cacheId is the oid of any of the tuples in the
+ * following system relations, then assume we are invalidating
+ * a relation descriptor
+ * ----------------
+ */
+ if (cacheId == MyRelationRelationId) {
+ RelationIdInvalidateRelationCacheByRelationId(hashIndex);
+ return;
+ }
+
+ if (cacheId == MyAttributeRelationId) {
+ RelationIdInvalidateRelationCacheByRelationId(hashIndex);
+ return;
+ }
+
+ if (cacheId == MyAMRelationId) {
+ RelationIdInvalidateRelationCacheByAccessMethodId(hashIndex);
+ return;
+ }
+
+ if (cacheId == MyAMOPRelationId) {
+ RelationIdInvalidateRelationCacheByAccessMethodId(InvalidOid);
+ return;
+ }
+
+ /* ----------------
+ * Yow! the caller asked us to invalidate something else.
+ * ----------------
+ */
+ elog(FATAL, "CacheIdInvalidate: cacheId=%d relation id?", cacheId);
+}
+
+/* --------------------------------
+ * ResetSystemCaches
+ *
+ * this blows away all tuples in the system catalog caches and
+ * all the cached relation descriptors (and closes the files too).
+ * --------------------------------
+ */
+static void
+ResetSystemCaches()
+{
+ ResetSystemCache();
+ RelationCacheInvalidate(false);
+}
+
+/* --------------------------------
+ * InvalidationMessageRegisterSharedInvalid
+ * --------------------------------
+ */
+#ifdef INVALIDDEBUG
+#define InvalidationMessageRegisterSharedInvalid_DEBUG1 \
+elog(DEBUG,\
+ "InvalidationMessageRegisterSharedInvalid(c, %d, %d, [%d, %d])",\
+ message->any.catalog.cacheId,\
+ message->any.catalog.hashIndex,\
+ ItemPointerGetBlockNumber(&message->any.catalog.pointerData),\
+ ItemPointerGetOffsetNumber(&message->any.catalog.pointerData))
+#define InvalidationMessageRegisterSharedInvalid_DEBUG2 \
+ elog(DEBUG, \
+ "InvalidationMessageRegisterSharedInvalid(r, %d, %d)", \
+ message->any.relation.relationId, \
+ message->any.relation.objectId)
+#else
+#define InvalidationMessageRegisterSharedInvalid_DEBUG1
+#define InvalidationMessageRegisterSharedInvalid_DEBUG2
+#endif /* INVALIDDEBUG */
+
+static void
+InvalidationMessageRegisterSharedInvalid(InvalidationMessage message)
+{
+ Assert(PointerIsValid(message));
+
+ switch (message->kind) {
+ case 'c': /* cached system catalog tuple */
+ InvalidationMessageRegisterSharedInvalid_DEBUG1;
+
+ RegisterSharedInvalid(message->any.catalog.cacheId,
+ message->any.catalog.hashIndex,
+ &message->any.catalog.pointerData);
+ break;
+
+ case 'r': /* cached relation descriptor */
+ InvalidationMessageRegisterSharedInvalid_DEBUG2;
+
+ RegisterSharedInvalid(message->any.relation.relationId,
+ message->any.relation.objectId,
+ (ItemPointer) NULL);
+ break;
+
+ default:
+ elog(FATAL,
+ "InvalidationMessageRegisterSharedInvalid: `%c' kind",
+ message->kind);
+ }
+}
+
+/* --------------------------------
+ * InvalidationMessageCacheInvalidate
+ * --------------------------------
+ */
+#ifdef INVALIDDEBUG
+#define InvalidationMessageCacheInvalidate_DEBUG1 \
+elog(DEBUG, "InvalidationMessageCacheInvalidate(c, %d, %d, [%d, %d])",\
+ message->any.catalog.cacheId,\
+ message->any.catalog.hashIndex,\
+ ItemPointerGetBlockNumber(&message->any.catalog.pointerData),\
+ ItemPointerGetOffsetNumber(&message->any.catalog.pointerData))
+#define InvalidationMessageCacheInvalidate_DEBUG2 \
+ elog(DEBUG, "InvalidationMessageCacheInvalidate(r, %d, %d)", \
+ message->any.relation.relationId, \
+ message->any.relation.objectId)
+#else
+#define InvalidationMessageCacheInvalidate_DEBUG1
+#define InvalidationMessageCacheInvalidate_DEBUG2
+#endif /* defined(INVALIDDEBUG) */
+
+static void
+InvalidationMessageCacheInvalidate(InvalidationMessage message)
+{
+ Assert(PointerIsValid(message));
+
+ switch (message->kind) {
+ case 'c': /* cached system catalog tuple */
+ InvalidationMessageCacheInvalidate_DEBUG1;
+
+ CatalogCacheIdInvalidate(message->any.catalog.cacheId,
+ message->any.catalog.hashIndex,
+ &message->any.catalog.pointerData);
+ break;
+
+ case 'r': /* cached relation descriptor */
+ InvalidationMessageCacheInvalidate_DEBUG2;
+
+ /* XXX ignore this--is this correct ??? */
+ break;
+
+ default:
+ elog(FATAL, "InvalidationMessageCacheInvalidate: `%c' kind",
+ message->kind);
+ }
+}
+
+/* --------------------------------
+ * RelationInvalidateRelationCache
+ * --------------------------------
+ */
+static void
+RelationInvalidateRelationCache(Relation relation,
+ HeapTuple tuple,
+ void (*function)())
+{
+ Oid relationId;
+ Oid objectId;
+
+ /* ----------------
+ * get the relation object id
+ * ----------------
+ */
+ ValidateHacks(); /* XXX */
+ relationId = RelationGetRelationId(relation);
+
+ /* ----------------
+ *
+ * ----------------
+ */
+ if (relationId == MyRelationRelationId) {
+ objectId = tuple->t_oid;
+ } else if (relationId == MyAttributeRelationId) {
+ objectId = ((AttributeTupleForm)GETSTRUCT(tuple))->attrelid;
+ } else if (relationId == MyAMRelationId) {
+ objectId = tuple->t_oid;
+ } else if (relationId == MyAMOPRelationId) {
+ ; /* objectId is unused */
+ } else
+ return;
+
+ /* ----------------
+ * can't handle immediate relation descriptor invalidation
+ * ----------------
+ */
+ Assert(PointerIsValid(function));
+
+ (*function)(relationId, objectId);
+}
+
+/*
+ * DiscardInvalid --
+ * Causes the invalidated cache state to be discarded.
+ *
+ * Note:
+ * This should be called as the first step in processing a transaction.
+ * This should be called while waiting for a query from the front end
+ * when other backends are active.
+ */
+void
+DiscardInvalid()
+{
+ /* ----------------
+ * debugging stuff
+ * ----------------
+ */
+#ifdef INVALIDDEBUG
+ elog(DEBUG, "DiscardInvalid called");
+#endif /* defined(INVALIDDEBUG) */
+
+ InvalidateSharedInvalid(CacheIdInvalidate, ResetSystemCaches);
+}
+
+/*
+ * RegisterInvalid --
+ * Causes registration of invalidated state with other backends iff true.
+ *
+ * Note:
+ * This should be called as the last step in processing a transaction.
+ */
+void
+RegisterInvalid(bool send)
+{
+ /* ----------------
+ * debugging stuff
+ * ----------------
+ */
+#ifdef INVALIDDEBUG
+ elog(DEBUG, "RegisterInvalid(%d) called", send);
+#endif /* defined(INVALIDDEBUG) */
+
+ /* ----------------
+ * Note: Invalid is a global variable
+ * ----------------
+ */
+ if (send)
+ LocalInvalidInvalidate(Invalid,
+ InvalidationMessageRegisterSharedInvalid);
+ else
+ LocalInvalidInvalidate(Invalid,
+ InvalidationMessageCacheInvalidate);
+
+ Invalid = EmptyLocalInvalid;
+}
+
+/*
+ * SetRefreshWhenInvalidate --
+ * Causes the local caches to be immediately refreshed iff true.
+ */
+void
+SetRefreshWhenInvalidate(bool on)
+{
+#ifdef INVALIDDEBUG
+ elog(DEBUG, "RefreshWhenInvalidate(%d) called", on);
+#endif /* defined(INVALIDDEBUG) */
+
+ RefreshWhenInvalidate = on;
+}
+
+/*
+ * RelationIdInvalidateHeapTuple --
+ * Causes the given tuple in a relation to be invalidated.
+ *
+ * Note:
+ * Assumes object id is valid.
+ * Assumes tuple is valid.
+ */
+#ifdef INVALIDDEBUG
+#define RelationInvalidateHeapTuple_DEBUG1 \
+elog(DEBUG, "RelationInvalidateHeapTuple(%.16s, [%d,%d])", \
+ RelationGetRelationName(relation), \
+ ItemPointerGetBlockNumber(&tuple->t_ctid), \
+ ItemPointerGetOffsetNumber(&tuple->t_ctid))
+#else
+#define RelationInvalidateHeapTuple_DEBUG1
+#endif /* defined(INVALIDDEBUG) */
+
+void
+RelationInvalidateHeapTuple(Relation relation, HeapTuple tuple)
+{
+ /* ----------------
+ * sanity checks
+ * ----------------
+ */
+ Assert(RelationIsValid(relation));
+ Assert(HeapTupleIsValid(tuple));
+
+ if (IsBootstrapProcessingMode())
+ return;
+ /* ----------------
+ * this only works for system relations now
+ * ----------------
+ */
+ if (! IsSystemRelationName(RelationGetRelationTupleForm(relation)->relname.data))
+ return;
+
+ /* ----------------
+ * debugging stuff
+ * ----------------
+ */
+ RelationInvalidateHeapTuple_DEBUG1;
+
+ /* ----------------
+ *
+ * ----------------
+ */
+ RelationInvalidateCatalogCacheTuple(relation,
+ tuple,
+ CacheIdRegisterLocalInvalid);
+
+ RelationInvalidateRelationCache(relation,
+ tuple,
+ RelationIdRegisterLocalInvalid);
+
+ if (RefreshWhenInvalidate)
+ RelationInvalidateCatalogCacheTuple(relation,
+ tuple,
+ (void (*)()) NULL);
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * lsyscache.c--
+ * Routines to access information within system caches
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.1.1.1 1996/07/09 06:22:06 scrappy Exp $
+ *
+ * NOTES
+ * Eventually, the index information should go through here, too.
+ *
+ * Most of these routines call SearchSysCacheStruct() and thus simply
+ * (1) allocate some space for the return struct and (2) call it.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+#include "utils/syscache.h"
+#include "utils/lsyscache.h"
+#include "access/tupmacs.h"
+#include "utils/rel.h"
+#include "utils/palloc.h"
+#include "utils/elog.h"
+#include "access/attnum.h"
+#include "access/heapam.h"
+
+#include "catalog/pg_amop.h"
+#include "catalog/pg_type.h"
+
+/* ---------- AMOP CACHES ---------- */
+
+/*
+ * op_class -
+ *
+ * Return t iff operator 'opno' is in operator class 'opclass'.
+ *
+ */
+bool
+op_class(Oid opno, int32 opclass, Oid amopid)
+{
+ FormData_pg_amop amoptup;
+
+ if (SearchSysCacheStruct(AMOPOPID,
+ (char *) &amoptup,
+ ObjectIdGetDatum(opclass),
+ ObjectIdGetDatum(opno),
+ ObjectIdGetDatum(amopid),
+ 0))
+ return(true);
+ else
+ return(false);
+}
+
+/* ---------- ATTRIBUTE CACHES ---------- */
+
+/*
+ * get_attname -
+ *
+ * Given the relation id and the attribute number,
+ * return the "attname" field from the attribute relation.
+ *
+ */
+char*
+get_attname(Oid relid, AttrNumber attnum)
+{
+ FormData_pg_attribute att_tup;
+ char *retval;
+
+ if (SearchSysCacheStruct(ATTNUM,
+ (char*)&att_tup,
+ ObjectIdGetDatum(relid),
+ UInt16GetDatum(attnum),
+ 0,0)) {
+ retval = pstrdup(att_tup.attname.data);
+
+ return(retval);
+ }
+ else
+ return(NULL);
+}
+
+/*
+ * get_attnum -
+ *
+ * Given the relation id and the attribute name,
+ * return the "attnum" field from the attribute relation.
+ *
+ */
+AttrNumber
+get_attnum(Oid relid, char *attname)
+{
+ FormData_pg_attribute att_tup;
+
+ if (SearchSysCacheStruct(ATTNAME, (char *) &att_tup,
+ ObjectIdGetDatum(relid),
+ PointerGetDatum(attname),
+ 0,0))
+ return(att_tup.attnum);
+ else
+ return(InvalidAttrNumber);
+}
+
+/*
+ * get_atttype -
+ *
+ * Given the relation OID and the attribute number with the relation,
+ * return the attribute type OID.
+ *
+ */
+Oid
+get_atttype(Oid relid, AttrNumber attnum)
+{
+ AttributeTupleForm att_tup = (AttributeTupleForm)palloc(sizeof(*att_tup));
+
+ if (SearchSysCacheStruct(ATTNUM,
+ (char *) att_tup,
+ ObjectIdGetDatum(relid),
+ UInt16GetDatum(attnum),
+ 0,0))
+ return(att_tup->atttypid);
+ else
+ return((Oid)NULL);
+}
+
+/* This routine uses the attname instead of the attnum because it
+ * replaces the routine find_atttype, which is called sometimes when
+ * only the attname, not the attno, is available.
+ */
+bool
+get_attisset(Oid relid, char *attname)
+{
+ HeapTuple htup;
+ AttrNumber attno;
+ AttributeTupleForm att_tup;
+
+ attno = get_attnum(relid, attname);
+
+ htup = SearchSysCacheTuple(ATTNAME,
+ ObjectIdGetDatum(relid),
+ PointerGetDatum(attname),
+ 0,0);
+ if (!HeapTupleIsValid(htup))
+ elog(WARN, "get_attisset: no attribute %.16s in relation %d",
+ attname, relid);
+ if (heap_attisnull(htup, attno))
+ return(false);
+ else {
+ att_tup = (AttributeTupleForm)GETSTRUCT(htup);
+ return(att_tup->attisset);
+ }
+}
+
+/* ---------- INDEX CACHE ---------- */
+
+/* watch this space...
+ */
+
+/* ---------- OPERATOR CACHE ---------- */
+
+/*
+ * get_opcode -
+ *
+ * Returns the regproc id of the routine used to implement an
+ * operator given the operator uid.
+ *
+ */
+RegProcedure
+get_opcode(Oid opno)
+{
+ FormData_pg_operator optup;
+
+ if (SearchSysCacheStruct(OPROID, (char *) &optup,
+ ObjectIdGetDatum(opno),
+ 0,0,0))
+ return(optup.oprcode);
+ else
+ return((RegProcedure)NULL);
+}
+
+/*
+ * get_opname -
+ * returns the name of the operator with the given opno
+ *
+ * Note: return the struct so that it gets copied.
+ */
+char*
+get_opname(Oid opno)
+{
+ FormData_pg_operator optup;
+
+ if (SearchSysCacheStruct(OPROID, (char *) &optup,
+ ObjectIdGetDatum(opno),
+ 0,0,0))
+ return (pstrdup(optup.oprname.data));
+ else {
+ elog(WARN, "can't look up operator %d\n", opno);
+ return NULL;
+ }
+}
+
+/*
+ * op_mergesortable -
+ *
+ * Returns the left and right sort operators and types corresponding to a
+ * mergesortable operator, or nil if the operator is not mergesortable.
+ *
+ */
+bool
+op_mergesortable(Oid opno, Oid ltype, Oid rtype, Oid *leftOp, Oid *rightOp)
+{
+ FormData_pg_operator optup;
+
+ if (SearchSysCacheStruct(OPROID, (char *) &optup,
+ ObjectIdGetDatum(opno),
+ 0,0,0) &&
+ optup.oprlsortop &&
+ optup.oprrsortop &&
+ optup.oprleft == ltype &&
+ optup.oprright == rtype) {
+
+ *leftOp = ObjectIdGetDatum(optup.oprlsortop);
+ *rightOp = ObjectIdGetDatum(optup.oprrsortop);
+ return TRUE;
+ } else {
+ return FALSE;
+ }
+}
+
+/*
+ * op_hashjoinable--
+ *
+ * Returns the hash operator corresponding to a hashjoinable operator,
+ * or nil if the operator is not hashjoinable.
+ *
+ */
+Oid
+op_hashjoinable(Oid opno, Oid ltype, Oid rtype)
+{
+ FormData_pg_operator optup;
+
+ if (SearchSysCacheStruct(OPROID, (char *) &optup,
+ ObjectIdGetDatum(opno),
+ 0,0,0) &&
+ optup.oprcanhash &&
+ optup.oprleft == ltype &&
+ optup.oprright == rtype)
+ return(opno);
+ else
+ return(InvalidOid);
+}
+
+/*
+ * get_commutator -
+ *
+ * Returns the corresponding commutator of an operator.
+ *
+ */
+Oid
+get_commutator(Oid opno)
+{
+ FormData_pg_operator optup;
+
+ if (SearchSysCacheStruct(OPROID, (char *) &optup,
+ ObjectIdGetDatum(opno),
+ 0,0,0))
+ return(optup.oprcom);
+ else
+ return((Oid)NULL);
+}
+
+HeapTuple
+get_operator_tuple(Oid opno)
+{
+ HeapTuple optup;
+
+ if ((optup = SearchSysCacheTuple(OPROID,
+ ObjectIdGetDatum(opno),
+ 0,0,0)))
+ return(optup);
+ else
+ return((HeapTuple)NULL);
+}
+
+/*
+ * get_negator -
+ *
+ * Returns the corresponding negator of an operator.
+ *
+ */
+Oid
+get_negator(Oid opno)
+{
+ FormData_pg_operator optup;
+
+ if (SearchSysCacheStruct(OPROID, (char *) &optup,
+ ObjectIdGetDatum(opno),
+ 0,0,0))
+ return(optup.oprnegate);
+ else
+ return((Oid)NULL);
+}
+
+/*
+ * get_oprrest -
+ *
+ * Returns procedure id for computing selectivity of an operator.
+ *
+ */
+RegProcedure
+get_oprrest(Oid opno)
+{
+ FormData_pg_operator optup;
+
+ if (SearchSysCacheStruct(OPROID, (char *) &optup,
+ ObjectIdGetDatum(opno),
+ 0,0,0))
+ return(optup.oprrest );
+ else
+ return((RegProcedure) NULL);
+}
+
+/*
+ * get_oprjoin -
+ *
+ * Returns procedure id for computing selectivity of a join.
+ *
+ */
+RegProcedure
+get_oprjoin(Oid opno)
+{
+ FormData_pg_operator optup;
+
+ if (SearchSysCacheStruct(OPROID, (char *) &optup,
+ ObjectIdGetDatum(opno),
+ 0,0,0))
+ return(optup.oprjoin);
+ else
+ return((RegProcedure)NULL);
+}
+
+/* ---------- RELATION CACHE ---------- */
+
+/*
+ * get_relnatts -
+ *
+ * Returns the number of attributes for a given relation.
+ *
+ */
+int
+get_relnatts(Oid relid)
+{
+ FormData_pg_class reltup;
+
+ if (SearchSysCacheStruct(RELOID, (char *) &reltup,
+ ObjectIdGetDatum(relid),
+ 0,0,0))
+ return(reltup.relnatts);
+ else
+ return(InvalidAttrNumber);
+}
+
+/*
+ * get_rel_name -
+ *
+ * Returns the name of a given relation.
+ *
+ */
+char*
+get_rel_name(Oid relid)
+{
+ FormData_pg_class reltup;
+
+ if ((SearchSysCacheStruct(RELOID,
+ (char*)&reltup,
+ ObjectIdGetDatum(relid),
+ 0,0,0))) {
+ return (pstrdup(reltup.relname.data));
+ } else
+ return(NULL);
+}
+
+/* ---------- TYPE CACHE ---------- */
+
+/*
+ * get_typlen -
+ *
+ * Given the type OID, return the length of the type.
+ *
+ */
+int16
+get_typlen(Oid typid)
+{
+ TypeTupleFormData typtup;
+
+ if (SearchSysCacheStruct(TYPOID, (char *) &typtup,
+ ObjectIdGetDatum(typid),
+ 0,0,0))
+ return(typtup.typlen);
+ else
+ return((int16)NULL);
+}
+
+/*
+ * get_typbyval -
+ *
+ * Given the type OID, determine whether the type is returned by value or
+ * not. Returns 1 if by value, 0 if by reference.
+ *
+ */
+bool
+get_typbyval(Oid typid)
+{
+ TypeTupleFormData typtup;
+
+ if (SearchSysCacheStruct(TYPOID, (char *) &typtup,
+ ObjectIdGetDatum(typid),
+ 0,0,0))
+ return((bool)typtup.typbyval);
+ else
+ return(false);
+}
+
+/*
+ * get_typbyval -
+ *
+ * Given the type OID, determine whether the type is returned by value or
+ * not. Returns 1 if by value, 0 if by reference.
+ *
+ */
+char
+get_typalign(Oid typid)
+{
+ TypeTupleFormData typtup;
+
+ if (SearchSysCacheStruct(TYPOID, (char *) &typtup,
+ ObjectIdGetDatum(typid),
+ 0,0,0))
+ return(typtup.typalign);
+ else
+ return ('i');
+}
+
+/*
+ * get_typdefault -
+ *
+ * Given the type OID, return the default value of the ADT.
+ *
+ */
+struct varlena *
+get_typdefault(Oid typid)
+{
+ struct varlena *typdefault =
+ (struct varlena *)TypeDefaultRetrieve (typid);
+ return(typdefault);
+}
+
+/*
+ * get_typtype -
+ *
+ * Given the type OID, find if it is a basic type, a named relation
+ * or the generic type 'relation'.
+ * It returns the null char if the cache lookup fails...
+ *
+ */
+char
+get_typtype(Oid typid)
+{
+ TypeTupleFormData typtup;
+
+ if (SearchSysCacheStruct(TYPOID, (char *) &typtup,
+ ObjectIdGetDatum(typid),
+ 0,0,0)) {
+ return(typtup.typtype);
+ } else {
+ return('\0');
+ }
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * rel.c--
+ * POSTGRES relation descriptor code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/Attic/rel.c,v 1.1.1.1 1996/07/09 06:22:06 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/* #define RELREFDEBUG 1 */
+
+#include "postgres.h"
+#include "miscadmin.h"
+#include "access/istrat.h"
+#include "access/tupdesc.h"
+#include "utils/rel.h"
+#include "storage/fd.h"
+
+
+/*
+ * RelationIsValid is now a macro in rel.h -cim 4/27/91
+ *
+ * Many of the RelationGet...() functions are now macros in rel.h
+ * -mer 3/2/92
+ */
+
+/*
+ * RelationGetIndexStrategy --
+ * Returns index strategy for a relation.
+ *
+ * Note:
+ * Assumes relation descriptor is valid.
+ * Assumes relation descriptor is for an index relation.
+ */
+IndexStrategy
+RelationGetIndexStrategy(Relation relation)
+{
+ return relation->rd_istrat;
+}
+
+/*
+ * RelationSetIndexSupport --
+ * Sets index strategy and support info for a relation.
+ *
+ * Note:
+ * Assumes relation descriptor is a valid pointer to sufficient space.
+ * Assumes index strategy is valid. Assumes support is valid if non-
+ * NULL.
+ */
+/* ----------------
+ * RelationSetIndexSupport
+ *
+ * This routine saves two pointers -- one to the IndexStrategy, and
+ * one to the RegProcs that support the indexed access method. These
+ * pointers are stored in the space following the attribute data in the
+ * reldesc.
+ *
+ * NEW: the index strategy and support are now stored in real fields
+ * at the end of the structure - jolly
+ * ----------------
+ */
+void
+RelationSetIndexSupport(Relation relation,
+ IndexStrategy strategy,
+ RegProcedure *support)
+{
+ Assert(PointerIsValid(relation));
+ Assert(IndexStrategyIsValid(strategy));
+
+ relation->rd_istrat = strategy;
+ relation->rd_support = support;
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * relcache.c--
+ * POSTGRES relation descriptor cache code
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.1.1.1 1996/07/09 06:22:06 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ * INTERFACE ROUTINES
+ * RelationInitialize - initialize relcache
+ * RelationIdCacheGetRelation - get a reldesc from the cache (id)
+ * RelationNameCacheGetRelation - get a reldesc from the cache (name)
+ * RelationIdGetRelation - get a reldesc by relation id
+ * RelationNameGetRelation - get a reldesc by relation name
+ * RelationClose - close an open relation
+ * RelationFlushRelation - flush relation information
+ *
+ * NOTES
+ * This file is in the process of being cleaned up
+ * before I add system attribute indexing. -cim 1/13/91
+ *
+ * The following code contains many undocumented hacks. Please be
+ * careful....
+ *
+ */
+#include /* for sprintf() */
+#include
+#include
+#include
+
+#include "postgres.h"
+#include "miscadmin.h"
+
+#include "access/attnum.h"
+#include "access/genam.h"
+#include "access/heapam.h"
+#include "access/htup.h"
+#include "access/istrat.h"
+#include "access/itup.h"
+#include "access/skey.h"
+#include "utils/builtins.h"
+#include "utils/tqual.h" /* for NowTimeQual */
+#include "access/tupdesc.h"
+#include "access/tupmacs.h"
+#include "access/xact.h"
+
+#include "storage/buf.h"
+#include "storage/fd.h" /* for SEEK_ */
+#include "storage/lmgr.h"
+#include "storage/bufmgr.h"
+
+
+#include "lib/hasht.h"
+
+#include "utils/memutils.h"
+#include "utils/elog.h"
+#include "utils/mcxt.h"
+#include "utils/rel.h"
+#include "utils/relcache.h"
+#include "utils/hsearch.h"
+#include "utils/palloc.h"
+#include "utils/relcache.h"
+
+#include "catalog/catname.h"
+#include "catalog/catalog.h"
+#include "utils/syscache.h"
+
+#include "catalog/pg_attribute.h"
+#include "catalog/pg_aggregate.h"
+#include "catalog/pg_index.h"
+#include "catalog/pg_proc.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_rewrite.h"
+#include "catalog/pg_type.h"
+
+#include "catalog/pg_variable.h"
+#include "catalog/pg_log.h"
+#include "catalog/pg_time.h"
+#include "catalog/indexing.h"
+#include "catalog/index.h"
+#include "fmgr.h"
+
+/* ----------------
+ * defines
+ * ----------------
+ */
+#define private static
+#define INIT_FILENAME "pg_internal.init"
+
+/* ----------------
+ * externs
+ * ----------------
+ */
+extern bool AMI_OVERRIDE; /* XXX style */
+extern GlobalMemory CacheCxt; /* from utils/cache/catcache.c */
+
+/* ----------------
+ * hardcoded tuple descriptors. see lib/backend/catalog/pg_attribute.h
+ * ----------------
+ */
+FormData_pg_attribute Desc_pg_class[Natts_pg_class] = { Schema_pg_class };
+FormData_pg_attribute Desc_pg_attribute[Natts_pg_attribute] = { Schema_pg_attribute };
+FormData_pg_attribute Desc_pg_proc[Natts_pg_proc] = { Schema_pg_proc };
+FormData_pg_attribute Desc_pg_type[Natts_pg_type] = { Schema_pg_type };
+FormData_pg_attribute Desc_pg_variable[Natts_pg_variable] = { Schema_pg_variable };
+FormData_pg_attribute Desc_pg_log[Natts_pg_log] = { Schema_pg_log };
+FormData_pg_attribute Desc_pg_time[Natts_pg_time] = { Schema_pg_time };
+
+/* ----------------
+ * global variables
+ *
+ * Relations are cached two ways, by name and by id,
+ * thus there are two hash tables for referencing them.
+ * ----------------
+ */
+HTAB *RelationNameCache;
+HTAB *RelationIdCache;
+
+/* ----------------
+ * RelationBuildDescInfo exists so code can be shared
+ * between RelationIdGetRelation() and RelationNameGetRelation()
+ * ----------------
+ */
+typedef struct RelationBuildDescInfo {
+ int infotype; /* lookup by id or by name */
+#define INFO_RELID 1
+#define INFO_RELNAME 2
+ union {
+ Oid info_id; /* relation object id */
+ char *info_name; /* relation name */
+ } i;
+} RelationBuildDescInfo;
+
+typedef struct relidcacheent {
+ Oid reloid;
+ Relation reldesc;
+} RelIdCacheEnt;
+
+typedef struct relnamecacheent {
+ NameData relname;
+ Relation reldesc;
+} RelNameCacheEnt;
+
+/* -----------------
+ * macros to manipulate name cache and id cache
+ * -----------------
+ */
+#define RelationCacheInsert(RELATION) \
+ { RelIdCacheEnt *idhentry; RelNameCacheEnt *namehentry; \
+ char *relname; Oid reloid; bool found; \
+ relname = (RELATION->rd_rel->relname).data; \
+ namehentry = (RelNameCacheEnt*)hash_search(RelationNameCache, \
+ relname, \
+ HASH_ENTER, \
+ &found); \
+ if (namehentry == NULL) { \
+ elog(FATAL, "can't insert into relation descriptor cache"); \
+ } \
+ if (found && !IsBootstrapProcessingMode()) { \
+ /* used to give notice -- now just keep quiet */ ; \
+ } \
+ namehentry->reldesc = RELATION; \
+ reloid = RELATION->rd_id; \
+ idhentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \
+ (char *)&reloid, \
+ HASH_ENTER, \
+ &found); \
+ if (idhentry == NULL) { \
+ elog(FATAL, "can't insert into relation descriptor cache"); \
+ } \
+ if (found && !IsBootstrapProcessingMode()) { \
+ /* used to give notice -- now just keep quiet */ ; \
+ } \
+ idhentry->reldesc = RELATION; \
+ }
+#define RelationNameCacheLookup(NAME, RELATION) \
+ { RelNameCacheEnt *hentry; bool found; \
+ hentry = (RelNameCacheEnt*)hash_search(RelationNameCache, \
+ (char *)NAME,HASH_FIND,&found); \
+ if (hentry == NULL) { \
+ elog(FATAL, "error in CACHE"); \
+ } \
+ if (found) { \
+ RELATION = hentry->reldesc; \
+ } \
+ else { \
+ RELATION = NULL; \
+ } \
+ }
+#define RelationIdCacheLookup(ID, RELATION) \
+ { RelIdCacheEnt *hentry; bool found; \
+ hentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \
+ (char *)&(ID),HASH_FIND, &found); \
+ if (hentry == NULL) { \
+ elog(FATAL, "error in CACHE"); \
+ } \
+ if (found) { \
+ RELATION = hentry->reldesc; \
+ } \
+ else { \
+ RELATION = NULL; \
+ } \
+ }
+#define RelationCacheDelete(RELATION) \
+ { RelNameCacheEnt *namehentry; RelIdCacheEnt *idhentry; \
+ char *relname; Oid reloid; bool found; \
+ relname = (RELATION->rd_rel->relname).data; \
+ namehentry = (RelNameCacheEnt*)hash_search(RelationNameCache, \
+ relname, \
+ HASH_REMOVE, \
+ &found); \
+ if (namehentry == NULL) { \
+ elog(FATAL, "can't delete from relation descriptor cache"); \
+ } \
+ if (!found) { \
+ elog(NOTICE, "trying to delete a reldesc that does not exist."); \
+ } \
+ reloid = RELATION->rd_id; \
+ idhentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \
+ (char *)&reloid, \
+ HASH_REMOVE, &found); \
+ if (idhentry == NULL) { \
+ elog(FATAL, "can't delete from relation descriptor cache"); \
+ } \
+ if (!found) { \
+ elog(NOTICE, "trying to delete a reldesc that does not exist."); \
+ } \
+ }
+
+/* non-export function prototypes */
+static void formrdesc(char *relationName, u_int natts,
+ FormData_pg_attribute att[]);
+
+static void RelationFlushIndexes(Relation *r, Oid accessMethodId);
+
+static char *BuildDescInfoError(RelationBuildDescInfo buildinfo);
+static HeapTuple ScanPgRelation(RelationBuildDescInfo buildinfo);
+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,
+ Relation relation, AttributeTupleForm attp, u_int natts);
+static void build_tupdesc_seq(RelationBuildDescInfo buildinfo,
+ Relation relation, AttributeTupleForm attp, u_int natts);
+static void build_tupdesc_ind(RelationBuildDescInfo buildinfo,
+ Relation relation, AttributeTupleForm attp, u_int natts);
+static Relation RelationBuildDesc(RelationBuildDescInfo buildinfo);
+static void IndexedAccessMethodInitialize(Relation relation);
+
+/* ----------------------------------------------------------------
+ * RelationIdGetRelation() and RelationNameGetRelation()
+ * support functions
+ * ----------------------------------------------------------------
+ */
+
+
+/* --------------------------------
+ * BuildDescInfoError returns a string appropriate to
+ * the buildinfo passed to it
+ * --------------------------------
+ */
+static char *
+BuildDescInfoError(RelationBuildDescInfo buildinfo)
+{
+ static char errBuf[64];
+
+ memset(errBuf, 0, (int) sizeof(errBuf));
+ switch(buildinfo.infotype) {
+ case INFO_RELID:
+ sprintf(errBuf, "(relation id %d)", buildinfo.i.info_id);
+ break;
+ case INFO_RELNAME:
+ sprintf(errBuf, "(relation name %.*s)", NAMEDATALEN, buildinfo.i.info_name);
+ break;
+ }
+
+ return errBuf;
+}
+
+/* --------------------------------
+ * ScanPgRelation
+ *
+ * this is used by RelationBuildDesc to find a pg_class
+ * tuple matching either a relation name or a relation id
+ * as specified in buildinfo.
+ * --------------------------------
+ */
+static HeapTuple
+ScanPgRelation(RelationBuildDescInfo buildinfo)
+{
+ /*
+ * If this is bootstrap time (initdb), then we can't use the system
+ * catalog indices, because they may not exist yet. Otherwise, we
+ * can, and do.
+ */
+
+ if (IsBootstrapProcessingMode())
+ return (scan_pg_rel_seq(buildinfo));
+ else
+ return (scan_pg_rel_ind(buildinfo));
+}
+
+static HeapTuple
+scan_pg_rel_seq(RelationBuildDescInfo buildinfo)
+{
+ HeapTuple pg_class_tuple;
+ HeapTuple return_tuple;
+ Relation pg_class_desc;
+ HeapScanDesc pg_class_scan;
+ ScanKeyData key;
+ Buffer buf;
+
+ /* ----------------
+ * form a scan key
+ * ----------------
+ */
+ switch (buildinfo.infotype) {
+ case INFO_RELID:
+ ScanKeyEntryInitialize(&key, 0,
+ ObjectIdAttributeNumber,
+ ObjectIdEqualRegProcedure,
+ ObjectIdGetDatum(buildinfo.i.info_id));
+ break;
+
+ case INFO_RELNAME:
+ ScanKeyEntryInitialize(&key, 0,
+ Anum_pg_class_relname,
+ Character16EqualRegProcedure,
+ NameGetDatum(buildinfo.i.info_name));
+ break;
+
+ default:
+ elog(WARN, "ScanPgRelation: bad buildinfo");
+ return NULL;
+ }
+
+ /* ----------------
+ * open pg_class and fetch a tuple
+ * ----------------
+ */
+ pg_class_desc = heap_openr(RelationRelationName);
+ if (!IsInitProcessingMode())
+ RelationSetLockForRead(pg_class_desc);
+ pg_class_scan =
+ heap_beginscan(pg_class_desc, 0, NowTimeQual, 1, &key);
+ pg_class_tuple = heap_getnext(pg_class_scan, 0, &buf);
+
+ /* ----------------
+ * get set to return tuple
+ * ----------------
+ */
+ if (! HeapTupleIsValid(pg_class_tuple)) {
+ return_tuple = pg_class_tuple;
+ } else {
+ /* ------------------
+ * a satanic bug used to live here: pg_class_tuple used to be
+ * returned here without having the corresponding buffer pinned.
+ * so when the buffer gets replaced, all hell breaks loose.
+ * this bug is discovered and killed by wei on 9/27/91.
+ * -------------------
+ */
+ return_tuple = (HeapTuple) palloc((Size) pg_class_tuple->t_len);
+ memmove((char *) return_tuple,
+ (char *) pg_class_tuple,
+ (int) pg_class_tuple->t_len);
+ ReleaseBuffer(buf);
+ }
+
+ /* all done */
+ heap_endscan(pg_class_scan);
+ if (!IsInitProcessingMode())
+ RelationUnsetLockForRead(pg_class_desc);
+ heap_close(pg_class_desc);
+
+ return return_tuple;
+}
+
+static HeapTuple
+scan_pg_rel_ind(RelationBuildDescInfo buildinfo)
+{
+ Relation pg_class_desc;
+ HeapTuple return_tuple;
+
+ pg_class_desc = heap_openr(RelationRelationName);
+ if (!IsInitProcessingMode())
+ RelationSetLockForRead(pg_class_desc);
+
+ switch (buildinfo.infotype) {
+ case INFO_RELID:
+ return_tuple = ClassOidIndexScan(pg_class_desc, buildinfo.i.info_id);
+ break;
+
+ case INFO_RELNAME:
+ return_tuple = ClassNameIndexScan(pg_class_desc,
+ buildinfo.i.info_name);
+ break;
+
+ default:
+ elog(WARN, "ScanPgRelation: bad buildinfo");
+ }
+
+ /* all done */
+ if (!IsInitProcessingMode())
+ RelationUnsetLockForRead(pg_class_desc);
+ heap_close(pg_class_desc);
+
+ return return_tuple;
+}
+
+/* ----------------
+ * AllocateRelationDesc
+ *
+ * This is used to allocate memory for a new relation descriptor
+ * and initialize the rd_rel field.
+ * ----------------
+ */
+static Relation
+AllocateRelationDesc(u_int natts, Form_pg_class relp)
+{
+ Relation relation;
+ Size len;
+ Form_pg_class relationTupleForm;
+
+ /* ----------------
+ * allocate space for the relation tuple form
+ * ----------------
+ */
+ relationTupleForm = (Form_pg_class)
+ palloc((Size) (sizeof(FormData_pg_class)));
+
+ memmove((char *) relationTupleForm, (char *) relp, CLASS_TUPLE_SIZE);
+
+ /* ----------------
+ * allocate space for new relation descriptor
+ */
+ len = sizeof(RelationData) + 10; /* + 10 is voodoo XXX mao */
+
+ relation = (Relation) palloc(len);
+
+ /* ----------------
+ * clear new reldesc
+ * ----------------
+ */
+ memset((char *) relation, 0, len);
+
+ /* initialize attribute tuple form */
+ relation->rd_att = CreateTemplateTupleDesc(natts);
+
+ /*and initialize relation tuple form */
+ relation->rd_rel = relationTupleForm;
+
+ return relation;
+}
+
+/* --------------------------------
+ * RelationBuildTupleDesc
+ *
+ * Form the relation's tuple descriptor from information in
+ * the pg_attribute system catalog.
+ * --------------------------------
+ */
+static void
+RelationBuildTupleDesc(RelationBuildDescInfo buildinfo,
+ Relation relation,
+ AttributeTupleForm attp,
+ u_int natts)
+{
+ /*
+ * If this is bootstrap time (initdb), then we can't use the system
+ * catalog indices, because they may not exist yet. Otherwise, we
+ * can, and do.
+ */
+
+ if (IsBootstrapProcessingMode())
+ build_tupdesc_seq(buildinfo, relation, attp, natts);
+ else
+ build_tupdesc_ind(buildinfo, relation, attp, natts);
+}
+
+static void
+build_tupdesc_seq(RelationBuildDescInfo buildinfo,
+ Relation relation,
+ AttributeTupleForm attp,
+ u_int natts)
+{
+ HeapTuple pg_attribute_tuple;
+ Relation pg_attribute_desc;
+ HeapScanDesc pg_attribute_scan;
+ ScanKeyData key;
+ int need;
+
+ /* ----------------
+ * form a scan key
+ * ----------------
+ */
+ ScanKeyEntryInitialize(&key, 0,
+ Anum_pg_attribute_attrelid,
+ ObjectIdEqualRegProcedure,
+ ObjectIdGetDatum(relation->rd_id));
+
+ /* ----------------
+ * open pg_attribute and begin a scan
+ * ----------------
+ */
+ pg_attribute_desc = heap_openr(AttributeRelationName);
+ pg_attribute_scan =
+ heap_beginscan(pg_attribute_desc, 0, NowTimeQual, 1, &key);
+
+ /* ----------------
+ * add attribute data to relation->rd_att
+ * ----------------
+ */
+ need = natts;
+ pg_attribute_tuple = heap_getnext(pg_attribute_scan, 0, (Buffer *) NULL);
+ while (HeapTupleIsValid(pg_attribute_tuple) && need > 0) {
+ attp = (AttributeTupleForm) GETSTRUCT(pg_attribute_tuple);
+
+ if (attp->attnum > 0) {
+ relation->rd_att->attrs[attp->attnum - 1] =
+ (AttributeTupleForm)palloc(ATTRIBUTE_TUPLE_SIZE);
+
+ memmove((char *) (relation->rd_att->attrs[attp->attnum - 1]),
+ (char *) attp,
+ ATTRIBUTE_TUPLE_SIZE);
+ need--;
+ }
+ pg_attribute_tuple = heap_getnext(pg_attribute_scan,
+ 0, (Buffer *) NULL);
+ }
+
+ if (need > 0)
+ elog(WARN, "catalog is missing %d attribute%s for relid %d",
+ need, (need == 1 ? "" : "s"), relation->rd_id);
+
+ /* ----------------
+ * end the scan and close the attribute relation
+ * ----------------
+ */
+ heap_endscan(pg_attribute_scan);
+ heap_close(pg_attribute_desc);
+}
+
+static void
+build_tupdesc_ind(RelationBuildDescInfo buildinfo,
+ Relation relation,
+ AttributeTupleForm attp,
+ u_int natts)
+{
+ Relation attrel;
+ HeapTuple atttup;
+ int i;
+
+ attrel = heap_openr(AttributeRelationName);
+
+ for (i = 1; i <= relation->rd_rel->relnatts; i++) {
+
+ atttup = (HeapTuple) AttributeNumIndexScan(attrel, relation->rd_id, i);
+
+ if (!HeapTupleIsValid(atttup))
+ elog(WARN, "cannot find attribute %d of relation %.16s", i,
+ &(relation->rd_rel->relname.data[0]));
+ attp = (AttributeTupleForm) GETSTRUCT(atttup);
+
+ relation->rd_att->attrs[i - 1] =
+ (AttributeTupleForm) palloc(ATTRIBUTE_TUPLE_SIZE);
+
+ memmove((char *) (relation->rd_att->attrs[i - 1]),
+ (char *) attp,
+ ATTRIBUTE_TUPLE_SIZE);
+ }
+
+ heap_close(attrel);
+}
+
+/* --------------------------------
+ * RelationBuildRuleLock
+ *
+ * Form the relation's rewrite rules from information in
+ * the pg_rewrite system catalog.
+ * --------------------------------
+ */
+static void
+RelationBuildRuleLock(Relation relation)
+{
+ HeapTuple pg_rewrite_tuple;
+ Relation pg_rewrite_desc;
+ TupleDesc pg_rewrite_tupdesc;
+ HeapScanDesc pg_rewrite_scan;
+ ScanKeyData key;
+ RuleLock *rulelock;
+ int numlocks;
+ RewriteRule **rules;
+ int maxlocks;
+
+ /* ----------------
+ * form an array to hold the rewrite rules (the array is extended if
+ * necessary)
+ * ----------------
+ */
+ maxlocks = 4;
+ rules = (RewriteRule **)palloc(sizeof(RewriteRule*)*maxlocks);
+ numlocks = 0;
+
+ /* ----------------
+ * form a scan key
+ * ----------------
+ */
+ ScanKeyEntryInitialize(&key, 0,
+ Anum_pg_rewrite_ev_class,
+ ObjectIdEqualRegProcedure,
+ ObjectIdGetDatum(relation->rd_id));
+
+ /* ----------------
+ * open pg_attribute and begin a scan
+ * ----------------
+ */
+ pg_rewrite_desc = heap_openr(RewriteRelationName);
+ pg_rewrite_scan =
+ heap_beginscan(pg_rewrite_desc, 0, NowTimeQual, 1, &key);
+ pg_rewrite_tupdesc =
+ RelationGetTupleDescriptor(pg_rewrite_desc);
+
+ /* ----------------
+ * add attribute data to relation->rd_att
+ * ----------------
+ */
+ while ((pg_rewrite_tuple = heap_getnext(pg_rewrite_scan, 0,
+ (Buffer *) NULL)) != NULL) {
+ bool isnull;
+ char *ruleaction = NULL;
+ char *rule_evqual_string;
+ RewriteRule *rule;
+
+ rule = (RewriteRule *)palloc(sizeof(RewriteRule));
+
+ rule->ruleId = pg_rewrite_tuple->t_oid;
+
+ /* XXX too lazy to fix the type cast problem
+ * (see rewriteDefine.c:121)
+ */
+ rule->event =
+ (CmdType)((char)heap_getattr(pg_rewrite_tuple, InvalidBuffer,
+ Anum_pg_rewrite_ev_type, pg_rewrite_tupdesc,
+ &isnull) - 48);
+ rule->attrno =
+ (AttrNumber)heap_getattr(pg_rewrite_tuple, InvalidBuffer,
+ Anum_pg_rewrite_ev_attr, pg_rewrite_tupdesc,
+ &isnull);
+ rule->isInstead =
+ (bool)heap_getattr(pg_rewrite_tuple, InvalidBuffer,
+ Anum_pg_rewrite_is_instead, pg_rewrite_tupdesc,
+ &isnull);
+
+ ruleaction =
+ heap_getattr(pg_rewrite_tuple, InvalidBuffer,
+ Anum_pg_rewrite_action, pg_rewrite_tupdesc,
+ &isnull);
+ rule_evqual_string =
+ heap_getattr(pg_rewrite_tuple, InvalidBuffer,
+ Anum_pg_rewrite_ev_qual, pg_rewrite_tupdesc,
+ &isnull);
+
+ ruleaction = textout((struct varlena *)ruleaction);
+ rule_evqual_string = textout((struct varlena *)rule_evqual_string);
+
+ rule->actions = (List*)stringToNode(ruleaction);
+ rule->qual = (Node*)stringToNode(rule_evqual_string);
+
+ rules[numlocks++] = rule;
+ if (numlocks==maxlocks) {
+ maxlocks *= 2;
+ rules =
+ (RewriteRule **)repalloc(rules, sizeof(RewriteRule*)*maxlocks);
+ }
+ }
+
+ /* ----------------
+ * end the scan and close the attribute relation
+ * ----------------
+ */
+ heap_endscan(pg_rewrite_scan);
+ heap_close(pg_rewrite_desc);
+
+ /* ----------------
+ * form a RuleLock and insert into relation
+ * ----------------
+ */
+ rulelock = (RuleLock *)palloc(sizeof(RuleLock));
+ rulelock->numLocks = numlocks;
+ rulelock->rules = rules;
+
+ relation->rd_rules = rulelock;
+ return;
+}
+
+
+/* --------------------------------
+ * RelationBuildDesc
+ *
+ * To build a relation descriptor, we have to allocate space,
+ * open the underlying unix file and initialize the following
+ * fields:
+ *
+ * File rd_fd; open file descriptor
+ * int rd_nblocks; number of blocks in rel
+ * it will be set in ambeginscan()
+ * uint16 rd_refcnt; reference count
+ * Form_pg_am rd_am; AM tuple
+ * Form_pg_class rd_rel; RELATION tuple
+ * Oid rd_id; relations's object id
+ * Pointer lockInfo; ptr. to misc. info.
+ * TupleDesc rd_att; tuple desciptor
+ *
+ * Note: rd_ismem (rel is in-memory only) is currently unused
+ * by any part of the system. someday this will indicate that
+ * the relation lives only in the main-memory buffer pool
+ * -cim 2/4/91
+ * --------------------------------
+ */
+static Relation
+RelationBuildDesc(RelationBuildDescInfo buildinfo)
+{
+ File fd;
+ Relation relation;
+ u_int natts;
+ Oid relid;
+ Oid relam;
+ Form_pg_class relp;
+ AttributeTupleForm attp = NULL;
+
+ MemoryContext oldcxt;
+
+ HeapTuple pg_class_tuple;
+
+ oldcxt = MemoryContextSwitchTo((MemoryContext)CacheCxt);
+
+ /* ----------------
+ * find the tuple in pg_class corresponding to the given relation id
+ * ----------------
+ */
+ pg_class_tuple = ScanPgRelation(buildinfo);
+
+ /* ----------------
+ * if no such tuple exists, return NULL
+ * ----------------
+ */
+ if (! HeapTupleIsValid(pg_class_tuple)) {
+
+ MemoryContextSwitchTo(oldcxt);
+
+ return NULL;
+ }
+
+ /* ----------------
+ * get information from the pg_class_tuple
+ * ----------------
+ */
+ relid = pg_class_tuple->t_oid;
+ relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
+ natts = relp->relnatts;
+
+ /* ----------------
+ * allocate storage for the relation descriptor,
+ * initialize relation->rd_rel and get the access method id.
+ * ----------------
+ */
+ relation = AllocateRelationDesc(natts, relp);
+ relam = relation->rd_rel->relam;
+
+ /* ----------------
+ * initialize the relation's relation id (relation->rd_id)
+ * ----------------
+ */
+ relation->rd_id = relid;
+
+ /* ----------------
+ * initialize relation->rd_refcnt
+ * ----------------
+ */
+ RelationSetReferenceCount(relation, 1);
+
+ /* ----------------
+ * normal relations are not nailed into the cache
+ * ----------------
+ */
+ relation->rd_isnailed = false;
+
+ /* ----------------
+ * initialize the access method information (relation->rd_am)
+ * ----------------
+ */
+ if (OidIsValid(relam)) {
+ relation->rd_am = (Form_pg_am)
+ AccessMethodObjectIdGetAccessMethodTupleForm(relam);
+ }
+
+ /* ----------------
+ * initialize the tuple descriptor (relation->rd_att).
+ * remember, rd_att is an array of attribute pointers that lives
+ * off the end of the relation descriptor structure so space was
+ * already allocated for it by AllocateRelationDesc.
+ * ----------------
+ */
+ RelationBuildTupleDesc(buildinfo, relation, attp, natts);
+
+ /* ----------------
+ * initialize rules that affect this relation
+ * ----------------
+ */
+ if (relp->relhasrules) {
+ RelationBuildRuleLock(relation);
+ } else {
+ relation->rd_rules = NULL;
+ }
+
+ /* ----------------
+ * initialize index strategy and support information for this relation
+ * ----------------
+ */
+ if (OidIsValid(relam)) {
+ IndexedAccessMethodInitialize(relation);
+ }
+
+ /* ----------------
+ * initialize the relation lock manager information
+ * ----------------
+ */
+ RelationInitLockInfo(relation); /* see lmgr.c */
+
+ /* ----------------
+ * open the relation and assign the file descriptor returned
+ * by the storage manager code to rd_fd.
+ * ----------------
+ */
+ fd = smgropen(relp->relsmgr, relation);
+
+ Assert (fd >= -1);
+ if (fd == -1)
+ elog(NOTICE, "RelationIdBuildRelation: smgropen(%s): %m",
+ &relp->relname);
+
+ relation->rd_fd = fd;
+
+ /* ----------------
+ * insert newly created relation into proper relcaches,
+ * restore memory context and return the new reldesc.
+ * ----------------
+ */
+
+ RelationCacheInsert(relation);
+
+ /* -------------------
+ * free the memory allocated for pg_class_tuple
+ * and for lock data pointed to by pg_class_tuple
+ * -------------------
+ */
+ pfree(pg_class_tuple);
+
+ MemoryContextSwitchTo(oldcxt);
+
+ return relation;
+}
+
+static void
+IndexedAccessMethodInitialize(Relation relation)
+{
+ IndexStrategy strategy;
+ RegProcedure *support;
+ int natts;
+ Size stratSize;
+ Size supportSize;
+ uint16 relamstrategies;
+ uint16 relamsupport;
+
+ natts = relation->rd_rel->relnatts;
+ relamstrategies = relation->rd_am->amstrategies;
+ stratSize = AttributeNumberGetIndexStrategySize(natts, relamstrategies);
+ strategy = (IndexStrategy) palloc(stratSize);
+ relamsupport = relation->rd_am->amsupport;
+
+ if (relamsupport > 0) {
+ supportSize = natts * (relamsupport * sizeof (RegProcedure));
+ support = (RegProcedure *) palloc(supportSize);
+ } else {
+ support = (RegProcedure *) NULL;
+ }
+
+ IndexSupportInitialize(strategy, support,
+ relation->rd_att->attrs[0]->attrelid,
+ relation->rd_rel->relam,
+ relamstrategies, relamsupport, natts);
+
+ RelationSetIndexSupport(relation, strategy, support);
+}
+
+/* --------------------------------
+ * formrdesc
+ *
+ * This is a special version of RelationBuildDesc()
+ * used by RelationInitialize() in initializing the
+ * relcache. The system relation descriptors built
+ * here are all nailed in the descriptor caches, for
+ * bootstrapping.
+ * --------------------------------
+ */
+static void
+formrdesc(char *relationName,
+ u_int natts,
+ FormData_pg_attribute att[])
+{
+ Relation relation;
+ Size len;
+ int i;
+
+ /* ----------------
+ * allocate new relation desc
+ * ----------------
+ */
+ len = sizeof (RelationData);
+ relation = (Relation) palloc(len);
+ memset((char *)relation, 0,len);
+
+ /* ----------------
+ * don't open the unix file yet..
+ * ----------------
+ */
+ relation->rd_fd = -1;
+
+ /* ----------------
+ * initialize reference count
+ * ----------------
+ */
+ RelationSetReferenceCount(relation, 1);
+
+ /* ----------------
+ * initialize relation tuple form
+ * ----------------
+ */
+ relation->rd_rel = (Form_pg_class)
+ palloc((Size) (sizeof(*relation->rd_rel)));
+ memset(relation->rd_rel, 0, sizeof(FormData_pg_class));
+ namestrcpy(&relation->rd_rel->relname, relationName);
+
+ /* ----------------
+ initialize attribute tuple form
+ */
+ relation->rd_att = CreateTemplateTupleDesc(natts);
+
+ /*
+ * For debugging purposes, it's important to distinguish between
+ * shared and non-shared relations, even at bootstrap time. There's
+ * code in the buffer manager that traces allocations that has to
+ * know about this.
+ */
+
+ if (IsSystemRelationName(relationName)) {
+ relation->rd_rel->relowner = 6; /* XXX use sym const */
+ relation->rd_rel->relisshared =
+ IsSharedSystemRelationName(relationName);
+ } else {
+ relation->rd_rel->relowner = InvalidOid; /* XXX incorrect*/
+ relation->rd_rel->relisshared = false;
+ }
+
+ relation->rd_rel->relpages = 1; /* XXX */
+ relation->rd_rel->reltuples = 1; /* XXX */
+ relation->rd_rel->relkind = RELKIND_RELATION;
+ relation->rd_rel->relarch = 'n';
+ relation->rd_rel->relnatts = (uint16) natts;
+ relation->rd_isnailed = true;
+
+ /* ----------------
+ * initialize tuple desc info
+ * ----------------
+ */
+ for (i = 0; i < natts; i++) {
+ relation->rd_att->attrs[i] =
+ (AttributeTupleForm)palloc(ATTRIBUTE_TUPLE_SIZE);
+
+ memset((char *)relation->rd_att->attrs[i], 0,
+ ATTRIBUTE_TUPLE_SIZE);
+ memmove((char *)relation->rd_att->attrs[i],
+ (char *)&att[i],
+ ATTRIBUTE_TUPLE_SIZE);
+ }
+
+ /* ----------------
+ * initialize relation id
+ * ----------------
+ */
+ relation->rd_id = relation->rd_att->attrs[0]->attrelid;
+
+ /* ----------------
+ * add new reldesc to relcache
+ * ----------------
+ */
+ RelationCacheInsert(relation);
+ /*
+ * Determining this requires a scan on pg_class, but to do the
+ * scan the rdesc for pg_class must already exist. Therefore
+ * we must do the check (and possible set) after cache insertion.
+ */
+ relation->rd_rel->relhasindex =
+ CatalogHasIndex(relationName, relation->rd_id);
+}
+
+
+/* ----------------------------------------------------------------
+ * Relation Descriptor Lookup Interface
+ * ----------------------------------------------------------------
+ */
+
+/* --------------------------------
+ * RelationIdCacheGetRelation
+ *
+ * only try to get the reldesc by looking up the cache
+ * do not go to the disk. this is used by BlockPrepareFile()
+ * and RelationIdGetRelation below.
+ * --------------------------------
+ */
+Relation
+RelationIdCacheGetRelation(Oid relationId)
+{
+ Relation rd;
+
+ RelationIdCacheLookup(relationId, rd);
+
+ if (RelationIsValid(rd)) {
+ if (rd->rd_fd == -1) {
+ rd->rd_fd = smgropen(rd->rd_rel->relsmgr, rd);
+ Assert(rd->rd_fd != -1);
+ }
+
+ RelationIncrementReferenceCount(rd);
+ RelationSetLockForDescriptorOpen(rd);
+
+ }
+
+ return(rd);
+}
+
+/* --------------------------------
+ * RelationNameCacheGetRelation
+ * --------------------------------
+ */
+Relation
+RelationNameCacheGetRelation(char *relationName)
+{
+ Relation rd;
+ NameData name;
+
+ /* make sure that the name key used for hash lookup is properly
+ null-padded */
+ memset(&name,0, NAMEDATALEN);
+ namestrcpy(&name, relationName);
+ RelationNameCacheLookup(name.data, rd);
+
+ if (RelationIsValid(rd)) {
+ if (rd->rd_fd == -1) {
+ rd->rd_fd = smgropen(rd->rd_rel->relsmgr, rd);
+ Assert(rd->rd_fd != -1);
+ }
+
+ RelationIncrementReferenceCount(rd);
+ RelationSetLockForDescriptorOpen(rd);
+
+ }
+
+ return(rd);
+}
+
+/* --------------------------------
+ * RelationIdGetRelation
+ *
+ * return a relation descriptor based on its id.
+ * return a cached value if possible
+ * --------------------------------
+ */
+Relation
+RelationIdGetRelation(Oid relationId)
+{
+ Relation rd;
+ RelationBuildDescInfo buildinfo;
+
+ /* ----------------
+ * increment access statistics
+ * ----------------
+ */
+ IncrHeapAccessStat(local_RelationIdGetRelation);
+ IncrHeapAccessStat(global_RelationIdGetRelation);
+
+ /* ----------------
+ * first try and get a reldesc from the cache
+ * ----------------
+ */
+ rd = RelationIdCacheGetRelation(relationId);
+ if (RelationIsValid(rd))
+ return rd;
+
+ /* ----------------
+ * no reldesc in the cache, so have RelationBuildDesc()
+ * build one and add it.
+ * ----------------
+ */
+ buildinfo.infotype = INFO_RELID;
+ buildinfo.i.info_id = relationId;
+
+ rd = RelationBuildDesc(buildinfo);
+ return
+ rd;
+}
+
+/* --------------------------------
+ * RelationNameGetRelation
+ *
+ * return a relation descriptor based on its name.
+ * return a cached value if possible
+ * --------------------------------
+ */
+Relation
+RelationNameGetRelation(char *relationName)
+{
+ Relation rd;
+ RelationBuildDescInfo buildinfo;
+
+ /* ----------------
+ * increment access statistics
+ * ----------------
+ */
+ IncrHeapAccessStat(local_RelationNameGetRelation);
+ IncrHeapAccessStat(global_RelationNameGetRelation);
+
+ /* ----------------
+ * first try and get a reldesc from the cache
+ * ----------------
+ */
+ rd = RelationNameCacheGetRelation(relationName);
+ if (RelationIsValid(rd))
+ return rd;
+
+ /* ----------------
+ * no reldesc in the cache, so have RelationBuildDesc()
+ * build one and add it.
+ * ----------------
+ */
+ buildinfo.infotype = INFO_RELNAME;
+ buildinfo.i.info_name = relationName;
+
+ rd = RelationBuildDesc(buildinfo);
+ return rd;
+}
+
+/* ----------------
+ * old "getreldesc" interface.
+ * ----------------
+ */
+Relation
+getreldesc(char *relationName)
+{
+ /* ----------------
+ * increment access statistics
+ * ----------------
+ */
+ IncrHeapAccessStat(local_getreldesc);
+ IncrHeapAccessStat(global_getreldesc);
+
+ return RelationNameGetRelation(relationName);
+}
+
+/* ----------------------------------------------------------------
+ * cache invalidation support routines
+ * ----------------------------------------------------------------
+ */
+
+/* --------------------------------
+ * RelationClose - close an open relation
+ * --------------------------------
+ */
+void
+RelationClose(Relation relation)
+{
+ /* Note: no locking manipulations needed */
+ RelationDecrementReferenceCount(relation);
+}
+
+/* --------------------------------
+ * RelationFlushRelation
+ *
+ * Actually blows away a relation... RelationFree doesn't do
+ * anything anymore.
+ * --------------------------------
+ */
+void
+RelationFlushRelation(Relation *relationPtr,
+ bool onlyFlushReferenceCountZero)
+{
+ int i;
+ AttributeTupleForm *p;
+ MemoryContext oldcxt;
+ Relation relation = *relationPtr;
+
+ if (relation->rd_isnailed) {
+ /* this is a nailed special relation for bootstraping */
+ return;
+ }
+
+ if (!onlyFlushReferenceCountZero ||
+ RelationHasReferenceCountZero(relation)) {
+
+ oldcxt = MemoryContextSwitchTo((MemoryContext)CacheCxt);
+
+ RelationCacheDelete(relation);
+
+ FileInvalidate(RelationGetSystemPort(relation));
+
+ i = relation->rd_rel->relnatts - 1;
+ p = &relation->rd_att->attrs[i];
+ while ((i -= 1) >= 0) {
+ pfree(*p--);
+ }
+
+#if 0
+ if (relation->rd_rules) {
+ int j;
+ for(j=0; j < relation->rd_rules->numLocks; j++) {
+ pfree(relation->rd_rules->rules[j]);
+ }
+ pfree(relation->rd_rules->rules);
+ pfree(relation->rd_rules);
+ }
+#endif
+
+ pfree(RelationGetLockInfo(relation));
+ pfree(RelationGetRelationTupleForm(relation));
+ pfree(relation);
+
+ MemoryContextSwitchTo(oldcxt);
+ }
+}
+
+/* --------------------------------
+ * RelationIdInvalidateRelationCacheByRelationId
+ * --------------------------------
+ */
+void
+RelationIdInvalidateRelationCacheByRelationId(Oid relationId)
+{
+ Relation relation;
+
+ RelationIdCacheLookup(relationId, relation);
+
+ /*
+ * "local" relations are invalidated by RelationPurgeLocalRelation.
+ * (This is to make LocalBufferSync's life easier: want the descriptor
+ * to hang around for a while. In fact, won't we want this for
+ * BufferSync also? But I'll leave it for now since I don't want to
+ * break anything.) - ay 3/95
+ */
+ if (PointerIsValid(relation) && !relation->rd_islocal) {
+ /*
+ * The boolean onlyFlushReferenceCountZero in RelationFlushReln()
+ * should be set to true when we are incrementing the command
+ * counter and to false when we are starting a new xaction. This
+ * can be determined by checking the current xaction status.
+ */
+ RelationFlushRelation(&relation, CurrentXactInProgress());
+ }
+}
+
+/* --------------------------------
+ * RelationIdInvalidateRelationCacheByAccessMethodId
+ *
+ * RelationFlushIndexes is needed for use with HashTableWalk..
+ * --------------------------------
+ */
+static void
+RelationFlushIndexes(Relation *r,
+ Oid accessMethodId)
+{
+ Relation relation = *r;
+
+ if (!RelationIsValid(relation)) {
+ elog(NOTICE, "inval call to RFI");
+ return;
+ }
+
+ if (relation->rd_rel->relkind == RELKIND_INDEX && /* XXX style */
+ (!OidIsValid(accessMethodId) ||
+ relation->rd_rel->relam == accessMethodId))
+ {
+ RelationFlushRelation(&relation, false);
+ }
+}
+
+void
+RelationIdInvalidateRelationCacheByAccessMethodId(Oid accessMethodId)
+{
+# if 0
+ /*
+ * 25 aug 1992: mao commented out the ht walk below. it should be
+ * doing the right thing, in theory, but flushing reldescs for index
+ * relations apparently doesn't work. we want to cut 4.0.1, and i
+ * don't want to introduce new bugs. this code never executed before,
+ * so i'm turning it off for now. after the release is cut, i'll
+ * fix this up.
+ */
+
+ HashTableWalk(RelationNameCache, (HashtFunc) RelationFlushIndexes,
+ accessMethodId);
+# else
+ return;
+# endif
+}
+
+/*
+ * RelationCacheInvalidate
+ *
+ * Will blow away either all the cached relation descriptors or
+ * those that have a zero reference count.
+ *
+ */
+void
+RelationCacheInvalidate(bool onlyFlushReferenceCountZero)
+{
+ HashTableWalk(RelationNameCache, (HashtFunc) RelationFlushRelation,
+ onlyFlushReferenceCountZero);
+
+ /*
+ * nailed-in reldescs will still be in the cache...
+ * 7 hardwired heaps + 3 hardwired indices == 10 total.
+ */
+ if (!onlyFlushReferenceCountZero) {
+ Assert(RelationNameCache->hctl->nkeys == 10);
+ Assert(RelationIdCache->hctl->nkeys == 10);
+ }
+}
+
+
+/*
+ * newlyCreatedRelns -
+ * relations created during this transaction. We need to keep track of
+ * these
+ */
+static List *newlyCreatedRelns = NULL;
+
+
+/* --------------------------------
+ * RelationRegisterRelation -
+ * register the Relation descriptor of a newly created relation
+ * with the relation descriptor Cache.
+ * --------------------------------
+ */
+void
+RelationRegisterRelation(Relation relation)
+{
+ MemoryContext oldcxt;
+
+ oldcxt = MemoryContextSwitchTo((MemoryContext)CacheCxt);
+
+ if (oldcxt != (MemoryContext)CacheCxt)
+ elog(NOIND,"RelationRegisterRelation: WARNING: Context != CacheCxt");
+
+ RelationCacheInsert(relation);
+
+ RelationInitLockInfo(relation);
+
+ /*
+ * we've just created the relation. It is invisible to anyone else
+ * before the transaction is committed. Setting rd_islocal allows us
+ * to use the local buffer manager for select/insert/etc before the end
+ * of transaction. (We also need to keep track of relations
+ * created during a transaction and does the necessary clean up at
+ * the end of the transaction.) - ay 3/95
+ */
+ relation->rd_islocal = TRUE;
+ newlyCreatedRelns = lcons(relation, newlyCreatedRelns);
+
+ MemoryContextSwitchTo(oldcxt);
+}
+
+/*
+ * RelationPurgeLocalRelation -
+ * find all the Relation descriptors marked rd_islocal and reset them.
+ * This should be called at the end of a transaction (commit/abort) when
+ * the "local" relations will become visible to others and the multi-user
+ * buffer pool should be used.
+ */
+void
+RelationPurgeLocalRelation(bool xactCommitted)
+{
+ MemoryContext oldcxt;
+
+ if (newlyCreatedRelns==NULL)
+ return;
+
+ oldcxt = MemoryContextSwitchTo((MemoryContext)CacheCxt);
+
+ while (newlyCreatedRelns) {
+ List *l = newlyCreatedRelns;
+ Relation reln = lfirst(l);
+
+ Assert(reln!=NULL && reln->rd_islocal);
+
+ if (!xactCommitted) {
+ /*
+ * remove the file if we abort. This is so that files for
+ * tables created inside a transaction block get removed.
+ */
+ smgrunlink(reln->rd_rel->relsmgr, reln);
+ }
+
+ reln->rd_islocal = FALSE;
+
+ if (!IsBootstrapProcessingMode())
+ RelationFlushRelation(&reln, FALSE);
+
+ newlyCreatedRelns = lnext(newlyCreatedRelns);
+ pfree(l);
+ }
+
+ MemoryContextSwitchTo(oldcxt);
+}
+
+/* --------------------------------
+ * RelationInitialize
+ *
+ * This initializes the relation descriptor cache.
+ * --------------------------------
+ */
+
+#define INITRELCACHESIZE 400
+
+void
+RelationInitialize()
+{
+ MemoryContext oldcxt;
+ HASHCTL ctl;
+
+ /* ----------------
+ * switch to cache memory context
+ * ----------------
+ */
+ if (!CacheCxt)
+ CacheCxt = CreateGlobalMemory("Cache");
+
+ oldcxt = MemoryContextSwitchTo((MemoryContext)CacheCxt);
+
+ /* ----------------
+ * create global caches
+ * ----------------
+ */
+ memset(&ctl,0, (int) sizeof(ctl));
+ ctl.keysize = sizeof(NameData);
+ ctl.datasize = sizeof(Relation);
+ RelationNameCache = hash_create(INITRELCACHESIZE, &ctl, HASH_ELEM);
+
+ ctl.keysize = sizeof(Oid);
+ ctl.hash = tag_hash;
+ RelationIdCache = hash_create(INITRELCACHESIZE, &ctl,
+ HASH_ELEM | HASH_FUNCTION);
+
+ /* ----------------
+ * initialize the cache with pre-made relation descriptors
+ * for some of the more important system relations. These
+ * relations should always be in the cache.
+ * ----------------
+ */
+ formrdesc(RelationRelationName, Natts_pg_class, Desc_pg_class);
+ formrdesc(AttributeRelationName, Natts_pg_attribute, Desc_pg_attribute);
+ formrdesc(ProcedureRelationName, Natts_pg_proc, Desc_pg_proc);
+ formrdesc(TypeRelationName, Natts_pg_type, Desc_pg_type);
+ formrdesc(VariableRelationName, Natts_pg_variable, Desc_pg_variable);
+ formrdesc(LogRelationName, Natts_pg_log, Desc_pg_log);
+ formrdesc(TimeRelationName, Natts_pg_time, Desc_pg_time);
+
+ /*
+ * If this isn't initdb time, then we want to initialize some index
+ * relation descriptors, as well. The descriptors are for pg_attnumind
+ * (to make building relation descriptors fast) and possibly others,
+ * as they're added.
+ */
+
+ if (!IsBootstrapProcessingMode())
+ init_irels();
+
+ MemoryContextSwitchTo(oldcxt);
+}
+
+/*
+ * init_irels(), write_irels() -- handle special-case initialization of
+ * index relation descriptors.
+ *
+ * In late 1992, we started regularly having databases with more than
+ * a thousand classes in them. With this number of classes, it became
+ * critical to do indexed lookups on the system catalogs.
+ *
+ * Bootstrapping these lookups is very hard. We want to be able to
+ * use an index on pg_attribute, for example, but in order to do so,
+ * we must have read pg_attribute for the attributes in the index,
+ * which implies that we need to use the index.
+ *
+ * In order to get around the problem, we do the following:
+ *
+ * + When the database system is initialized (at initdb time), we
+ * don't use indices on pg_attribute. We do sequential scans.
+ *
+ * + When the backend is started up in normal mode, we load an image
+ * of the appropriate relation descriptors, in internal format,
+ * from an initialization file in the data/base/... directory.
+ *
+ * + If the initialization file isn't there, then we create the
+ * relation descriptor using sequential scans and write it to
+ * the initialization file for use by subsequent backends.
+ *
+ * This is complicated and interferes with system changes, but
+ * performance is so bad that we're willing to pay the tax.
+ */
+
+/* pg_attnumind, pg_classnameind, pg_classoidind */
+#define Num_indices_bootstrap 3
+
+void
+init_irels()
+{
+ Size len;
+ int nread;
+ File fd;
+ Relation irel[Num_indices_bootstrap];
+ Relation ird;
+ Form_pg_am am;
+ Form_pg_class relform;
+ IndexStrategy strat;
+ RegProcedure *support;
+ int i;
+ int relno;
+
+ if ((fd = FileNameOpenFile(INIT_FILENAME, O_RDONLY, 0600)) < 0) {
+ write_irels();
+ return;
+ }
+
+ (void) FileSeek(fd, 0L, SEEK_SET);
+
+ for (relno = 0; relno < Num_indices_bootstrap; relno++) {
+ /* first read the relation descriptor length*/
+ if ((nread = FileRead(fd, (char*)&len, sizeof(int))) != sizeof(int)) {
+ write_irels();
+ return;
+ }
+
+ ird = irel[relno] = (Relation) palloc(len);
+ memset(ird, 0, len);
+
+ /* then, read the Relation structure */
+ if ((nread = FileRead(fd, (char*)ird, len)) != len) {
+ write_irels();
+ return;
+ }
+
+ /* the file descriptor is not yet opened */
+ ird->rd_fd = -1;
+
+ /* lock info is not initialized */
+ ird->lockInfo = (char *) NULL;
+
+ /* next, read the access method tuple form */
+ if ((nread = FileRead(fd, (char*)&len, sizeof(int))) != sizeof(int)) {
+ write_irels();
+ return;
+ }
+
+ am = (Form_pg_am) palloc(len);
+ if ((nread = FileRead(fd, (char*)am, len)) != len) {
+ write_irels();
+ return;
+ }
+
+ ird->rd_am = am;
+
+ /* next read the relation tuple form */
+ if ((nread = FileRead(fd, (char*)&len, sizeof(int))) != sizeof(int)) {
+ write_irels();
+ return;
+ }
+
+ relform = (Form_pg_class) palloc(len);
+ if ((nread = FileRead(fd, (char*)relform, len)) != len) {
+ write_irels();
+ return;
+ }
+
+ ird->rd_rel = relform;
+
+ /* initialize attribute tuple forms */
+ ird->rd_att = CreateTemplateTupleDesc(relform->relnatts);
+
+ /* next read all the attribute tuple form data entries */
+ len = ATTRIBUTE_TUPLE_SIZE;
+ for (i = 0; i < relform->relnatts; i++) {
+ if ((nread = FileRead(fd, (char*)&len, sizeof(int))) != sizeof(int)) {
+ write_irels();
+ return;
+ }
+
+ ird->rd_att->attrs[i] = (AttributeTupleForm) palloc(len);
+
+ if ((nread = FileRead(fd, (char*)ird->rd_att->attrs[i], len)) != len) {
+ write_irels();
+ return;
+ }
+ }
+
+ /* next, read the index strategy map */
+ if ((nread = FileRead(fd, (char*)&len, sizeof(int))) != sizeof(int)) {
+ write_irels();
+ return;
+ }
+
+ strat = (IndexStrategy) palloc(len);
+ if ((nread = FileRead(fd, (char*)strat, len)) != len) {
+ write_irels();
+ return;
+ }
+
+ /* oh, for god's sake... */
+#define SMD(i) strat[0].strategyMapData[i].entry[0]
+
+ /* have to reinit the function pointers in the strategy maps */
+ for (i = 0; i < am->amstrategies; i++)
+ fmgr_info(SMD(i).sk_procedure,
+ &(SMD(i).sk_func), &(SMD(i).sk_nargs));
+
+
+ /* use a real field called rd_istrat instead of the
+ bogosity of hanging invisible fields off the end of a structure
+ - jolly */
+ ird->rd_istrat = strat;
+
+ /* finally, read the vector of support procedures */
+ if ((nread = FileRead(fd, (char*)&len, sizeof(int))) != sizeof(int)) {
+ write_irels();
+ return;
+ }
+
+ support = (RegProcedure *) palloc(len);
+ if ((nread = FileRead(fd, (char*)support, len)) != len) {
+ write_irels();
+ return;
+ }
+
+ /*
+ p += sizeof(IndexStrategy);
+ *((RegProcedure **) p) = support;
+ */
+
+ ird->rd_support = support;
+
+ RelationCacheInsert(ird);
+ }
+}
+
+void
+write_irels()
+{
+ int len;
+ int nwritten;
+ File fd;
+ Relation irel[Num_indices_bootstrap];
+ Relation ird;
+ Form_pg_am am;
+ Form_pg_class relform;
+ IndexStrategy strat;
+ RegProcedure *support;
+ ProcessingMode oldmode;
+ int i;
+ int relno;
+ RelationBuildDescInfo bi;
+
+ fd = FileNameOpenFile(INIT_FILENAME, O_WRONLY|O_CREAT|O_TRUNC, 0600);
+ if (fd < 0)
+ elog(FATAL, "cannot create init file %s", INIT_FILENAME);
+
+ (void) FileSeek(fd, 0L, SEEK_SET);
+
+ /*
+ * Build a relation descriptor for pg_attnumind without resort to the
+ * descriptor cache. In order to do this, we set ProcessingMode
+ * to Bootstrap. The effect of this is to disable indexed relation
+ * searches -- a necessary step, since we're trying to instantiate
+ * the index relation descriptors here.
+ */
+
+ oldmode = GetProcessingMode();
+ SetProcessingMode(BootstrapProcessing);
+
+ bi.infotype = INFO_RELNAME;
+ bi.i.info_name = AttributeNumIndex;
+ irel[0] = RelationBuildDesc(bi);
+ irel[0]->rd_isnailed = true;
+
+ bi.i.info_name = ClassNameIndex;
+ irel[1] = RelationBuildDesc(bi);
+ irel[1]->rd_isnailed = true;
+
+ bi.i.info_name = ClassOidIndex;
+ irel[2] = RelationBuildDesc(bi);
+ irel[2]->rd_isnailed = true;
+
+ SetProcessingMode(oldmode);
+
+ /* nail the descriptor in the cache */
+ for (relno = 0; relno < Num_indices_bootstrap; relno++) {
+ ird = irel[relno];
+
+ /* save the volatile fields in the relation descriptor */
+ am = ird->rd_am;
+ ird->rd_am = (Form_pg_am) NULL;
+ relform = ird->rd_rel;
+ ird->rd_rel = (Form_pg_class) NULL;
+ strat = ird->rd_istrat;
+ support = ird->rd_support;
+
+ /* first write the relation descriptor , excluding strategy and support */
+ len = sizeof(RelationData);
+
+ /* first, write the relation descriptor length */
+ if ((nwritten = FileWrite(fd, (char*) &len, sizeof(int)))
+ != sizeof(int))
+ elog(FATAL, "cannot write init file -- descriptor length");
+
+ /* next, write out the Relation structure */
+ if ((nwritten = FileWrite(fd, (char*) ird, len)) != len)
+ elog(FATAL, "cannot write init file -- reldesc");
+
+ /* next, write the access method tuple form */
+ len = sizeof(FormData_pg_am);
+ if ((nwritten = FileWrite(fd, (char*) &len, sizeof(int)))
+ != sizeof(int))
+ elog(FATAL, "cannot write init file -- am tuple form length");
+
+ if ((nwritten = FileWrite(fd, (char*) am, len)) != len)
+ elog(FATAL, "cannot write init file -- am tuple form");
+
+ /* next write the relation tuple form */
+ len = sizeof(FormData_pg_class);
+ if ((nwritten = FileWrite(fd, (char*) &len, sizeof(int)))
+ != sizeof(int))
+ elog(FATAL, "cannot write init file -- relation tuple form length");
+
+ if ((nwritten = FileWrite(fd, (char*) relform, len)) != len)
+ elog(FATAL, "cannot write init file -- relation tuple form");
+
+ /* next, do all the attribute tuple form data entries */
+ len = ATTRIBUTE_TUPLE_SIZE;
+ for (i = 0; i < relform->relnatts; i++) {
+ if ((nwritten = FileWrite(fd, (char*) &len, sizeof(int)))
+ != sizeof(int))
+ elog(FATAL, "cannot write init file -- length of attdesc %d", i);
+ if ((nwritten = FileWrite(fd, (char*) ird->rd_att->attrs[i], len))
+ != len)
+ elog(FATAL, "cannot write init file -- attdesc %d", i);
+ }
+
+ /* next, write the index strategy map */
+ len = AttributeNumberGetIndexStrategySize(relform->relnatts,
+ am->amstrategies);
+ if ((nwritten = FileWrite(fd, (char*) &len, sizeof(int)))
+ != sizeof(int))
+ elog(FATAL, "cannot write init file -- strategy map length");
+
+ if ((nwritten = FileWrite(fd, (char*) strat, len)) != len)
+ elog(FATAL, "cannot write init file -- strategy map");
+
+ /* finally, write the vector of support procedures */
+ len = relform->relnatts * (am->amsupport * sizeof(RegProcedure));
+ if ((nwritten = FileWrite(fd, (char*) &len, sizeof(int)))
+ != sizeof(int))
+ elog(FATAL, "cannot write init file -- support vector length");
+
+ if ((nwritten = FileWrite(fd, (char*) support, len)) != len)
+ elog(FATAL, "cannot write init file -- support vector");
+
+ /* restore volatile fields */
+ ird->rd_am = am;
+ ird->rd_rel = relform;
+ }
+
+ (void) FileClose(fd);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * syscache.c--
+ * System cache management routines
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/syscache.c,v 1.1.1.1 1996/07/09 06:22:07 scrappy Exp $
+ *
+ * NOTES
+ * These routines allow the parser/planner/executor to perform
+ * rapid lookups on the contents of the system catalogs.
+ *
+ * see catalog/syscache.h for a list of the cache id's
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "c.h"
+
+#include "access/heapam.h"
+#include "access/htup.h"
+#include "catalog/catname.h"
+#include "utils/catcache.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "nodes/pg_list.h"
+
+/* ----------------
+ * hardwired attribute information comes from system catalog files.
+ * ----------------
+ */
+#include "catalog/pg_am.h"
+#include "catalog/pg_amop.h"
+#include "catalog/pg_attribute.h"
+#include "catalog/pg_group.h"
+#include "catalog/pg_index.h"
+#include "catalog/pg_inherits.h"
+#include "catalog/pg_language.h"
+#include "catalog/pg_opclass.h"
+#include "catalog/pg_operator.h"
+#include "catalog/pg_proc.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_type.h"
+#include "catalog/pg_rewrite.h"
+#include "catalog/pg_aggregate.h"
+#include "catalog/pg_user.h"
+#include "storage/large_object.h"
+#include "catalog/pg_listener.h"
+
+extern bool AMI_OVERRIDE; /* XXX style */
+
+#include "utils/syscache.h"
+#include "catalog/indexing.h"
+
+typedef HeapTuple (*ScanFunc)();
+
+/* ----------------
+ * Warning: cacheinfo[] below is changed, then be sure and
+ * update the magic constants in syscache.h!
+ * ----------------
+ */
+static struct cachedesc cacheinfo[] = {
+ { AccessMethodOperatorRelationName, /* AMOPOPID */
+ 3,
+ { Anum_pg_amop_amopclaid,
+ Anum_pg_amop_amopopr,
+ Anum_pg_amop_amopid,
+ 0 },
+ sizeof(FormData_pg_amop),
+ NULL,
+ (ScanFunc) NULL },
+ { AccessMethodOperatorRelationName, /* AMOPSTRATEGY */
+ 3,
+ { Anum_pg_amop_amopid,
+ Anum_pg_amop_amopclaid,
+ Anum_pg_amop_amopstrategy,
+ 0 },
+ sizeof(FormData_pg_amop),
+ NULL,
+ (ScanFunc) NULL },
+ { AttributeRelationName, /* ATTNAME */
+ 2,
+ { Anum_pg_attribute_attrelid,
+ Anum_pg_attribute_attname,
+ 0,
+ 0 },
+ ATTRIBUTE_TUPLE_SIZE,
+ AttributeNameIndex,
+ (ScanFunc) AttributeNameIndexScan },
+ { AttributeRelationName, /* ATTNUM */
+ 2,
+ { Anum_pg_attribute_attrelid,
+ Anum_pg_attribute_attnum,
+ 0,
+ 0 },
+ ATTRIBUTE_TUPLE_SIZE,
+ AttributeNumIndex,
+ (ScanFunc) AttributeNumIndexScan },
+ { IndexRelationName, /* INDEXRELID */
+ 1,
+ { Anum_pg_index_indexrelid,
+ 0,
+ 0,
+ 0 },
+ offsetof(FormData_pg_index, indpred),
+ NULL,
+ NULL },
+ { LanguageRelationName, /* LANNAME */
+ 1,
+ { Anum_pg_language_lanname,
+ 0,
+ 0,
+ 0 },
+ offsetof(FormData_pg_language, lancompiler),
+ NULL,
+ NULL },
+ { OperatorRelationName, /* OPRNAME */
+ 4,
+ { Anum_pg_operator_oprname,
+ Anum_pg_operator_oprleft,
+ Anum_pg_operator_oprright,
+ Anum_pg_operator_oprkind },
+ sizeof(FormData_pg_operator),
+ NULL,
+ NULL },
+ { OperatorRelationName, /* OPROID */
+ 1,
+ { ObjectIdAttributeNumber,
+ 0,
+ 0,
+ 0 },
+ sizeof(FormData_pg_operator),
+ NULL,
+ (ScanFunc) NULL },
+ { ProcedureRelationName, /* PRONAME */
+ 3,
+ { Anum_pg_proc_proname,
+ Anum_pg_proc_pronargs,
+ Anum_pg_proc_proargtypes,
+ 0 },
+ offsetof(FormData_pg_proc, prosrc),
+ ProcedureNameIndex,
+ (ScanFunc) ProcedureNameIndexScan },
+ { ProcedureRelationName, /* PROOID */
+ 1,
+ { ObjectIdAttributeNumber,
+ 0,
+ 0,
+ 0 },
+ offsetof(FormData_pg_proc, prosrc),
+ ProcedureOidIndex,
+ (ScanFunc) ProcedureOidIndexScan },
+ { RelationRelationName, /* RELNAME */
+ 1,
+ { Anum_pg_class_relname,
+ 0,
+ 0,
+ 0 },
+ CLASS_TUPLE_SIZE,
+ ClassNameIndex,
+ (ScanFunc) ClassNameIndexScan },
+ { RelationRelationName, /* RELOID */
+ 1,
+ { ObjectIdAttributeNumber,
+ 0,
+ 0,
+ 0 },
+ CLASS_TUPLE_SIZE,
+ ClassOidIndex,
+ (ScanFunc) ClassOidIndexScan },
+ { TypeRelationName, /* TYPNAME */
+ 1,
+ { Anum_pg_type_typname,
+ 0,
+ 0,
+ 0 },
+ offsetof(TypeTupleFormData,typalign)+sizeof(char),
+ TypeNameIndex,
+ TypeNameIndexScan },
+ { TypeRelationName, /* TYPOID */
+ 1,
+ { ObjectIdAttributeNumber,
+ 0,
+ 0,
+ 0},
+ offsetof(TypeTupleFormData,typalign)+sizeof(char),
+ TypeOidIndex,
+ TypeOidIndexScan },
+ { AccessMethodRelationName, /* AMNAME */
+ 1,
+ { Anum_pg_am_amname,
+ 0,
+ 0,
+ 0},
+ sizeof(FormData_pg_am),
+ NULL,
+ NULL },
+ { OperatorClassRelationName, /* CLANAME */
+ 1,
+ { Anum_pg_opclass_opcname,
+ 0,
+ 0,
+ 0},
+ sizeof(FormData_pg_opclass),
+ NULL,
+ NULL },
+ { IndexRelationName, /* INDRELIDKEY */
+ 2,
+ { Anum_pg_index_indrelid,
+ Anum_pg_index_indkey,
+ 0,
+ 0},
+ offsetof(FormData_pg_index, indpred),
+ NULL,
+ (ScanFunc) NULL },
+ { InheritsRelationName, /* INHRELID */
+ 2,
+ { Anum_pg_inherits_inhrel,
+ Anum_pg_inherits_inhseqno,
+ 0,
+ 0},
+ sizeof(FormData_pg_inherits),
+ NULL,
+ (ScanFunc) NULL },
+ { RewriteRelationName, /* RULOID */
+ 1,
+ { ObjectIdAttributeNumber,
+ 0,
+ 0,
+ 0 },
+ offsetof(FormData_pg_rewrite, ev_qual),
+ NULL,
+ (ScanFunc) NULL },
+ { AggregateRelationName, /*AGGNAME*/
+ 2,
+ { Anum_pg_aggregate_aggname,
+ Anum_pg_aggregate_aggbasetype,
+ 0,
+ 0 },
+ offsetof(FormData_pg_aggregate, agginitval1),
+ NULL,
+ (ScanFunc) NULL },
+ { ListenerRelationName, /* LISTENREL */
+ 2,
+ { Anum_pg_listener_relname,
+ Anum_pg_listener_pid,
+ 0,
+ 0 },
+ sizeof(FormData_pg_listener),
+ NULL,
+ (ScanFunc) NULL },
+ { UserRelationName, /* USENAME */
+ 1,
+ { Anum_pg_user_usename,
+ 0,
+ 0,
+ 0 },
+ sizeof(FormData_pg_user),
+ NULL,
+ (ScanFunc) NULL },
+ { UserRelationName, /* USESYSID */
+ 1,
+ { Anum_pg_user_usesysid,
+ 0,
+ 0,
+ 0 },
+ sizeof(FormData_pg_user),
+ NULL,
+ (ScanFunc) NULL },
+ { GroupRelationName, /* GRONAME */
+ 1,
+ { Anum_pg_group_groname,
+ 0,
+ 0,
+ 0 },
+ offsetof(FormData_pg_group, grolist[0]),
+ NULL,
+ (ScanFunc) NULL },
+ { GroupRelationName, /* GROSYSID */
+ 1,
+ { Anum_pg_group_grosysid,
+ 0,
+ 0,
+ 0 },
+ offsetof(FormData_pg_group, grolist[0]),
+ NULL,
+ (ScanFunc) NULL },
+ { RewriteRelationName, /* REWRITENAME */
+ 1,
+ { Anum_pg_rewrite_rulename,
+ 0,
+ 0,
+ 0 },
+ offsetof(FormData_pg_rewrite, ev_qual),
+ NULL,
+ (ScanFunc) NULL },
+ { ProcedureRelationName, /* PROSRC */
+ 1,
+ { Anum_pg_proc_prosrc,
+ 0,
+ 0,
+ 0 },
+ offsetof(FormData_pg_proc, prosrc),
+ ProcedureSrcIndex,
+ (ScanFunc) ProcedureSrcIndexScan }
+};
+
+static struct catcache *SysCache[lengthof(cacheinfo)];
+static int32 SysCacheSize = lengthof(cacheinfo);
+
+
+/*
+ * zerocaches--
+ *
+ * Make sure the SysCache structure is zero'd.
+ */
+void
+zerocaches()
+{
+ memset((char *) SysCache, 0, SysCacheSize * sizeof(struct catcache *));
+}
+
+/*
+ * Note:
+ * This function was written because the initialized catalog caches
+ * are used to determine which caches may contain tuples which need
+ * to be invalidated in other backends.
+ */
+void
+InitCatalogCache()
+{
+ int cacheId; /* XXX type */
+
+ if (!AMI_OVERRIDE) {
+ for (cacheId = 0; cacheId < SysCacheSize; cacheId += 1) {
+
+ Assert(!PointerIsValid((Pointer)SysCache[cacheId]));
+
+ SysCache[cacheId] =
+ InitSysCache(cacheinfo[cacheId].name,
+ cacheinfo[cacheId].indname,
+ cacheId,
+ cacheinfo[cacheId].nkeys,
+ cacheinfo[cacheId].key,
+ cacheinfo[cacheId].iScanFunc);
+ if (!PointerIsValid((char *)SysCache[cacheId])) {
+ elog(WARN,
+ "InitCatalogCache: Can't init cache %.16s(%d)",
+ cacheinfo[cacheId].name,
+ cacheId);
+ }
+
+ }
+ }
+}
+
+/*
+ * SearchSysCacheTuple--
+ *
+ * A layer on top of SearchSysCache that does the initialization and
+ * key-setting for you.
+ *
+ * Returns the tuple if one is found, NULL if not.
+ *
+ * XXX The tuple that is returned is NOT supposed to be pfree'd!
+ */
+HeapTuple
+SearchSysCacheTuple(int cacheId, /* cache selection code */
+ Datum key1,
+ Datum key2,
+ Datum key3,
+ Datum key4)
+{
+ register HeapTuple tp;
+
+ if (cacheId < 0 || cacheId >= SysCacheSize) {
+ elog(WARN, "SearchSysCacheTuple: Bad cache id %d", cacheId);
+ return((HeapTuple) NULL);
+ }
+
+ if (!AMI_OVERRIDE) {
+ Assert(PointerIsValid(SysCache[cacheId]));
+ } else {
+ if (!PointerIsValid(SysCache[cacheId])) {
+ SysCache[cacheId] =
+ InitSysCache(cacheinfo[cacheId].name,
+ cacheinfo[cacheId].indname,
+ cacheId,
+ cacheinfo[cacheId].nkeys,
+ cacheinfo[cacheId].key,
+ cacheinfo[cacheId].iScanFunc);
+ if (!PointerIsValid(SysCache[cacheId])) {
+ elog(WARN,
+ "InitCatalogCache: Can't init cache %.16s(%d)",
+ cacheinfo[cacheId].name,
+ cacheId);
+ }
+
+ }
+ }
+
+ tp = SearchSysCache(SysCache[cacheId], key1, key2, key3, key4);
+ if (!HeapTupleIsValid(tp)) {
+#ifdef CACHEDEBUG
+ elog(DEBUG,
+ "SearchSysCacheTuple: Search %s(%d) %d %d %d %d failed",
+ (*cacheinfo[cacheId].name)->data,
+ cacheId, key1, key2, key3, key4);
+#endif
+ return((HeapTuple) NULL);
+ }
+ return(tp);
+}
+
+/*
+ * SearchSysCacheStruct--
+ * Fills 's' with the information retrieved by calling SearchSysCache()
+ * with arguments key1...key4. Retrieves only the portion of the tuple
+ * which is not variable-length.
+ *
+ * NOTE: we are assuming that non-variable-length fields in the system
+ * catalogs will always be defined!
+ *
+ * Returns 1L if a tuple was found, 0L if not.
+ */
+int32
+SearchSysCacheStruct(int cacheId, /* cache selection code */
+ char *returnStruct, /* (preallocated!) */
+ Datum key1,
+ Datum key2,
+ Datum key3,
+ Datum key4)
+{
+ HeapTuple tp;
+
+ if (!PointerIsValid(returnStruct)) {
+ elog(WARN, "SearchSysCacheStruct: No receiving struct");
+ return(0);
+ }
+ tp = SearchSysCacheTuple(cacheId, key1, key2, key3, key4);
+ if (!HeapTupleIsValid(tp))
+ return(0);
+ memmove(returnStruct, (char *) GETSTRUCT(tp), cacheinfo[cacheId].size);
+ return(1);
+}
+
+
+/*
+ * SearchSysCacheGetAttribute--
+ * Returns the attribute corresponding to 'attributeNumber' for
+ * a given cached tuple.
+ *
+ * XXX This re-opens a relation, so this is slower.
+ *
+ * [callers all assume this returns a (struct varlena *). -ay 10/94]
+ */
+void *
+SearchSysCacheGetAttribute(int cacheId,
+ AttrNumber attributeNumber,
+ Datum key1,
+ Datum key2,
+ Datum key3,
+ Datum key4)
+{
+ HeapTuple tp;
+ char *cacheName;
+ Relation relation;
+ int32 attributeLength, attributeByValue;
+ bool isNull;
+ char *attributeValue;
+ void *returnValue;
+
+ tp = SearchSysCacheTuple(cacheId, key1, key2, key3, key4);
+ cacheName = cacheinfo[cacheId].name;
+
+ if (!HeapTupleIsValid(tp)) {
+#ifdef CACHEDEBUG
+ elog(DEBUG,
+ "SearchSysCacheGetAttribute: Lookup in %s(%d) failed",
+ cacheName, cacheId);
+#endif /* defined(CACHEDEBUG) */
+ return(NULL);
+ }
+
+ relation = heap_openr(cacheName);
+
+ if (attributeNumber < 0 &&
+ attributeNumber > FirstLowInvalidHeapAttributeNumber) {
+ attributeLength = heap_sysattrlen(attributeNumber);
+ attributeByValue = heap_sysattrbyval(attributeNumber);
+ } else if (attributeNumber > 0 &&
+ attributeNumber <= relation->rd_rel->relnatts) {
+ attributeLength =
+ relation->rd_att->attrs[attributeNumber-1]->attlen;
+ attributeByValue =
+ relation->rd_att->attrs[attributeNumber-1]->attbyval;
+ } else {
+ elog(WARN,
+ "SearchSysCacheGetAttribute: Bad attr # %d in %s(%d)",
+ attributeNumber, cacheName, cacheId);
+ return(NULL);
+ }
+
+ attributeValue = heap_getattr(tp,
+ (Buffer) 0,
+ attributeNumber,
+ RelationGetTupleDescriptor(relation),
+ &isNull);
+
+ if (isNull) {
+ /*
+ * Used to be an elog(DEBUG, ...) here and a claim that it should
+ * be a FATAL error, I don't think either is warranted -mer 6/9/92
+ */
+ return(NULL);
+ }
+
+ if (attributeByValue) {
+ returnValue = (void *)attributeValue;
+ } else {
+ char *tmp;
+ int size = (attributeLength < 0)
+ ? VARSIZE((struct varlena *) attributeValue) /* variable length */
+ : attributeLength; /* fixed length */
+
+ tmp = (char *) palloc(size);
+ memmove(tmp, attributeValue, size);
+ returnValue = (void *)tmp;
+ }
+
+ heap_close(relation);
+ return(returnValue);
+}
+
+/*
+ * TypeDefaultRetrieve--
+ *
+ * Given a type OID, return the typdefault field associated with that
+ * type. The typdefault is returned as the car of a dotted pair which
+ * is passed to TypeDefaultRetrieve by the calling routine.
+ *
+ * Returns a fixnum for types which are passed by value and a ppreserve'd
+ * vectori for types which are not.
+ *
+ * [identical to get_typdefault, expecting a (struct varlena *) as ret val.
+ * some day, either of the functions should be removed -ay 10/94]
+ */
+void *
+TypeDefaultRetrieve(Oid typId)
+{
+ HeapTuple typeTuple;
+ TypeTupleForm type;
+ int32 typByVal, typLen;
+ struct varlena *typDefault;
+ int32 dataSize;
+ void *returnValue;
+
+ typeTuple = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(typId),
+ 0,0,0);
+
+ if (!HeapTupleIsValid(typeTuple)) {
+#ifdef CACHEDEBUG
+ elog(DEBUG, "TypeDefaultRetrieve: Lookup in %s(%d) failed",
+ (*cacheinfo[TYPOID].name)->data, TYPOID);
+#endif /* defined(CACHEDEBUG) */
+ return(NULL);
+ }
+
+ type = (TypeTupleForm) GETSTRUCT(typeTuple);
+ typByVal = type->typbyval;
+ typLen = type->typlen;
+
+ typDefault = (struct varlena *)
+ SearchSysCacheGetAttribute(TYPOID,
+ Anum_pg_type_typdefault,
+ ObjectIdGetDatum(typId),
+ 0,0,0);
+
+ if (typDefault == (struct varlena *)NULL) {
+#ifdef CACHEDEBUG
+ elog(DEBUG, "TypeDefaultRetrieve: No extractable typdefault",
+ (*cacheinfo[TYPOID].name)->data, TYPOID);
+#endif /* defined(CACHEDEBUG) */
+ return (NULL);
+
+ }
+
+ dataSize = VARSIZE(typDefault) - VARHDRSZ;
+
+ if (typByVal) {
+ int8 i8;
+ int16 i16;
+ int32 i32;
+
+ if (dataSize == typLen) {
+ switch (typLen) {
+ case sizeof(int8):
+ memmove((char *) &i8, VARDATA(typDefault), sizeof(int8));
+ i32 = i8;
+ break;
+ case sizeof(int16):
+ memmove((char *) &i16, VARDATA(typDefault), sizeof(int16));
+ i32 = i16;
+ break;
+ case sizeof(int32):
+ memmove((char *) &i32, VARDATA(typDefault), sizeof(int32));
+ break;
+ }
+ returnValue = (void *)i32;
+ } else {
+ returnValue = NULL;
+ }
+ } else {
+ if ((typLen < 0 && dataSize < 0) || dataSize != typLen)
+ returnValue = NULL;
+ else {
+ returnValue = (void *)palloc(VARSIZE(typDefault));
+ memmove((char *) returnValue,
+ (char *) typDefault,
+ (int) VARSIZE(typDefault));
+ }
+ }
+
+ return(returnValue);
+}
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * catcache.h--
+ * Low-level catalog cache definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: catcache.h,v 1.1.1.1 1996/07/09 06:22:01 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CATCACHE_H
+#define CATCACHE_H
+
+/* #define CACHEDEBUG turns DEBUG elogs on */
+
+#include "postgres.h"
+
+#include "access/skey.h"
+#include "access/htup.h"
+#include "utils/rel.h"
+#include "nodes/memnodes.h"
+#include "lib/dllist.h"
+
+/*
+ * struct catctup: tuples in the cache.
+ * struct catcache: information for managing a cache.
+ */
+
+typedef struct catctup {
+ HeapTuple ct_tup; /* A pointer to a tuple */
+ Dlelem *ct_node; /* points to LRU list is the CatCTup is in the cache,
+ else, points to the cache if the CatCTup is in
+ LRU list */
+} CatCTup;
+
+/* voodoo constants */
+#define NCCBUCK 500 /* CatCache buckets*/
+#define MAXTUP 300 /* Maximum # of tuples cached per cache */
+
+typedef struct catcache {
+ Oid relationId;
+ Oid indexId;
+ char *cc_relname; /* relation name for defered open */
+ char *cc_indname; /* index name for defered open */
+ HeapTuple (*cc_iscanfunc)(); /* index scanfunction */
+ TupleDesc cc_tupdesc; /* tuple descriptor from reldesc */
+ int id; /* XXX could be improved -hirohama */
+ short cc_ntup; /* # of tuples in this cache */
+ short cc_maxtup; /* max # of tuples allowed (LRU)*/
+ short cc_nkeys;
+ short cc_size;
+ short cc_key[4];
+ short cc_klen[4];
+ ScanKeyData cc_skey[4];
+ struct catcache *cc_next;
+ Dllist *cc_lrulist; /* LRU list, most recent first */
+ Dllist *cc_cache[NCCBUCK+1];
+} CatCache;
+
+#define InvalidCatalogCacheId (-1)
+
+extern struct catcache *Caches;
+extern GlobalMemory CacheCxt;
+
+extern void CatalogCacheInitializeCache(struct catcache *cache,
+ Relation relation);
+extern void CatalogCacheSetId(CatCache *cacheInOutP, int id);
+extern long comphash(long l, char *v);
+extern Index CatalogCacheComputeHashIndex(struct catcache *cacheInP);
+extern Index CatalogCacheComputeTupleHashIndex(struct catcache *cacheInOutP,
+ Relation relation, HeapTuple tuple);
+extern void CatCacheRemoveCTup(CatCache *cache, Dlelem *e);
+extern void CatalogCacheIdInvalidate(int cacheId, Index hashIndex,
+ ItemPointer pointer);
+extern void ResetSystemCache(void);
+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,
+ Datum v3, Datum v4);
+extern void RelationInvalidateCatalogCacheTuple(Relation relation,
+ HeapTuple tuple, void (*function)());
+
+#endif /* CATCACHE_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * datum.h--
+ * POSTGRES abstract data type datum representation definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: datum.h,v 1.1.1.1 1996/07/09 06:22:01 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef DATUM_H
+#define DATUM_H
+
+#include "postgres.h"
+
+/*--------------------------------------------------------
+ * SOME NOT VERY PORTABLE ROUTINES ???
+ *--------------------------------------------------------
+ *
+ * In the implementation of the next routines we assume the following:
+ *
+ * A) if a type is "byVal" then all the information is stored in the
+ * Datum itself (i.e. no pointers involved!). In this case the
+ * length of the type is always greater than zero and less than
+ * "sizeof(Datum)"
+ * B) if a type is not "byVal" and it has a fixed length, then
+ * the "Datum" always contain a pointer to a stream of bytes.
+ * The number of significant bytes are always equal to the length of thr
+ * type.
+ * C) if a type is not "byVal" and is of variable length (i.e. it has
+ * length == -1) then "Datum" always points to a "struct varlena".
+ * This varlena structure has information about the actual length of this
+ * particular instance of the type and about its value.
+ */
+
+/*---------------
+ * datumGetSize
+ * find the "real" length of a datum
+ */
+extern Size datumGetSize(Datum value, Oid type, bool byVal, Size len);
+
+/*---------------
+ * datumCopy
+ * make a copy of a datum.
+ */
+extern Datum datumCopy(Datum value, Oid type, bool byVal, Size len);
+
+/*---------------
+ * datumFree
+ * free space that *might* have been palloced by "datumCopy"
+ */
+extern void datumFree(Datum value, Oid type, bool byVal, Size len);
+
+/*---------------
+ * datumIsEqual
+ * 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,
+ bool byVal, Size len);
+
+#endif /* DATUM_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * dynamic_loader.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: dynamic_loader.h,v 1.1.1.1 1996/07/09 06:22:01 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef DYNAMIC_LOADER_H
+#define DYNAMIC_LOADER_H
+
+#ifdef MIN
+#undef MIN
+#undef MAX
+#endif /* MIN */
+
+#ifdef WIN32
+#define MAXPATHLEN 250
+#endif
+
+#include /* for MAXPATHLEN */
+#include /* for dev_t, ino_t, etc. */
+#ifdef WIN32
+#include
+#endif
+
+/*
+ * List of dynamically loaded files.
+ */
+
+typedef struct df_files {
+ char filename[MAXPATHLEN]; /* Full pathname of file */
+#ifdef WIN32
+ _dev_t device; /* Device file is on */
+ _ino_t inode; /* Inode number of file */
+#else
+ dev_t device; /* Device file is on */
+ ino_t inode; /* Inode number of file */
+#endif /* WIN32 */
+ void *handle; /* a handle for pg_dl* functions */
+ struct df_files *next;
+} DynamicFileList;
+
+extern void *pg_dlopen(char *filename);
+extern func_ptr pg_dlsym(void *handle, char *funcname);
+extern void pg_dlclose(void *handle);
+extern char *pg_dlerror(void);
+
+#endif /* DYNAMIC_LOADER_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * elog.h--
+ * POSTGRES error logging definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: elog.h,v 1.1.1.1 1996/07/09 06:22:01 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ELOG_H
+#define ELOG_H
+
+#define NOTICE 0 /* random info - no special action */
+#define WARN -1 /* Warning error - return to known state */
+#define FATAL 1 /* Fatal error - abort process */
+#define DEBUG -2 /* debug message */
+#define NOIND -3 /* debug message, don't indent as far */
+
+#define PTIME 0x100 /* prepend time to message */
+#define POS 0x200 /* prepend source position to message */
+#define USERMSG 0x400 /* send message to user */
+#define TERM 0x800 /* send message to terminal */
+#define DBLOG 0x1000 /* put message in per db log */
+#define SLOG 0x2000 /* put message in system log */
+#define ABORT 0x4000 /* abort process after logging */
+
+#define ELOG_MAXLEN 4096
+
+
+/* uncomment the following if you want your elog's to be timestamped */
+/* #define ELOG_TIMESTAMPS */
+
+extern void elog(int lev, char *fmt, ...);
+
+#endif /* ELOG_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for utils/error
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/utils/error/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:22:07 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= assert.c elog.c exc.c excabort.c excid.c format.c
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * assert.c--
+ * Assert code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/error/assert.c,v 1.1.1.1 1996/07/09 06:22:07 scrappy Exp $
+ *
+ * NOTE
+ * This should eventually work with elog(), dlog(), etc.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+
+#include "c.h" /* where the declaration goes */
+#include "utils/module.h"
+
+#include "utils/exc.h"
+
+int
+ExceptionalCondition(char* conditionName,
+ Exception *exceptionP,
+ char* detail,
+ char* fileName,
+ int lineNumber)
+{
+ extern char* ExcFileName; /* XXX */
+ extern Index ExcLineNumber; /* XXX */
+
+ ExcFileName = fileName;
+ ExcLineNumber = lineNumber;
+
+ if (!PointerIsValid(conditionName)
+ || !PointerIsValid(fileName)
+ || !PointerIsValid(exceptionP)) {
+ fprintf(stderr, "ExceptionalCondition: bad arguments\n");
+
+ ExcAbort(exceptionP,
+ (ExcDetail)detail,
+ (ExcData)NULL,
+ (ExcMessage)NULL);
+ } else {
+ fprintf(stderr,
+ "%s(\"%s:%s\", File: \"%s\", Line: %d)\n",
+ exceptionP->message, conditionName, detail,
+ fileName, lineNumber);
+ }
+
+ /*
+ * XXX Depending on the Exception and tracing conditions, you will
+ * XXX want to stop here immediately and maybe dump core.
+ * XXX This may be especially true for Assert(), etc.
+ */
+
+ /* TraceDump(); dump the trace stack */
+
+ /* XXX FIXME: detail is lost */
+ ExcRaise(exceptionP, (ExcDetail)0, (ExcData)NULL, conditionName);
+ return(0);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * elog.c--
+ * error logger
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.1.1.1 1996/07/09 06:22:07 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include
+#include
+#ifndef O_RDONLY
+#include
+#endif /* O_RDONLY */
+#include
+#include
+#include
+
+#include "postgres.h"
+#include "miscadmin.h"
+#include "utils/elog.h"
+#include "libpq/libpq.h"
+#include "storage/proc.h"
+
+static int Debugfile = -1;
+static int Err_file = -1;
+static int ElogDebugIndentLevel = 0;
+
+extern char OutputFileName[];
+#ifdef WIN32
+extern jmp_buf Warn_restart;
+#endif
+
+/*
+ * elog --
+ * Old error logging function.
+ */
+void
+elog(int lev, char *fmt, ... )
+{
+ va_list ap;
+ char buf[ELOG_MAXLEN], line[ELOG_MAXLEN];
+ register char *bp, *cp;
+ extern int errno, sys_nerr;
+#if !defined(PORTNAME_BSD44_derived) && !defined(PORTNAME_bsdi)
+ extern char *sys_errlist[];
+#endif /* !PORTNAME_BSD44_derived */
+#ifndef PG_STANDALONE
+ extern FILE *Pfout;
+#endif /* !PG_STANDALONE */
+ time_t tim, time();
+ int len;
+ int i = 0;
+
+ va_start(ap, fmt);
+ if (lev == DEBUG && Debugfile < 0) {
+ return;
+ }
+ switch (lev) {
+ case NOIND:
+ i = ElogDebugIndentLevel-1;
+ if (i < 0) i = 0;
+ if (i > 30) i = i%30;
+ cp = "DEBUG:";
+ break;
+ case DEBUG:
+ i = ElogDebugIndentLevel;
+ if (i < 0) i = 0;
+ if (i > 30) i = i%30;
+ cp = "DEBUG:";
+ break;
+ case NOTICE:
+ cp = "NOTICE:";
+ break;
+ case WARN:
+ cp = "WARN:";
+ break;
+ default:
+ sprintf(line, "FATAL %d:", lev);
+ cp = line;
+ }
+#ifdef ELOG_TIMESTAMPS
+ time(&tim);
+ strcat(strcpy(buf, cp), ctime(&tim)+4);
+ bp = buf+strlen(buf)-6;
+ *bp++ = ':';
+#else
+ strcpy(buf,cp);
+ bp = buf+strlen(buf);
+#endif
+ while (i-- >0) *bp++ = ' ';
+ for (cp = fmt; *cp; cp++)
+ if (*cp == '%' && *(cp+1) == 'm') {
+ if (errno < sys_nerr && errno >= 0)
+ strcpy(bp, sys_errlist[errno]);
+ else
+ sprintf(bp, "error %d", errno);
+ bp += strlen(bp);
+ cp++;
+ } else
+ *bp++ = *cp;
+ *bp = '\0';
+ vsprintf(line, buf, ap);
+ va_end(ap);
+ len = strlen(strcat(line, "\n"));
+ if (Debugfile > -1)
+ write(Debugfile, line, len);
+ if (lev == DEBUG || lev == NOIND)
+ return;
+
+ /*
+ * If there's an error log file other than our channel to the
+ * front-end program, write to it first. This is important
+ * because there's a bug in the socket code on ultrix. If the
+ * front end has gone away (so the channel to it has been closed
+ * at the other end), then writing here can cause this backend
+ * to exit without warning -- that is, write() does an exit().
+ * In this case, our only hope of finding out what's going on
+ * is if Err_file was set to some disk log. This is a major pain.
+ */
+
+ if (Err_file > -1 && Debugfile != Err_file) {
+ if (write(Err_file, line, len) < 0) {
+ write(open("/dev/console", O_WRONLY, 0666), line, len);
+ fflush(stdout);
+ fflush(stderr);
+ exitpg(lev);
+ }
+ fsync(Err_file);
+ }
+
+#ifndef PG_STANDALONE
+ /* Send IPC message to the front-end program */
+ if (Pfout != NULL && lev > DEBUG) {
+ /* notices are not exactly errors, handle it differently */
+ if (lev == NOTICE)
+ pq_putnchar("N", 1);
+ else
+ pq_putnchar("E", 1);
+ /* pq_putint(-101, 4);*/ /* should be query id */
+ pq_putstr(line);
+ pq_flush();
+ }
+#endif /* !PG_STANDALONE */
+
+ if (lev == WARN) {
+ ProcReleaseSpins(NULL); /* get rid of spinlocks we hold */
+#ifndef WIN32
+ kill(getpid(), 1); /* abort to traffic cop */
+ pause();
+#else
+ longjmp(Warn_restart, 1);
+#endif /* WIN32 */
+ /*
+ * The pause(3) is just to avoid race conditions where the
+ * thread of control on an MP system gets past here (i.e.,
+ * the signal is not received instantaneously).
+ */
+ }
+
+ if (lev == FATAL) {
+ /*
+ * Assume that if we have detected the failure we can
+ * exit with a normal exit status. This will prevent
+ * the postmaster from cleaning up when it's not needed.
+ */
+ fflush(stdout);
+ fflush(stderr);
+ ProcReleaseSpins(NULL); /* get rid of spinlocks we hold */
+ ProcReleaseLocks(); /* get rid of real locks we hold */
+ exitpg(0);
+ }
+
+ if (lev > FATAL) {
+ fflush(stdout);
+ fflush(stderr);
+ exitpg(lev);
+ }
+}
+
+#ifndef PG_STANDALONE
+int
+DebugFileOpen()
+{
+ int fd, istty;
+
+ Err_file = Debugfile = -1;
+ ElogDebugIndentLevel = 0;
+
+ if (OutputFileName[0]) {
+ OutputFileName[MAXPGPATH-1] = '\0';
+ if ((fd = open(OutputFileName, O_CREAT|O_APPEND|O_WRONLY,
+ 0666)) < 0)
+ elog(FATAL, "DebugFileOpen: open of %s: %m",
+ OutputFileName);
+ istty = isatty(fd);
+ (void) close(fd);
+ /* If the file is a tty and we're running under the
+ * postmaster, try to send stdout there as well (if it
+ * isn't a tty then stderr will block out stdout, so we
+ * may as well let stdout go wherever it was going before).
+ */
+ if (istty &&
+ IsUnderPostmaster &&
+ !freopen(OutputFileName, "a", stdout))
+ elog(FATAL, "DebugFileOpen: %s reopen as stdout: %m",
+ OutputFileName);
+ if (!freopen(OutputFileName, "a", stderr))
+ elog(FATAL, "DebugFileOpen: %s reopen as stderr: %m",
+ OutputFileName);
+ Err_file = Debugfile = fileno(stderr);
+ return(Debugfile);
+ }
+#ifndef WIN32
+ /* If no filename was specified, send debugging output to stderr.
+ * If stderr has been hosed, try to open a file.
+ */
+ fd = fileno(stderr);
+ if (fcntl(fd, F_GETFD, 0) < 0) {
+ sprintf(OutputFileName, "%s/pg.errors.%d",
+ GetPGData(), getpid());
+ fd = open(OutputFileName, O_CREAT|O_APPEND|O_WRONLY, 0666);
+ }
+#endif /* WIN32 */
+ if (fd < 0)
+ elog(FATAL, "DebugFileOpen: could not open debugging file");
+
+ Err_file = Debugfile = fd;
+ return(Debugfile);
+}
+#endif
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * exc.c--
+ * POSTGRES exception handling code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/error/Attic/exc.c,v 1.1.1.1 1996/07/09 06:22:07 scrappy Exp $
+ *
+ * NOTE
+ * XXX this code needs improvement--check for state violations and
+ * XXX reset after handling an exception.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* XXX use own I/O routines */
+#include
+#include "utils/exc.h"
+#include "storage/ipc.h"
+
+/*
+ * Global Variables
+ */
+static bool ExceptionHandlingEnabled = false;
+
+char* ExcFileName = NULL;
+Index ExcLineNumber = 0;
+
+ExcFrame *ExcCurFrameP = NULL;
+
+static ExcProc *ExcUnCaughtP = NULL;
+
+extern char* ProgramName;
+
+/*
+ * Exported Functions
+ */
+
+/*
+ * EnableExceptionHandling --
+ * Enables/disables the exception handling system.
+ *
+ * Note:
+ * This must be called before any exceptions occur. I.e., call this first!
+ * This routine will not return if an error is detected.
+ * This does not follow the usual Enable... protocol.
+ * This should be merged more closely with the error logging and tracing
+ * packages.
+ *
+ * Exceptions:
+ * none
+ */
+/*
+ * Excection handling should be supported by the language, thus there should
+ * be no need to explicitly enable exception processing.
+ *
+ * This function should probably not be called, ever. Currently it does
+ * almost nothing. If there is a need for this intialization and checking.
+ * then this function should be converted to the new-style Enable code and
+ * called by all the other module Enable functions.
+ */
+void
+EnableExceptionHandling(bool on)
+{
+ if (on == ExceptionHandlingEnabled) {
+ /* XXX add logging of failed state */
+ exitpg(255);
+ /* ExitPostgres(FatalExitStatus); */
+ }
+
+ if (on) { /* initialize */
+ ;
+ } else { /* cleanup */
+ ExcFileName = NULL;
+ ExcLineNumber = 0;
+ ExcCurFrameP = NULL;
+ ExcUnCaughtP = NULL;
+ }
+
+ ExceptionHandlingEnabled = on;
+}
+
+void
+ExcPrint(Exception *excP,
+ ExcDetail detail,
+ ExcData data,
+ ExcMessage message)
+{
+ extern int errno;
+ extern int sys_nerr;
+#if !defined(PORTNAME_BSD44_derived) && !defined(PORTNAME_bsdi)
+ extern char *sys_errlist[];
+#endif /* !PORTNAME_BSD44_derived */
+
+#ifdef lint
+ data = data;
+#endif
+
+ (void) fflush(stdout); /* In case stderr is buffered */
+
+#if 0
+ if (ProgramName != NULL && *ProgramName != '\0')
+ (void) fprintf(stderr, "%s: ", ProgramName);
+#endif
+
+ if (message != NULL)
+ (void) fprintf(stderr, "%s", message);
+ else if (excP->message != NULL)
+ (void) fprintf(stderr, "%s", excP->message);
+ else
+#ifdef lint
+ (void) fprintf(stderr, "UNNAMED EXCEPTION 0x%lx", excP);
+#else
+ (void) fprintf(stderr, "UNNAMED EXCEPTION 0x%lx", (long)excP);
+#endif
+
+ (void) fprintf(stderr, " (%ld)", detail);
+
+ if (errno > 0 && errno < sys_nerr &&
+ sys_errlist[errno] != NULL && sys_errlist[errno][0] != '\0')
+ (void) fprintf(stderr, " [%s]", sys_errlist[errno]);
+ else if (errno != 0)
+ (void) fprintf(stderr, " [Error %d]", errno);
+
+ (void) fprintf(stderr, "\n");
+
+ (void) fflush(stderr);
+}
+
+ExcProc *
+ExcGetUnCaught()
+{
+ return (ExcUnCaughtP);
+}
+
+ExcProc *
+ExcSetUnCaught(ExcProc *newP)
+{
+ ExcProc *oldP = ExcUnCaughtP;
+
+ ExcUnCaughtP = newP;
+
+ return (oldP);
+}
+
+void
+ExcUnCaught(Exception *excP,
+ ExcDetail detail,
+ ExcData data,
+ ExcMessage message)
+{
+ ExcPrint(excP, detail, data, message);
+
+ ExcAbort(excP, detail, data, message);
+}
+
+void
+ExcRaise(Exception *excP,
+ ExcDetail detail,
+ ExcData data,
+ ExcMessage message)
+{
+ register ExcFrame *efp;
+
+ efp = ExcCurFrameP;
+ if (efp == NULL) {
+ if (ExcUnCaughtP != NULL)
+ (*ExcUnCaughtP)(excP, detail, data, message);
+
+ ExcUnCaught(excP, detail, data, message);
+ } else {
+ efp->id = excP;
+ efp->detail = detail;
+ efp->data = data;
+ efp->message = message;
+
+ ExcCurFrameP = efp->link;
+
+ longjmp(efp->context, 1);
+ }
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * excabort.c--
+ * Default exception abort code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/error/Attic/excabort.c,v 1.1.1.1 1996/07/09 06:22:07 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "utils/exc.h" /* where function declarations go */
+
+void
+ExcAbort(const Exception *excP,
+ ExcDetail detail,
+ ExcData data,
+ ExcMessage message)
+{
+#ifdef __SABER__
+ saber_stop();
+#else
+ /* dump core */
+ abort();
+#endif
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * excid.c--
+ * POSTGRES known exception identifier code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/error/Attic/excid.c,v 1.1.1.1 1996/07/09 06:22:07 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "utils/excid.h"
+
+/*****************************************************************************
+ * Generic Recoverable Exceptions *
+ *****************************************************************************/
+
+
+/*
+ * FailedAssertion --
+ * Indicates an Assert(...) failed.
+ */
+Exception FailedAssertion = { "Failed Assertion" };
+
+/*
+ * BadState --
+ * Indicates a function call request is inconsistent with module state.
+ */
+Exception BadState = { "Bad State for Function Call" };
+
+/*
+ * BadArg --
+ * Indicates a function call argument or arguments is out-of-bounds.
+ */
+Exception BadArg = { "Bad Argument to Function Call" };
+
+/*****************************************************************************
+ * Specific Recoverable Exceptions *
+ *****************************************************************************/
+
+/*
+ * BadAllocSize --
+ * Indicates that an allocation request is of unreasonable size.
+ */
+Exception BadAllocSize = { "Too Large Allocation Request" };
+
+/*
+ * ExhaustedMemory --
+ * Indicates an dynamic memory allocation failed.
+ */
+Exception ExhaustedMemory = { "Memory Allocation Failed" };
+
+/*
+ * Unimplemented --
+ * Indicates a function call request requires unimplemented code.
+ */
+Exception Unimplemented = { "Unimplemented Functionality" };
+
+Exception CatalogFailure = {"Catalog failure"}; /* XXX inconsistent */
+Exception InternalError = {"Internal Error"}; /* XXX inconsistent */
+Exception SemanticError = {"Semantic Error"}; /* XXX inconsistent */
+Exception SystemError = {"System Error"}; /* XXX inconsistent */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * format.c--
+ * a wrapper around code that does what vsprintf does.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/error/Attic/format.c,v 1.1.1.1 1996/07/09 06:22:07 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include "c.h"
+
+#define FormMaxSize 1024
+#define FormMinSize (FormMaxSize / 8)
+
+static char FormBuf[FormMaxSize];
+
+
+/* ----------------
+ * form
+ * ----------------
+ */
+char *
+form(char *fmt, ... )
+{
+ va_list args;
+
+ va_start(args, fmt);
+
+ (void) vsprintf(FormBuf, fmt, args);
+
+ va_end(args);
+
+ return (FormBuf);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * exc.h--
+ * POSTGRES exception handling definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: exc.h,v 1.1.1.1 1996/07/09 06:22:01 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef EXC_H
+#define EXC_H
+
+#include "c.h" /* for Exception, etc. */
+#include
+
+extern char *ExcFileName;
+extern Index ExcLineNumber;
+
+/*
+ * ExcMessage and Exception are now defined in c.h
+ */
+
+#if defined(PORTNAME_linux) \
+|| defined(PORTNAME_hpux) \
+|| defined(PORTNAME_next)\
+|| defined(WIN32)
+typedef jmp_buf ExcContext;
+#else
+typedef sigjmp_buf ExcContext;
+#endif
+
+typedef Exception* ExcId;
+typedef long ExcDetail;
+typedef char* ExcData;
+
+typedef struct ExcFrame {
+ struct ExcFrame *link;
+ ExcContext context;
+ ExcId id;
+ ExcDetail detail;
+ ExcData data;
+ ExcMessage message;
+} ExcFrame;
+
+extern ExcFrame* ExcCurFrameP;
+
+#define ExcBegin() \
+ { \
+ ExcFrame exception; \
+ \
+ exception.link = ExcCurFrameP; \
+ if (sigsetjmp(exception.context, 1) == 0) { \
+ ExcCurFrameP = &exception; \
+ {
+#define ExcExcept() \
+ } \
+ ExcCurFrameP = exception.link; \
+ } else { \
+ {
+#define ExcEnd() \
+ } \
+ } \
+ }
+
+#define raise4(x, t, d, message) \
+ ExcRaise(&(x), (ExcDetail)(t), (ExcData)(d), (ExcMessage)(message))
+
+#define reraise() \
+ raise4(*exception.id,exception.detail,exception.data,exception.message)
+
+typedef void ExcProc(Exception*, ExcDetail, ExcData, ExcMessage);
+
+
+/*
+ * prototypes for functions in exc.c
+ */
+extern void EnableExceptionHandling(bool on);
+extern void ExcPrint(Exception *excP, ExcDetail detail, ExcData data,
+ ExcMessage message);
+extern ExcProc *ExcGetUnCaught();
+extern ExcProc *ExcSetUnCaught(ExcProc *newP);
+extern void ExcUnCaught(Exception *excP, ExcDetail detail, ExcData data,
+ ExcMessage message);
+extern void ExcUnCaught(Exception *excP, ExcDetail detail, ExcData data,
+ ExcMessage message);
+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,
+ ExcMessage message);
+
+#endif /* EXC_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * excid.h--
+ * POSTGRES known exception identifier definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: excid.h,v 1.1.1.1 1996/07/09 06:22:01 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef EXCID_H
+#define EXCID_H
+
+#include "c.h"
+#include "utils/exc.h" /* for Exception */
+
+extern Exception FailedAssertion;
+extern Exception BadState;
+extern Exception BadArg;
+extern Exception BadAllocSize;
+extern Exception ExhaustedMemory;
+extern Exception Unimplemented;
+
+extern Exception CatalogFailure; /* XXX inconsistent naming style */
+extern Exception InternalError; /* XXX inconsistent naming style */
+extern Exception SemanticError; /* XXX inconsistent naming style */
+extern Exception SystemError; /* XXX inconsistent naming style */
+
+#endif /* EXCID_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * fcache.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: fcache.h,v 1.1.1.1 1996/07/09 06:22:01 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef FCACHE_H
+#define FCACHE_H
+
+#include "fmgr.h"
+
+typedef struct
+{
+ int typlen; /* length of the return type */
+ int typbyval; /* true if return type is pass by value */
+ func_ptr func; /* address of function to call (for c funcs) */
+ Oid foid; /* oid of the function in pg_proc */
+ Oid language; /* oid of the language in pg_language */
+ int nargs; /* number of arguments */
+
+ /* Might want to make these two arrays of size MAXFUNCARGS */
+
+ Oid *argOidVect; /* oids of all the arguments */
+ bool *nullVect; /* keep track of null arguments */
+
+ char *src; /* source code of the function */
+ char *bin; /* binary object code ?? */
+ char *func_state; /* fuction_state struct for execution */
+
+ bool oneResult; /* true we only want 1 result from the
+ * function
+ */
+ bool hasSetArg; /* true if func is part of a nested dot expr
+ * whose argument is func returning a set ugh!
+ */
+
+ Pointer funcSlot; /* if one result we need to copy it before we
+ * end execution of the function and free stuff
+ */
+
+ char *setArg; /* current argument for nested dot execution
+ * Nested dot expressions mean we have funcs
+ * whose argument is a set of tuples
+ */
+
+ bool istrusted; /* trusted fn? */
+} FunctionCache, *FunctionCachePtr;
+
+#endif /* FCACHE_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * fcache2.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: fcache2.h,v 1.1.1.1 1996/07/09 06:22:01 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef FCACHE2_H
+#define FCACHE2_H
+
+extern void
+setFcache(Node *node, Oid foid, List *argList, ExprContext *econtext);
+
+#endif /* FCACHE2_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for utils/fmgr
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/utils/fmgr/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:22:07 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= dfmgr.c fmgr.c
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * dfmgr.c--
+ * Dynamic function manager code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/dfmgr.c,v 1.1.1.1 1996/07/09 06:22:07 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include
+#include
+
+#include "postgres.h"
+
+#include "fmgr.h" /* generated by Gen_fmgrtab.sh */
+#include "utils/dynamic_loader.h"
+#include "utils/elog.h"
+#include "utils/builtins.h"
+#include "access/heapam.h"
+#include "nodes/pg_list.h"
+
+#include "port-protos.h" /* system specific function prototypes */
+
+#include "catalog/catname.h"
+#include "utils/syscache.h"
+#include "catalog/pg_proc.h"
+
+static DynamicFileList *file_list = (DynamicFileList *) NULL;
+static DynamicFileList *file_tail = (DynamicFileList *) NULL;
+
+#define NOT_EQUAL(A, B) (((A).st_ino != (B).inode) \
+ || ((A).st_dev != (B).device))
+
+static Oid procedureId_save = -1;
+static int pronargs_save;
+static func_ptr user_fn_save = (func_ptr) NULL;
+static func_ptr handle_load(char *filename, char *funcname);
+
+func_ptr
+fmgr_dynamic(Oid procedureId, int *pronargs)
+{
+ HeapTuple procedureTuple;
+ Form_pg_proc procedureStruct;
+ char *proname;
+ char *probinattr, *probinstring;
+ func_ptr user_fn, handle_load();
+ Relation rdesc;
+ bool isnull;
+
+ if (procedureId == procedureId_save) {
+ *pronargs = pronargs_save;
+ return(user_fn_save);
+ }
+
+ /*
+ * The procedure isn't a builtin, so we'll have to do a catalog
+ * lookup to find its pg_proc entry.
+ */
+ procedureTuple = SearchSysCacheTuple(PROOID, ObjectIdGetDatum(procedureId),
+ 0,0,0);
+ if (!HeapTupleIsValid(procedureTuple)) {
+ elog(WARN, "fmgr: Cache lookup failed for procedure %d\n",
+ procedureId);
+ return((func_ptr) NULL);
+ }
+
+ procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple);
+ proname = procedureStruct->proname.data;
+ pronargs_save = *pronargs = procedureStruct->pronargs;
+
+ /*
+ * Extract the procedure info from the pg_proc tuple.
+ * Since probin is varlena, do a amgetattr() on the procedure
+ * tuple. To do that, we need the rdesc for the procedure
+ * relation, so...
+ */
+
+ /* open pg_procedure */
+
+ rdesc = heap_openr(ProcedureRelationName);
+ if (!RelationIsValid(rdesc)) {
+ elog(WARN, "fmgr: Could not open relation %s",
+ ProcedureRelationName);
+ return((func_ptr) NULL);
+ }
+ probinattr = heap_getattr(procedureTuple, (Buffer) 0,
+ Anum_pg_proc_probin,
+ RelationGetTupleDescriptor(rdesc), &isnull);
+ if (!PointerIsValid(probinattr) /*|| isnull*/) {
+ heap_close(rdesc);
+ elog(WARN, "fmgr: Could not extract probin for %d from %s",
+ procedureId, ProcedureRelationName);
+ return((func_ptr) NULL);
+ }
+ probinstring = textout((struct varlena *) probinattr);
+
+ user_fn = handle_load(probinstring, proname);
+
+ procedureId_save = procedureId;
+ user_fn_save = user_fn;
+
+ return(user_fn);
+}
+
+static func_ptr
+handle_load(char *filename, char *funcname)
+{
+ DynamicFileList *file_scanner = (DynamicFileList *) NULL;
+ func_ptr retval = (func_ptr) NULL;
+ char *load_error;
+#ifdef WIN32
+ struct _stat stat_buf;
+#else
+ struct stat stat_buf;
+#endif /* WIN32 */
+
+ /*
+ * Do this because loading files may screw up the dynamic function
+ * manager otherwise.
+ */
+ procedureId_save = -1;
+
+ /*
+ * Scan the list of loaded FILES to see if the function
+ * has been loaded.
+ */
+
+ if (filename != (char *) NULL) {
+ for (file_scanner = file_list;
+ file_scanner != (DynamicFileList *) NULL
+ && file_scanner->filename != (char *) NULL
+ && strcmp(filename, file_scanner->filename) != 0;
+ file_scanner = file_scanner->next)
+ ;
+ if (file_scanner == (DynamicFileList *) NULL) {
+ if (stat(filename, &stat_buf) == -1) {
+ elog(WARN, "stat failed on file %s", filename);
+ }
+
+ for (file_scanner = file_list;
+ file_scanner != (DynamicFileList *) NULL
+ && (NOT_EQUAL(stat_buf, *file_scanner));
+ file_scanner = file_scanner->next)
+ ;
+ /*
+ * Same files - different paths (ie, symlink or link)
+ */
+ if (file_scanner != (DynamicFileList *) NULL)
+ (void) strcpy(file_scanner->filename, filename);
+
+ }
+ } else {
+ file_scanner = (DynamicFileList *) NULL;
+ }
+
+ /*
+ * File not loaded yet.
+ */
+
+ if (file_scanner == (DynamicFileList *) NULL) {
+ if (file_list == (DynamicFileList *) NULL) {
+ file_list = (DynamicFileList *)
+ malloc(sizeof(DynamicFileList));
+ file_scanner = file_list;
+ } else {
+ file_tail->next = (DynamicFileList *)
+ malloc(sizeof(DynamicFileList));
+ file_scanner = file_tail->next;
+ }
+ memset((char *) file_scanner, 0, sizeof(DynamicFileList));
+
+ (void) strcpy(file_scanner->filename, filename);
+#ifndef WIN32
+ file_scanner->device = stat_buf.st_dev;
+ file_scanner->inode = stat_buf.st_ino;
+#endif /* WIN32 */
+ file_scanner->next = (DynamicFileList *) NULL;
+
+ file_scanner->handle = pg_dlopen(filename);
+ if (file_scanner->handle == (void *)NULL) {
+ load_error = pg_dlerror();
+ if (file_scanner == file_list) {
+ file_list = (DynamicFileList *) NULL;
+ } else {
+ file_tail->next = (DynamicFileList *) NULL;
+ }
+
+ free((char *) file_scanner);
+ elog(WARN, "Load of file %s failed: %s", filename, load_error);
+ }
+
+ /*
+ * Just load the file - we are done with that so return.
+ */
+ file_tail = file_scanner;
+
+ if (funcname == (char *) NULL)
+ return((func_ptr) NULL);
+ }
+
+ retval = pg_dlsym(file_scanner->handle, funcname);
+
+ if (retval == (func_ptr) NULL) {
+ elog(WARN, "Can't find function %s in file %s", funcname, filename);
+ }
+
+ return(retval);
+}
+
+/*
+ * This function loads files by the following:
+ *
+ * If the file is already loaded:
+ * o Zero out that file's loaded space (so it doesn't screw up linking)
+ * o Free all space associated with that file
+ * o Free that file's descriptor.
+ *
+ * Now load the file by calling handle_load with a NULL argument as the
+ * function.
+ */
+void
+load_file(char *filename)
+{
+ DynamicFileList *file_scanner, *p;
+#ifdef WIN32
+ struct _stat stat_buf;
+#else
+ struct stat stat_buf;
+#endif /* WIN32 */
+
+ int done = 0;
+
+ if (stat(filename, &stat_buf) == -1) {
+ elog(WARN, "stat failed on file %s", filename);
+ }
+
+ if (file_list != (DynamicFileList *) NULL
+ && !NOT_EQUAL(stat_buf, *file_list)) {
+ file_scanner = file_list;
+ file_list = file_list->next;
+ pg_dlclose(file_scanner->handle);
+ free((char *) file_scanner);
+ } else if (file_list != (DynamicFileList *) NULL) {
+ file_scanner = file_list;
+ while (!done) {
+ if (file_scanner->next == (DynamicFileList *) NULL) {
+ done = 1;
+ } else if (!NOT_EQUAL(stat_buf, *(file_scanner->next))) {
+ done = 1;
+ } else {
+ file_scanner = file_scanner->next;
+ }
+ }
+
+ if (file_scanner->next != (DynamicFileList *) NULL) {
+ p = file_scanner->next;
+ file_scanner->next = file_scanner->next->next;
+ pg_dlclose(file_scanner->handle);
+ free((char *)p);
+ }
+ }
+ handle_load(filename, (char *) NULL);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * fmgr.c--
+ * Interface routines for the table-driven function manager.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.1.1.1 1996/07/09 06:22:08 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+
+#include "postgres.h"
+
+/* these 2 files are generated by Gen_fmgrtab.sh; contain the declarations */
+#include "fmgr.h"
+#include "utils/fmgrtab.h"
+
+#include "nodes/pg_list.h"
+#include "catalog/pg_proc.h"
+#include "catalog/pg_language.h"
+#include "utils/syscache.h"
+#include "nodes/params.h"
+
+#include "utils/elog.h"
+
+
+char *
+fmgr_c(func_ptr user_fn,
+ Oid func_id,
+ int n_arguments,
+ FmgrValues *values,
+ bool *isNull)
+{
+ char *returnValue = (char *) NULL;
+
+
+ if (user_fn == (func_ptr) NULL) {
+ /*
+ * a NULL func_ptr denotes untrusted function (in postgres 4.2).
+ * Untrusted functions have very limited use and is clumsy. We
+ * just get rid of it.
+ */
+ elog(WARN, "internal error: untrusted function not supported.");
+ }
+
+ switch (n_arguments) {
+ case 0:
+ returnValue = (*user_fn)();
+ break;
+ case 1:
+ /* NullValue() uses isNull to check if args[0] is NULL */
+ returnValue = (*user_fn)(values->data[0], isNull);
+ break;
+ case 2:
+ returnValue = (*user_fn)(values->data[0], values->data[1]);
+ break;
+ case 3:
+ returnValue = (*user_fn)(values->data[0], values->data[1],
+ values->data[2]);
+ break;
+ case 4:
+ returnValue = (*user_fn)(values->data[0], values->data[1],
+ values->data[2], values->data[3]);
+ break;
+ case 5:
+ returnValue = (*user_fn)(values->data[0], values->data[1],
+ values->data[2], values->data[3],
+ values->data[4]);
+ break;
+ case 6:
+ returnValue = (*user_fn)(values->data[0], values->data[1],
+ values->data[2], values->data[3],
+ values->data[4], values->data[5]);
+ break;
+ case 7:
+ returnValue = (*user_fn)(values->data[0], values->data[1],
+ values->data[2], values->data[3],
+ values->data[4], values->data[5],
+ values->data[6]);
+ break;
+ case 8:
+ returnValue = (*user_fn)(values->data[0], values->data[1],
+ values->data[2], values->data[3],
+ values->data[4], values->data[5],
+ values->data[6], values->data[7]);
+ break;
+ case 9:
+ /*
+ * XXX Note that functions with >8 arguments can only be
+ * called from inside the system, not from the user level,
+ * since the catalogs only store 8 argument types for user
+ * type-checking!
+ */
+ returnValue = (*user_fn)(values->data[0], values->data[1],
+ values->data[2], values->data[3],
+ values->data[4], values->data[5],
+ values->data[6], values->data[7],
+ values->data[8]);
+ break;
+ default:
+ elog(WARN, "fmgr_c: function %d: too many arguments (%d > %d)",
+ func_id, n_arguments, MAXFMGRARGS);
+ break;
+ }
+ return(returnValue);
+}
+
+void
+fmgr_info(Oid procedureId, func_ptr *function, int *nargs)
+{
+ func_ptr user_fn;
+ FmgrCall *fcp;
+ HeapTuple procedureTuple;
+ FormData_pg_proc *procedureStruct;
+ Oid language;
+
+ if (!(fcp = fmgr_isbuiltin(procedureId))) {
+ procedureTuple = SearchSysCacheTuple(PROOID,
+ ObjectIdGetDatum(procedureId),
+ 0,0,0);
+ if (!HeapTupleIsValid(procedureTuple)) {
+ elog(WARN, "fmgr_info: function %d: cache lookup failed\n",
+ procedureId);
+ }
+ procedureStruct = (FormData_pg_proc *)
+ GETSTRUCT(procedureTuple);
+ if (!procedureStruct->proistrusted) {
+ *function = (func_ptr) NULL;
+ *nargs = procedureStruct->pronargs;
+ return;
+ }
+ language = procedureStruct->prolang;
+ switch (language) {
+ case INTERNALlanguageId:
+ user_fn = fmgr_lookupByName(procedureStruct->proname.data);
+ if (!user_fn)
+ elog(WARN, "fmgr_info: function %s: not in internal table",
+ procedureStruct->proname.data);
+ break;
+ case ClanguageId:
+ user_fn = fmgr_dynamic(procedureId, nargs);
+ break;
+ case SQLlanguageId:
+ user_fn = (func_ptr) NULL;
+ *nargs = procedureStruct->pronargs;
+ break;
+ default:
+ elog(WARN, "fmgr_info: function %d: unknown language %d",
+ procedureId, language);
+ }
+ } else {
+ user_fn = fcp->func;
+ *nargs = fcp->nargs;
+ }
+ *function = user_fn;
+}
+
+/*
+ * fmgr - return the value of a function call
+ *
+ * If the function is a system routine, it's compiled in, so call
+ * it directly.
+ *
+ * Otherwise pass it to the the appropriate 'language' function caller.
+ *
+ * Returns the return value of the invoked function if succesful,
+ * 0 if unsuccessful.
+ */
+char *
+fmgr(Oid procedureId, ... )
+{
+ va_list pvar;
+ register i;
+ int pronargs;
+ FmgrValues values;
+ func_ptr user_fn;
+ bool isNull = false;
+
+ va_start(pvar, procedureId);
+
+ fmgr_info(procedureId, &user_fn, &pronargs);
+
+ if (pronargs > MAXFMGRARGS) {
+ elog(WARN, "fmgr: function %d: too many arguments (%d > %d)",
+ procedureId, pronargs, MAXFMGRARGS);
+ }
+ for (i = 0; i < pronargs; ++i)
+ values.data[i] = va_arg(pvar, char *);
+ va_end(pvar);
+
+ /* XXX see WAY_COOL_ORTHOGONAL_FUNCTIONS */
+ return(fmgr_c(user_fn, procedureId, pronargs, &values,
+ &isNull));
+}
+
+/*
+ * This is just a version of fmgr() in which the hacker can prepend a C
+ * function pointer. This routine is not normally called; generally,
+ * if you have all of this information you're likely to just jump through
+ * the pointer, but it's available for use with macros in fmgr.h if you
+ * want this routine to do sanity-checking for you.
+ *
+ * func_ptr, func_id, n_arguments, args...
+ */
+char *
+fmgr_ptr(func_ptr user_fn, Oid func_id, ...)
+{
+ va_list pvar;
+ register i;
+ int n_arguments;
+ FmgrValues values;
+ bool isNull = false;
+
+ va_start(pvar, func_id);
+ n_arguments = va_arg(pvar, int);
+ if (n_arguments > MAXFMGRARGS) {
+ elog(WARN, "fmgr_ptr: function %d: too many arguments (%d > %d)",
+ func_id, n_arguments, MAXFMGRARGS);
+ }
+ for (i = 0; i < n_arguments; ++i)
+ values.data[i] = va_arg(pvar, char *);
+ va_end(pvar);
+
+ /* XXX see WAY_COOL_ORTHOGONAL_FUNCTIONS */
+ return(fmgr_c(user_fn, func_id, n_arguments, &values,
+ &isNull));
+}
+
+/*
+ * This routine is not well thought out. When I get around to adding a
+ * 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)
+{
+ func_ptr user_fn;
+ int true_arguments;
+
+ fmgr_info(procedureId, &user_fn, &true_arguments);
+
+ /* XXX see WAY_COOL_ORTHOGONAL_FUNCTIONS */
+ return
+ (fmgr_c(user_fn,
+ procedureId,
+ true_arguments,
+ (FmgrValues*)args,
+ isNull));
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * fmgrtab.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: fmgrtab.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef FMGRTAB_H
+#define FMGRTAB_H
+
+#include "postgres.h" /* for ObjectId */
+#include "fmgr.h" /* genearated by Gen_fmgrtab.sh */
+
+typedef struct {
+ Oid proid;
+ uint16 nargs;
+ func_ptr func;
+ char* funcName;
+} FmgrCall;
+
+extern FmgrCall *fmgr_isbuiltin(Oid id);
+extern func_ptr fmgr_lookupByName(char* name);
+
+#endif /* FMGRTAB_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * geo-decls.h--
+ * Declarations for various 2D constructs.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: geo-decls.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ * NOTE
+ * These routines do *not* use the float types from adt/.
+ *
+ * XXX These routines were not written by a numerical analyst.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef GEO_DECLS_H
+#define GEO_DECLS_H
+
+/*#ifndef FmgrIncluded -- seems like always included. (it's FMgrIncluded) AY */
+
+/*--------------------------------------------------------------------
+ * Useful floating point utilities and constants.
+ *-------------------------------------------------------------------*/
+
+#include
+#include "c.h"
+
+#define EPSILON 1.0E-06
+
+#define FPzero(A) (fabs(A) <= EPSILON)
+#define FPeq(A,B) (fabs((A) - (B)) <= EPSILON)
+#define FPlt(A,B) ((B) - (A) > EPSILON)
+#define FPle(A,B) ((A) - (B) <= EPSILON)
+#define FPgt(A,B) ((A) - (B) > EPSILON)
+#define FPge(A,B) ((B) - (A) <= EPSILON)
+
+#define HYPOT(A, B) sqrt((A) * (A) + (B) * (B))
+
+/*--------------------------------------------------------------------
+ * Memory management.
+ *-------------------------------------------------------------------*/
+
+#define PALLOC(SIZE) palloc(SIZE)
+#define PFREE(P) pfree(P)
+#define PALLOCTYPE(TYPE) (TYPE *) PALLOC(sizeof(TYPE))
+
+/*#endif !FmgrIncluded */
+
+/*---------------------------------------------------------------------
+ * Point - (x,y)
+ *-------------------------------------------------------------------*/
+typedef struct {
+ double x, y;
+} Point;
+
+
+/*---------------------------------------------------------------------
+ * LSEG - A straight line, specified by endpoints.
+ *-------------------------------------------------------------------*/
+typedef struct {
+ Point p[2];
+
+ double m; /* precomputed to save time, not in tuple */
+} LSEG;
+
+
+/*---------------------------------------------------------------------
+ * PATH - Specified by vertex points.
+ *-------------------------------------------------------------------*/
+typedef struct {
+ int32 length; /* XXX varlena */
+ int32 npts;
+ int32 closed; /* is this a closed polygon? */
+ int32 dummy; /* padding to make it double align */
+ Point p[1]; /* variable length array of POINTs */
+} PATH;
+
+
+/*---------------------------------------------------------------------
+ * LINE - Specified by its general equation (Ax+By+C=0).
+ * If there is a y-intercept, it is C, which
+ * incidentally gives a freebie point on the line
+ * (if B=0, then C is the x-intercept).
+ * Slope m is precalculated to save time; if
+ * the line is not vertical, m == A.
+ *-------------------------------------------------------------------*/
+typedef struct {
+ double A, B, C;
+ double m;
+} LINE;
+
+
+/*---------------------------------------------------------------------
+ * BOX - Specified by two corner points, which are
+ * sorted to save calculation time later.
+ *-------------------------------------------------------------------*/
+typedef struct {
+ double xh, yh, xl, yl; /* high and low coords */
+} BOX;
+
+/*---------------------------------------------------------------------
+ * POLYGON - Specified by an array of doubles defining the points,
+ * keeping the number of points and the bounding box for
+ * speed purposes.
+ *-------------------------------------------------------------------*/
+typedef struct {
+ int32 size; /* XXX varlena */
+ int32 npts;
+ BOX boundbox;
+ char pts[1];
+} POLYGON;
+
+
+/*
+ * in geo-ops.h
+ */
+extern BOX *box_in(char *str);
+extern char *box_out(BOX *box);
+extern BOX *box_construct(double x1, double x2, double y1, double y2);
+extern BOX *box_fill(BOX *result, double x1, double x2, double y1, double y2);
+extern BOX *box_copy(BOX *box);
+extern long box_same(BOX *box1, BOX *box2);
+extern long box_overlap(BOX *box1, BOX *box2);
+extern long box_overleft(BOX *box1, BOX *box2);
+extern long box_left(BOX *box1, BOX *box2);
+extern long box_right(BOX *box1, BOX *box2);
+extern long box_overright(BOX *box1, BOX *box2);
+extern long box_contained(BOX *box1, BOX *box2);
+extern long box_contain(BOX *box1, BOX *box2);
+extern long box_below(BOX *box1, BOX *box2);
+extern long box_above(BOX *box1, BOX *box2);
+extern long box_lt(BOX *box1, BOX *box2);
+extern long box_gt(BOX *box1, BOX *box2);
+extern long box_eq(BOX *box1, BOX *box2);
+extern long box_le(BOX *box1, BOX *box2);
+extern long box_ge(BOX *box1, BOX *box2);
+extern double *box_area(BOX *box);
+extern double *box_length(BOX *box);
+extern double *box_height(BOX *box);
+extern double *box_distance(BOX *box1, BOX *box2);
+extern Point *box_center(BOX *box);
+extern double box_ar(BOX *box);
+extern double box_ln(BOX *box);
+extern double box_ht(BOX *box);
+extern double box_dt(BOX *box1, BOX *box2);
+extern BOX *box_intersect(BOX *box1, BOX *box2);
+extern LSEG *box_diagonal(BOX *box);
+extern LINE *line_construct_pm(Point *pt, double m);
+extern LINE *line_construct_pp(Point *pt1, Point *pt2);
+extern long line_intersect(LINE *l1, LINE *l2);
+extern long line_parallel(LINE *l1, LINE *l2);
+extern long line_perp(LINE *l1, LINE *l2);
+extern long line_vertical(LINE *line);
+extern long line_horizontal(LINE *line);
+extern long line_eq(LINE *l1, LINE *l2);
+extern double *line_distance(LINE *l1, LINE *l2);
+extern Point *line_interpt(LINE *l1, LINE *l2);
+extern PATH *path_in(char *str);
+extern char *path_out(PATH *path);
+extern long path_n_lt(PATH *p1, PATH *p2);
+extern long path_n_gt(PATH *p1, PATH *p2);
+extern long path_n_eq(PATH *p1, PATH *p2);
+extern long path_n_le(PATH *p1, PATH *p2);
+extern long path_n_ge(PATH *p1, PATH *p2);
+extern long path_inter(PATH *p1, PATH *p2);
+extern double *path_distance(PATH *p1, PATH *p2);
+extern double *path_length(PATH *path);
+extern double path_ln(PATH *path);
+extern Point *point_in(char *str);
+extern char *point_out(Point *pt);
+extern Point *point_construct(double x, double y);
+extern Point *point_copy(Point *pt);
+extern long point_left(Point *pt1, Point *pt2);
+extern long point_right(Point *pt1, Point *pt2);
+extern long point_above(Point *pt1, Point *pt2);
+extern long point_below(Point *pt1, Point *pt2);
+extern long point_vert(Point *pt1, Point *pt2);
+extern long point_horiz(Point *pt1, Point *pt2);
+extern long point_eq(Point *pt1, Point *pt2);
+extern long pointdist(Point *p1, Point *p2);
+extern double *point_distance(Point *pt1, Point *pt2);
+extern double point_dt(Point *pt1, Point *pt2);
+extern double *point_slope(Point *pt1, Point *pt2);
+extern double point_sl(Point *pt1, Point *pt2);
+extern LSEG *lseg_in(char *str);
+extern char *lseg_out(LSEG *ls);
+extern LSEG *lseg_construct(Point *pt1, Point *pt2);
+extern void statlseg_construct(LSEG *lseg, Point *pt1, Point *pt2);
+extern long lseg_intersect(LSEG *l1, LSEG *l2);
+extern long lseg_parallel(LSEG *l1, LSEG *l2);
+extern long lseg_perp(LSEG *l1, LSEG *l2);
+extern long lseg_vertical(LSEG *lseg);
+extern long lseg_horizontal(LSEG *lseg);
+extern long lseg_eq(LSEG *l1, LSEG *l2);
+extern double *lseg_distance(LSEG *l1, LSEG *l2);
+extern double lseg_dt(LSEG *l1, LSEG *l2);
+extern Point *lseg_interpt(LSEG *l1, LSEG *l2);
+extern double *dist_pl(Point *pt, LINE *line);
+extern double *dist_ps(Point *pt, LSEG *lseg);
+extern double *dist_ppth(Point *pt, PATH *path);
+extern double *dist_pb(Point *pt, BOX *box);
+extern double *dist_sl(LSEG *lseg, LINE *line);
+extern double *dist_sb(LSEG *lseg, BOX *box);
+extern double *dist_lb(LINE *line, BOX *box);
+extern Point *interpt_sl(LSEG *lseg, LINE *line);
+extern Point *close_pl(Point *pt, LINE *line);
+extern Point *close_ps(Point *pt, LSEG *lseg);
+extern Point *close_pb(Point *pt, BOX *box);
+extern Point *close_sl(LSEG *lseg, LINE *line);
+extern Point *close_sb(LSEG *lseg, BOX *box);
+extern Point *close_lb(LINE *line, BOX *box);
+extern long on_pl(Point *pt, LINE *line);
+extern long on_ps(Point *pt, LSEG *lseg);
+extern long on_pb(Point *pt, BOX *box);
+extern long on_ppath(Point *pt, PATH *path);
+extern long on_sl(LSEG *lseg, LINE *line);
+extern long on_sb(LSEG *lseg, BOX *box);
+extern long inter_sl(LSEG *lseg, LINE *line);
+extern long inter_sb(LSEG *lseg, BOX *box);
+extern long inter_lb(LINE *line, BOX *box);
+extern void make_bound_box(POLYGON *poly);
+extern POLYGON *poly_in(char *s);
+extern long poly_pt_count(char *s, char delim);
+extern char *poly_out(POLYGON *poly);
+extern double poly_max(double *coords, int ncoords);
+extern double poly_min(double *coords, int ncoords);
+extern long poly_left(POLYGON *polya, POLYGON *polyb);
+extern long poly_overleft(POLYGON *polya, POLYGON *polyb);
+extern long poly_right(POLYGON *polya, POLYGON *polyb);
+extern long poly_overright(POLYGON *polya, POLYGON *polyb);
+extern long poly_same(POLYGON *polya, POLYGON *polyb);
+extern long poly_overlap(POLYGON *polya, POLYGON *polyb);
+extern long poly_contain(POLYGON *polya, POLYGON *polyb);
+extern long poly_contained(POLYGON *polya, POLYGON *polyb);
+
+/* geo-selfuncs.c */
+#if 0 /* FIX ME! */
+extern float64 areasel(Oid opid, Oid relid, AttrNumber attno, char *value, int32 flag);
+extern float64 areajoinsel(Oid opid, Oid relid, AttrNumber attno, char *value, int32 flag);
+extern float64 leftsel(Oid opid, Oid relid, AttrNumber attno, char *value, int32 flag);
+extern float64 leftjoinsel(Oid opid, Oid relid, AttrNumber attno, char *value, int32 flag);
+extern float64 contsel(Oid opid, Oid relid, AttrNumber attno, char *value, int32 flag);
+extern float64 contjoinsel(Oid opid, Oid relid, AttrNumber attno, char *value, int32 flag);
+#endif
+
+#endif /* GEO_DECLS_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for utils/hash
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/utils/hash/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:22:08 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= dynahash.c hashfn.c
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * dynahash.c--
+ * dynamic hashing
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/hash/dynahash.c,v 1.1.1.1 1996/07/09 06:22:08 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ *
+ * Dynamic hashing, after CACM April 1988 pp 446-457, by Per-Ake Larson.
+ * Coded into C, with minor code improvements, and with hsearch(3) interface,
+ * also, hcreate/hdestroy routines added to simulate hsearch(3).
+ *
+ * These routines simulate hsearch(3) and family, with the important
+ * difference that the hash table is dynamic - can grow indefinitely
+ * beyond its original size (as supplied to hcreate()).
+ *
+ * Performance appears to be comparable to that of hsearch(3).
+ * The 'source-code' options referred to in hsearch(3)'s 'man' page
+ * are not implemented; otherwise functionality is identical.
+ *
+ * Compilation controls:
+ * DEBUG controls some informative traces, mainly for debugging.
+ * HASH_STATISTICS causes HashAccesses and HashCollisions to be maintained;
+ * when combined with HASH_DEBUG, these are displayed by hdestroy().
+ *
+ * concatenation property, in probably unnecessary code 'optimisation'.
+ *
+ * added multiple table interface
+ * changed ctl structure for shared memory
+ */
+# include
+# include
+# include
+# include "postgres.h"
+# include "utils/hsearch.h"
+#ifndef FRONTEND
+# include "nodes/memnodes.h"
+# include "utils/mcxt.h"
+#endif /* !FRONTEND */
+# include "utils/palloc.h"
+# include "utils/elog.h"
+
+/*
+ * Fast arithmetic, relying on powers of 2,
+ * and on pre-processor concatenation property
+ */
+
+# define MOD(x,y) ((x) & ((y)-1))
+
+/*
+ * external routines
+ */
+
+/*
+ * Private function prototypes
+ */
+static long *DynaHashAlloc(unsigned int size);
+static void DynaHashFree(Pointer ptr);
+static int hash_clear(HTAB *hashp);
+static uint32 call_hash(HTAB *hashp, char *k, int len);
+static SEG_OFFSET seg_alloc(HTAB *hashp);
+static int bucket_alloc(HTAB *hashp);
+static int dir_realloc(HTAB *hashp);
+
+typedef long * ((*dhalloc_ptr)());
+
+#ifndef FRONTEND
+/* ----------------
+ * memory allocation routines
+ *
+ * for postgres: all hash elements have to be in
+ * the global cache context. Otherwise the postgres
+ * garbage collector is going to corrupt them. -wei
+ *
+ * ??? the "cache" memory context is intended to store only
+ * system cache information. The user of the hashing
+ * routines should specify which context to use or we
+ * should create a separate memory context for these
+ * hash routines. For now I have modified this code to
+ * do the latter -cim 1/19/91
+ * ----------------
+ */
+GlobalMemory DynaHashCxt = (GlobalMemory) NULL;
+
+static long *
+DynaHashAlloc(unsigned int size)
+{
+ if (! DynaHashCxt)
+ DynaHashCxt = CreateGlobalMemory("DynaHash");
+
+ return (long *)
+ MemoryContextAlloc((MemoryContext)DynaHashCxt, size);
+}
+
+static void
+DynaHashFree(Pointer ptr)
+{
+ MemoryContextFree((MemoryContext)DynaHashCxt, ptr);
+}
+
+#define MEM_ALLOC DynaHashAlloc
+#define MEM_FREE DynaHashFree
+
+#else /* FRONTEND */
+
+#define MEM_ALLOC palloc
+#define MEM_FREE pfree
+
+#endif /* FRONTEND */
+
+/* ----------------
+ * Internal routines
+ * ----------------
+ */
+
+static int expand_table();
+static int hdefault();
+static int init_htab();
+
+
+/*
+ * pointer access macros. Shared memory implementation cannot
+ * store pointers in the hash table data structures because
+ * pointer values will be different in different address spaces.
+ * these macros convert offsets to pointers and pointers to offsets.
+ * Shared memory need not be contiguous, but all addresses must be
+ * calculated relative to some offset (segbase).
+ */
+
+#define GET_SEG(hp,seg_num)\
+ (SEGMENT) (((unsigned long) (hp)->segbase) + (hp)->dir[seg_num])
+
+#define GET_BUCKET(hp,bucket_offs)\
+ (ELEMENT *) (((unsigned long) (hp)->segbase) + bucket_offs)
+
+#define MAKE_HASHOFFSET(hp,ptr)\
+ ( ((unsigned long) ptr) - ((unsigned long) (hp)->segbase) )
+
+# if HASH_STATISTICS
+static long hash_accesses, hash_collisions, hash_expansions;
+# endif
+
+/************************** CREATE ROUTINES **********************/
+
+HTAB *
+hash_create(int nelem, HASHCTL *info, int flags)
+{
+ register HHDR * hctl;
+ HTAB * hashp;
+
+
+ hashp = (HTAB *) MEM_ALLOC((unsigned long) sizeof(HTAB));
+ memset(hashp, 0, sizeof(HTAB));
+
+ if ( flags & HASH_FUNCTION ) {
+ hashp->hash = info->hash;
+ } else {
+ /* default */
+ hashp->hash = string_hash;
+ }
+
+ if ( flags & HASH_SHARED_MEM ) {
+ /* ctl structure is preallocated for shared memory tables */
+
+ hashp->hctl = (HHDR *) info->hctl;
+ hashp->segbase = (char *) info->segbase;
+ hashp->alloc = info->alloc;
+ hashp->dir = (SEG_OFFSET *)info->dir;
+
+ /* hash table already exists, we're just attaching to it */
+ if (flags & HASH_ATTACH) {
+ return(hashp);
+ }
+
+ } else {
+ /* setup hash table defaults */
+
+ hashp->alloc = (dhalloc_ptr) MEM_ALLOC;
+ hashp->dir = NULL;
+ hashp->segbase = NULL;
+
+ }
+
+ if (! hashp->hctl) {
+ hashp->hctl = (HHDR *) hashp->alloc((unsigned long)sizeof(HHDR));
+ if (! hashp->hctl) {
+ return(0);
+ }
+ }
+
+ if ( !hdefault(hashp) ) return(0);
+ hctl = hashp->hctl;
+#ifdef HASH_STATISTICS
+ hctl->accesses = hctl->collisions = 0;
+#endif
+
+ if ( flags & HASH_BUCKET ) {
+ hctl->bsize = info->bsize;
+ hctl->bshift = my_log2(info->bsize);
+ }
+ if ( flags & HASH_SEGMENT ) {
+ hctl->ssize = info->ssize;
+ hctl->sshift = my_log2(info->ssize);
+ }
+ if ( flags & HASH_FFACTOR ) {
+ hctl->ffactor = info->ffactor;
+ }
+
+ /*
+ * SHM hash tables have fixed maximum size (allocate
+ * a maximal sized directory).
+ */
+ if ( flags & HASH_DIRSIZE ) {
+ hctl->max_dsize = my_log2(info->max_size);
+ hctl->dsize = my_log2(info->dsize);
+ }
+ /* hash table now allocates space for key and data
+ * but you have to say how much space to allocate
+ */
+ if ( flags & HASH_ELEM ) {
+ hctl->keysize = info->keysize;
+ hctl->datasize = info->datasize;
+ }
+ if ( flags & HASH_ALLOC ) {
+ hashp->alloc = info->alloc;
+ }
+
+ if ( init_htab (hashp, nelem ) ) {
+ hash_destroy(hashp);
+ return(0);
+ }
+ return(hashp);
+}
+
+/*
+ Allocate and initialize an HTAB structure
+ */
+static int
+hdefault(HTAB *hashp)
+{
+ HHDR *hctl;
+
+ memset(hashp->hctl, 0, sizeof(HHDR));
+
+ hctl = hashp->hctl;
+ hctl->bsize = DEF_BUCKET_SIZE;
+ hctl->bshift = DEF_BUCKET_SHIFT;
+ hctl->ssize = DEF_SEGSIZE;
+ hctl->sshift = DEF_SEGSIZE_SHIFT;
+ hctl->dsize = DEF_DIRSIZE;
+ hctl->ffactor = DEF_FFACTOR;
+ hctl->nkeys = 0;
+ hctl->nsegs = 0;
+
+ /* I added these MS. */
+
+ /* default memory allocation for hash buckets */
+ hctl->keysize = sizeof(char *);
+ hctl->datasize = sizeof(char *);
+
+ /* table has no fixed maximum size */
+ hctl->max_dsize = NO_MAX_DSIZE;
+
+ /* garbage collection for HASH_REMOVE */
+ hctl->freeBucketIndex = INVALID_INDEX;
+
+ return(1);
+}
+
+
+static int
+init_htab (HTAB *hashp, int nelem)
+{
+ register SEG_OFFSET *segp;
+ register int nbuckets;
+ register int nsegs;
+ int l2;
+ HHDR *hctl;
+
+ hctl = hashp->hctl;
+ /*
+ * Divide number of elements by the fill factor and determine a desired
+ * number of buckets. Allocate space for the next greater power of
+ * two number of buckets
+ */
+ nelem = (nelem - 1) / hctl->ffactor + 1;
+
+ l2 = my_log2(nelem);
+ nbuckets = 1 << l2;
+
+ hctl->max_bucket = hctl->low_mask = nbuckets - 1;
+ hctl->high_mask = (nbuckets << 1) - 1;
+
+ nsegs = (nbuckets - 1) / hctl->ssize + 1;
+ nsegs = 1 << my_log2(nsegs);
+
+ if ( nsegs > hctl->dsize ) {
+ hctl->dsize = nsegs;
+ }
+
+ /* Use two low order bits of points ???? */
+ /*
+ if ( !(hctl->mem = bit_alloc ( nbuckets )) ) return(-1);
+ if ( !(hctl->mod = bit_alloc ( nbuckets )) ) return(-1);
+ */
+
+ /* allocate a directory */
+ if (!(hashp->dir)) {
+ hashp->dir =
+ (SEG_OFFSET *)hashp->alloc(hctl->dsize * sizeof(SEG_OFFSET));
+ if (! hashp->dir)
+ return(-1);
+ }
+
+ /* Allocate initial segments */
+ for (segp = hashp->dir; hctl->nsegs < nsegs; hctl->nsegs++, segp++ ) {
+ *segp = seg_alloc(hashp);
+ if ( *segp == (SEG_OFFSET)0 ) {
+ hash_destroy(hashp);
+ return (0);
+ }
+ }
+
+# if HASH_DEBUG
+ fprintf(stderr, "%s\n%s%x\n%s%d\n%s%d\n%s%d\n%s%d\n%s%d\n%s%d\n%s%d\n%s%x\n%s%x\n%s%d\n%s%d\n",
+ "init_htab:",
+ "TABLE POINTER ", hashp,
+ "BUCKET SIZE ", hctl->bsize,
+ "BUCKET SHIFT ", hctl->bshift,
+ "DIRECTORY SIZE ", hctl->dsize,
+ "SEGMENT SIZE ", hctl->ssize,
+ "SEGMENT SHIFT ", hctl->sshift,
+ "FILL FACTOR ", hctl->ffactor,
+ "MAX BUCKET ", hctl->max_bucket,
+ "HIGH MASK ", hctl->high_mask,
+ "LOW MASK ", hctl->low_mask,
+ "NSEGS ", hctl->nsegs,
+ "NKEYS ", hctl->nkeys );
+# endif
+ return (0);
+}
+
+/********************** DESTROY ROUTINES ************************/
+
+static int
+hash_clear(HTAB *hashp)
+{
+ elog(NOTICE,"hash_clear not implemented\n");
+ return 0;
+}
+
+
+void
+hash_destroy (HTAB *hashp)
+{
+ /* cannot destroy a shared memory hash table */
+ Assert(! hashp->segbase);
+
+ if (hashp != NULL) {
+ register SEG_OFFSET segNum;
+ SEGMENT segp;
+ int nsegs = hashp->hctl->nsegs;
+ int j;
+ BUCKET_INDEX *elp,p,q;
+ ELEMENT *curr;
+
+ for (segNum = 0; nsegs > 0; nsegs--, segNum++) {
+
+ segp = GET_SEG(hashp,segNum);
+ for (j = 0, elp = segp; j < hashp->hctl->ssize; j++, elp++) {
+ for ( p = *elp; p != INVALID_INDEX; p = q ){
+ curr = GET_BUCKET(hashp,p);
+ q = curr->next;
+ MEM_FREE((char *) curr);
+ }
+ }
+ free((char *)segp);
+ }
+ (void) MEM_FREE( (char *) hashp->dir);
+ (void) MEM_FREE( (char *) hashp->hctl);
+ hash_stats("destroy",hashp);
+ (void) MEM_FREE( (char *) hashp);
+ }
+}
+
+void
+hash_stats(char *where, HTAB *hashp)
+{
+# if HASH_STATISTICS
+
+ fprintf(stderr,"%s: this HTAB -- accesses %ld collisions %ld\n",
+ where,hashp->hctl->accesses,hashp->hctl->collisions);
+
+ fprintf(stderr,"hash_stats: keys %ld keysize %ld maxp %d segmentcount %d\n",
+ hashp->hctl->nkeys, hashp->hctl->keysize,
+ hashp->hctl->max_bucket, hashp->hctl->nsegs);
+ fprintf(stderr,"%s: total accesses %ld total collisions %ld\n",
+ where, hash_accesses, hash_collisions);
+ fprintf(stderr,"hash_stats: total expansions %ld\n",
+ hash_expansions);
+
+# endif
+
+}
+
+/*******************************SEARCH ROUTINES *****************************/
+
+static uint32
+call_hash(HTAB *hashp, char *k, int len)
+{
+ long hash_val, bucket;
+ HHDR *hctl;
+
+ hctl = hashp->hctl;
+ hash_val = hashp->hash(k, len);
+
+ bucket = hash_val & hctl->high_mask;
+ if ( bucket > hctl->max_bucket ) {
+ bucket = bucket & hctl->low_mask;
+ }
+
+ return(bucket);
+}
+
+/*
+ * hash_search -- look up key in table and perform action
+ *
+ * action is one of HASH_FIND/HASH_ENTER/HASH_REMOVE
+ *
+ * RETURNS: NULL if table is corrupted, a pointer to the element
+ * found/removed/entered if applicable, TRUE otherwise.
+ * foundPtr is TRUE if we found an element in the table
+ * (FALSE if we entered one).
+ */
+long *
+hash_search(HTAB *hashp,
+ char *keyPtr,
+ HASHACTION action, /*
+ * HASH_FIND / HASH_ENTER / HASH_REMOVE
+ * HASH_FIND_SAVE / HASH_REMOVE_SAVED
+ */
+ bool *foundPtr)
+{
+ uint32 bucket;
+ long segment_num;
+ long segment_ndx;
+ SEGMENT segp;
+ register ELEMENT *curr;
+ HHDR *hctl;
+ BUCKET_INDEX currIndex;
+ BUCKET_INDEX *prevIndexPtr;
+ char * destAddr;
+ static struct State {
+ ELEMENT *currElem;
+ BUCKET_INDEX currIndex;
+ BUCKET_INDEX *prevIndex;
+ } saveState;
+
+ Assert((hashp && keyPtr));
+ Assert((action == HASH_FIND) || (action == HASH_REMOVE) || (action == HASH_ENTER) || (action == HASH_FIND_SAVE) || (action == HASH_REMOVE_SAVED));
+
+ hctl = hashp->hctl;
+
+# if HASH_STATISTICS
+ hash_accesses++;
+ hashp->hctl->accesses++;
+# endif
+ if (action == HASH_REMOVE_SAVED)
+ {
+ curr = saveState.currElem;
+ currIndex = saveState.currIndex;
+ prevIndexPtr = saveState.prevIndex;
+ /*
+ * Try to catch subsequent errors
+ */
+ Assert(saveState.currElem && !(saveState.currElem = 0));
+ }
+ else
+ {
+ bucket = call_hash(hashp, keyPtr, hctl->keysize);
+ segment_num = bucket >> hctl->sshift;
+ segment_ndx = bucket & ( hctl->ssize - 1 );
+
+ segp = GET_SEG(hashp,segment_num);
+
+ Assert(segp);
+
+ prevIndexPtr = &segp[segment_ndx];
+ currIndex = *prevIndexPtr;
+ /*
+ * Follow collision chain
+ */
+ for (curr = NULL;currIndex != INVALID_INDEX;) {
+ /* coerce bucket index into a pointer */
+ curr = GET_BUCKET(hashp,currIndex);
+
+ if (! memcmp((char *)&(curr->key), keyPtr, hctl->keysize)) {
+ break;
+ }
+ prevIndexPtr = &(curr->next);
+ currIndex = *prevIndexPtr;
+# if HASH_STATISTICS
+ hash_collisions++;
+ hashp->hctl->collisions++;
+# endif
+ }
+ }
+
+ /*
+ * if we found an entry or if we weren't trying
+ * to insert, we're done now.
+ */
+ *foundPtr = (bool) (currIndex != INVALID_INDEX);
+ switch (action) {
+ case HASH_ENTER:
+ if (currIndex != INVALID_INDEX)
+ return(&(curr->key));
+ break;
+ case HASH_REMOVE:
+ case HASH_REMOVE_SAVED:
+ if (currIndex != INVALID_INDEX) {
+ Assert(hctl->nkeys > 0);
+ hctl->nkeys--;
+
+ /* add the bucket to the freelist for this table. */
+ *prevIndexPtr = curr->next;
+ curr->next = hctl->freeBucketIndex;
+ hctl->freeBucketIndex = currIndex;
+
+ /* better hope the caller is synchronizing access to
+ * this element, because someone else is going to reuse
+ * it the next time something is added to the table
+ */
+ return (&(curr->key));
+ }
+ return((long *) TRUE);
+ case HASH_FIND:
+ if (currIndex != INVALID_INDEX)
+ return(&(curr->key));
+ return((long *)TRUE);
+ case HASH_FIND_SAVE:
+ if (currIndex != INVALID_INDEX)
+ {
+ saveState.currElem = curr;
+ saveState.prevIndex = prevIndexPtr;
+ saveState.currIndex = currIndex;
+ return(&(curr->key));
+ }
+ return((long *)TRUE);
+ default:
+ /* can't get here */
+ return (NULL);
+ }
+
+ /*
+ If we got here, then we didn't find the element and
+ we have to insert it into the hash table
+ */
+ Assert(currIndex == INVALID_INDEX);
+
+ /* get the next free bucket */
+ currIndex = hctl->freeBucketIndex;
+ if (currIndex == INVALID_INDEX) {
+
+ /* no free elements. allocate another chunk of buckets */
+ if (! bucket_alloc(hashp)) {
+ return(NULL);
+ }
+ currIndex = hctl->freeBucketIndex;
+ }
+ Assert(currIndex != INVALID_INDEX);
+
+ curr = GET_BUCKET(hashp,currIndex);
+ hctl->freeBucketIndex = curr->next;
+
+ /* link into chain */
+ *prevIndexPtr = currIndex;
+
+ /* copy key and data */
+ destAddr = (char *) &(curr->key);
+ memmove(destAddr,keyPtr,hctl->keysize);
+ curr->next = INVALID_INDEX;
+
+ /* let the caller initialize the data field after
+ * hash_search returns.
+ */
+ /* memmove(destAddr,keyPtr,hctl->keysize+hctl->datasize);*/
+
+ /*
+ * Check if it is time to split the segment
+ */
+ if (++hctl->nkeys / (hctl->max_bucket+1) > hctl->ffactor) {
+ /*
+ fprintf(stderr,"expanding on '%s'\n",keyPtr);
+ hash_stats("expanded table",hashp);
+ */
+ if (! expand_table(hashp))
+ return(NULL);
+ }
+ return (&(curr->key));
+}
+
+/*
+ * hash_seq -- sequentially search through hash table and return
+ * all the elements one by one, return NULL on error and
+ * return TRUE in the end.
+ *
+ */
+long *
+hash_seq(HTAB *hashp)
+{
+ static uint32 curBucket = 0;
+ static BUCKET_INDEX curIndex;
+ ELEMENT *curElem;
+ long segment_num;
+ long segment_ndx;
+ SEGMENT segp;
+ HHDR *hctl;
+
+ if (hashp == NULL)
+ {
+ /*
+ * reset static state
+ */
+ curBucket = 0;
+ curIndex = INVALID_INDEX;
+ return((long *) NULL);
+ }
+
+ hctl = hashp->hctl;
+ while (curBucket <= hctl->max_bucket) {
+ if (curIndex != INVALID_INDEX) {
+ curElem = GET_BUCKET(hashp, curIndex);
+ curIndex = curElem->next;
+ if (curIndex == INVALID_INDEX) /* end of this bucket */
+ ++curBucket;
+ return(&(curElem->key));
+ }
+
+ /*
+ * initialize the search within this bucket.
+ */
+ segment_num = curBucket >> hctl->sshift;
+ segment_ndx = curBucket & ( hctl->ssize - 1 );
+
+ /*
+ * first find the right segment in the table directory.
+ */
+ segp = GET_SEG(hashp, segment_num);
+ if (segp == NULL)
+ /* this is probably an error */
+ return((long *) NULL);
+
+ /*
+ * now find the right index into the segment for the first
+ * item in this bucket's chain. if the bucket is not empty
+ * (its entry in the dir is valid), we know this must
+ * correspond to a valid element and not a freed element
+ * because it came out of the directory of valid stuff. if
+ * there are elements in the bucket chains that point to the
+ * freelist we're in big trouble.
+ */
+ curIndex = segp[segment_ndx];
+
+ if (curIndex == INVALID_INDEX) /* empty bucket */
+ ++curBucket;
+ }
+
+ return((long *) TRUE); /* out of buckets */
+}
+
+
+/********************************* UTILITIES ************************/
+static int
+expand_table(HTAB *hashp)
+{
+ HHDR *hctl;
+ SEGMENT old_seg,new_seg;
+ long old_bucket, new_bucket;
+ long new_segnum, new_segndx;
+ long old_segnum, old_segndx;
+ ELEMENT *chain;
+ BUCKET_INDEX *old,*newbi;
+ register BUCKET_INDEX chainIndex,nextIndex;
+
+#ifdef HASH_STATISTICS
+ hash_expansions++;
+#endif
+
+ hctl = hashp->hctl;
+ new_bucket = ++hctl->max_bucket;
+ old_bucket = (hctl->max_bucket & hctl->low_mask);
+
+ new_segnum = new_bucket >> hctl->sshift;
+ new_segndx = MOD ( new_bucket, hctl->ssize );
+
+ if ( new_segnum >= hctl->nsegs ) {
+
+ /* Allocate new segment if necessary */
+ if (new_segnum >= hctl->dsize) {
+ dir_realloc(hashp);
+ }
+ if (! (hashp->dir[new_segnum] = seg_alloc(hashp))) {
+ return (0);
+ }
+ hctl->nsegs++;
+ }
+
+
+ if ( new_bucket > hctl->high_mask ) {
+ /* Starting a new doubling */
+ hctl->low_mask = hctl->high_mask;
+ hctl->high_mask = new_bucket | hctl->low_mask;
+ }
+
+ /*
+ * Relocate records to the new bucket
+ */
+ old_segnum = old_bucket >> hctl->sshift;
+ old_segndx = MOD(old_bucket, hctl->ssize);
+
+ old_seg = GET_SEG(hashp,old_segnum);
+ new_seg = GET_SEG(hashp,new_segnum);
+
+ old = &old_seg[old_segndx];
+ newbi = &new_seg[new_segndx];
+ for (chainIndex = *old;
+ chainIndex != INVALID_INDEX;
+ chainIndex = nextIndex){
+
+ chain = GET_BUCKET(hashp,chainIndex);
+ nextIndex = chain->next;
+ if ( call_hash(hashp,
+ (char *)&(chain->key),
+ hctl->keysize) == old_bucket ) {
+ *old = chainIndex;
+ old = &chain->next;
+ } else {
+ *newbi = chainIndex;
+ newbi = &chain->next;
+ }
+ chain->next = INVALID_INDEX;
+ }
+ return (1);
+}
+
+
+static int
+dir_realloc(HTAB *hashp)
+{
+ register char *p;
+ char **p_ptr;
+ long old_dirsize;
+ long new_dirsize;
+
+
+ if (hashp->hctl->max_dsize != NO_MAX_DSIZE)
+ return (0);
+
+ /* Reallocate directory */
+ old_dirsize = hashp->hctl->dsize * sizeof ( SEGMENT * );
+ new_dirsize = old_dirsize << 1;
+
+ p_ptr = (char **) hashp->dir;
+ p = (char *) hashp->alloc((unsigned long) new_dirsize );
+ if (p != NULL) {
+ memmove(p, *p_ptr, old_dirsize );
+ memset ( *p_ptr + old_dirsize, 0, new_dirsize-old_dirsize );
+ (void) free( (char *)*p_ptr);
+ *p_ptr = p;
+ hashp->hctl->dsize = new_dirsize;
+ return(1);
+ }
+ return (0);
+
+}
+
+
+static SEG_OFFSET
+seg_alloc(HTAB * hashp)
+{
+ SEGMENT segp;
+ SEG_OFFSET segOffset;
+
+
+ segp = (SEGMENT) hashp->alloc((unsigned long)
+ sizeof(SEGMENT)*hashp->hctl->ssize);
+
+ if (! segp) {
+ return(0);
+ }
+
+ memset((char *)segp, 0,
+ (long) sizeof(SEGMENT)*hashp->hctl->ssize);
+
+ segOffset = MAKE_HASHOFFSET(hashp,segp);
+ return(segOffset);
+}
+
+/*
+ * allocate some new buckets and link them into the free list
+ */
+static int
+bucket_alloc(HTAB *hashp)
+{
+ int i;
+ ELEMENT *tmpBucket;
+ long bucketSize;
+ BUCKET_INDEX tmpIndex,lastIndex;
+
+ bucketSize =
+ sizeof(BUCKET_INDEX) + hashp->hctl->keysize + hashp->hctl->datasize;
+
+ /* make sure its aligned correctly */
+ bucketSize += sizeof(long *) - (bucketSize % sizeof(long *));
+
+ /* tmpIndex is the shmem offset into the first bucket of
+ * the array.
+ */
+ tmpBucket = (ELEMENT *)
+ hashp->alloc((unsigned long) BUCKET_ALLOC_INCR*bucketSize);
+
+ if (! tmpBucket) {
+ return(0);
+ }
+
+ tmpIndex = MAKE_HASHOFFSET(hashp,tmpBucket);
+
+ /* set the freebucket list to point to the first bucket */
+ lastIndex = hashp->hctl->freeBucketIndex;
+ hashp->hctl->freeBucketIndex = tmpIndex;
+
+ /* initialize each bucket to point to the one behind it */
+ for (i=0;i<(BUCKET_ALLOC_INCR-1);i++) {
+ tmpBucket = GET_BUCKET(hashp,tmpIndex);
+ tmpIndex += bucketSize;
+ tmpBucket->next = tmpIndex;
+ }
+
+ /* the last bucket points to the old freelist head (which is
+ * probably invalid or we wouldnt be here)
+ */
+ tmpBucket->next = lastIndex;
+
+ return(1);
+}
+
+/* calculate the log base 2 of num */
+int
+my_log2(long num)
+{
+ int i = 1;
+ int limit;
+
+ for ( i = 0, limit = 1; limit < num; limit = 2 * limit, i++ );
+ return (i);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * hashfn.c--
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/hash/hashfn.c,v 1.1.1.1 1996/07/09 06:22:08 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "utils/hsearch.h"
+
+/*
+ * Assume that we've already split the bucket to which this
+ * key hashes, calculate that bucket, and check that in fact
+ * we did already split it.
+ */
+long
+string_hash(char *key, int keysize)
+{
+ int h;
+ register unsigned char *k = (unsigned char *) key;
+
+ h = 0;
+ /*
+ * Convert string to integer
+ */
+ while (*k)
+ h = h * PRIME1 ^ (*k++ - ' ');
+ h %= PRIME2;
+
+ return (h);
+}
+
+
+long
+tag_hash(int *key, int keysize)
+{
+ register long h = 0;
+
+ /*
+ * Convert tag to integer; Use four byte chunks in a "jump table"
+ * to go a little faster. Currently the maximum keysize is 16
+ * (mar 17 1992) I have put in cases for up to 24. Bigger than
+ * this will resort to the old behavior of the for loop. (see the
+ * default case).
+ */
+ switch (keysize)
+ {
+ case 6*sizeof(int):
+ h = h * PRIME1 ^ (*key);
+ key++;
+ /* fall through */
+
+ case 5*sizeof(int):
+ h = h * PRIME1 ^ (*key);
+ key++;
+ /* fall through */
+
+ case 4*sizeof(int):
+ h = h * PRIME1 ^ (*key);
+ key++;
+ /* fall through */
+
+ case 3*sizeof(int):
+ h = h * PRIME1 ^ (*key);
+ key++;
+ /* fall through */
+
+ case 2*sizeof(int):
+ h = h * PRIME1 ^ (*key);
+ key++;
+ /* fall through */
+
+ case sizeof(int):
+ h = h * PRIME1 ^ (*key);
+ key++;
+ break;
+
+ default:
+ for(; keysize > (sizeof(int)-1); keysize -= sizeof(int), key++)
+ h = h * PRIME1 ^ (*key);
+ /*
+ * now let's grab the last few bytes of the tag if the tag
+ * has (size % 4) != 0 (which it sometimes will on a sun3).
+ */
+ if (keysize)
+ {
+ char *keytmp = (char *)key;
+
+ switch (keysize)
+ {
+ case 3:
+ h = h * PRIME1 ^ (*keytmp);
+ keytmp++;
+ /* fall through */
+ case 2:
+ h = h * PRIME1 ^ (*keytmp);
+ keytmp++;
+ /* fall through */
+ case 1:
+ h = h * PRIME1 ^ (*keytmp);
+ break;
+ }
+ }
+ break;
+ }
+
+ h %= PRIME2;
+ return (h);
+}
+
+/*
+ * This is INCREDIBLY ugly, but fast.
+ * We break the string up into 8 byte units. On the first time
+ * through the loop we get the "leftover bytes" (strlen % 8).
+ * On every other iteration, we perform 8 HASHC's so we handle
+ * all 8 bytes. Essentially, this saves us 7 cmp & branch
+ * instructions. If this routine is heavily used enough, it's
+ * worth the ugly coding
+ */
+long
+disk_hash(char *key)
+{
+ register int n = 0;
+ register char *str = key;
+ register int len = strlen(key);
+ register int loop;
+
+#define HASHC n = *str++ + 65599 * n
+
+ if (len > 0) {
+ loop = (len + 8 - 1) >> 3;
+
+ switch(len & (8 - 1)) {
+ case 0: do { /* All fall throughs */
+ HASHC;
+ case 7: HASHC;
+ case 6: HASHC;
+ case 5: HASHC;
+ case 4: HASHC;
+ case 3: HASHC;
+ case 2: HASHC;
+ case 1: HASHC;
+ } while (--loop);
+ }
+
+ }
+ return(n);
+}
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * hsearch.h--
+ * for hashing in the new buffer manager
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: hsearch.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef HSEARCH_H
+#define HSEARCH_H
+
+#include "postgres.h"
+
+/*
+ * Constants
+ */
+# define DEF_BUCKET_SIZE 256
+# define DEF_BUCKET_SHIFT 8 /* log2(BUCKET) */
+# define DEF_SEGSIZE 256
+# define DEF_SEGSIZE_SHIFT 8 /* log2(SEGSIZE) */
+# define DEF_DIRSIZE 256
+# define PRIME1 37
+# define PRIME2 1048583
+# define DEF_FFACTOR 1
+# define SPLTMAX 8
+
+
+/*
+ * Hash bucket is actually bigger than this. Key field can have
+ * variable length and a variable length data field follows it.
+ */
+typedef struct element {
+ unsigned long next; /* secret from user */
+ long key;
+} ELEMENT;
+
+typedef unsigned long BUCKET_INDEX;
+/* segment is an array of bucket pointers */
+typedef BUCKET_INDEX *SEGMENT;
+typedef unsigned long SEG_OFFSET;
+
+typedef struct hashhdr {
+ long bsize; /* Bucket/Page Size */
+ long bshift; /* Bucket shift */
+ long dsize; /* Directory Size */
+ long ssize; /* Segment Size */
+ long sshift; /* Segment shift */
+ long max_bucket; /* ID of Maximum bucket in use */
+ long high_mask; /* Mask to modulo into entire table */
+ long low_mask; /* Mask to modulo into lower half of table */
+ long ffactor; /* Fill factor */
+ long nkeys; /* Number of keys in hash table */
+ long nsegs; /* Number of allocated segments */
+ long keysize; /* hash key length in bytes */
+ long datasize; /* elem data length in bytes */
+ long max_dsize; /* 'dsize' limit if directory is fixed size */
+ BUCKET_INDEX freeBucketIndex;
+ /* index of first free bucket */
+#ifdef HASH_STATISTICS
+ long accesses;
+ long collisions;
+#endif
+} HHDR;
+
+typedef struct htab {
+ HHDR *hctl; /* shared control information */
+ long (*hash)(); /* Hash Function */
+ char *segbase; /* segment base address for
+ * calculating pointer values
+ */
+ SEG_OFFSET *dir; /* 'directory' of segm starts */
+ long *(*alloc)(); /* memory allocator
+ * (long * for alignment reasons)
+ */
+
+} HTAB;
+
+typedef struct hashctl {
+ long bsize; /* Bucket Size */
+ long ssize; /* Segment Size */
+ long dsize; /* Dirsize Size */
+ long ffactor; /* Fill factor */
+ long (*hash)(); /* Hash Function */
+ long keysize; /* hash key length in bytes */
+ long datasize; /* elem data length in bytes */
+ long max_size; /* limit to dsize if directory size is limited */
+ long *segbase; /* base for calculating bucket + seg ptrs */
+ long * (*alloc)(); /* memory allocation function */
+ long *dir; /* directory if allocated already */
+ long *hctl; /* location of header information in shd mem */
+} HASHCTL;
+
+/* Flags to indicate action for hctl */
+#define HASH_BUCKET 0x001 /* Setting bucket size */
+#define HASH_SEGMENT 0x002 /* Setting segment size */
+#define HASH_DIRSIZE 0x004 /* Setting directory size */
+#define HASH_FFACTOR 0x008 /* Setting fill factor */
+#define HASH_FUNCTION 0x010 /* Set user defined hash function */
+#define HASH_ELEM 0x020 /* Setting key/data size */
+#define HASH_SHARED_MEM 0x040 /* Setting shared mem const */
+#define HASH_ATTACH 0x080 /* Do not initialize hctl */
+#define HASH_ALLOC 0x100 /* Setting memory allocator */
+
+
+/* seg_alloc assumes that INVALID_INDEX is 0*/
+#define INVALID_INDEX (0)
+#define NO_MAX_DSIZE (-1)
+/* number of hash buckets allocated at once */
+#define BUCKET_ALLOC_INCR (30)
+
+/* hash_search operations */
+typedef enum {
+ HASH_FIND,
+ HASH_ENTER,
+ HASH_REMOVE,
+ HASH_FIND_SAVE,
+ HASH_REMOVE_SAVED
+} HASHACTION;
+
+/*
+ * prototypes from functions in dynahash.c
+ */
+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,
+ bool *foundPtr);
+extern long *hash_seq(HTAB *hashp);
+
+/*
+ * prototypes from functions in hashfn.c
+ */
+extern long string_hash(char *key, int keysize);
+extern long tag_hash(int *key, int keysize);
+extern long disk_hash(char *key);
+
+#endif /* HSEARCH_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for utils/init
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/utils/init/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:22:08 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= enbl.c findbe.c globals.c magic.c miscinit.c postinit.c
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * enbl.c--
+ * POSTGRES module enable and disable support code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/init/Attic/enbl.c,v 1.1.1.1 1996/07/09 06:22:08 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "c.h"
+#include "utils/module.h" /* where the declarations go */
+
+/*
+ * BypassEnable --
+ * False iff enable/disable processing is required given on and "*countP."
+ *
+ * Note:
+ * As a side-effect, *countP is modified. It should be 0 initially.
+ *
+ * Exceptions:
+ * BadState if called with pointer to value 0 and false.
+ * BadArg if "countP" is invalid pointer.
+ * BadArg if on is invalid.
+ */
+bool
+BypassEnable(int *enableCountInOutP, bool on)
+{
+ AssertArg(PointerIsValid(enableCountInOutP));
+ AssertArg(BoolIsValid(on));
+
+ if (on) {
+ *enableCountInOutP += 1;
+ return ((bool)(*enableCountInOutP >= 2));
+ }
+
+ AssertState(*enableCountInOutP >= 1);
+
+ *enableCountInOutP -= 1;
+
+ return ((bool)(*enableCountInOutP >= 1));
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * findbe.c --
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/init/Attic/findbe.c,v 1.1.1.1 1996/07/09 06:22:08 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#ifndef WIN32
+#include
+#else
+#include
+#endif /* WIN32 */
+#include
+#include
+#include
+
+#include "c.h"
+#include "miscadmin.h" /* for DebugLvl */
+
+#ifndef S_IRUSR /* XXX [TRH] should be in a header */
+# define S_IRUSR S_IREAD
+# define S_IWUSR S_IWRITE
+# define S_IXUSR S_IEXEC
+# define S_IRGRP ((S_IRUSR)>>3)
+# define S_IWGRP ((S_IWUSR)>>3)
+# define S_IXGRP ((S_IXUSR)>>3)
+# define S_IROTH ((S_IRUSR)>>6)
+# define S_IWOTH ((S_IWUSR)>>6)
+# define S_IXOTH ((S_IXUSR)>>6)
+#endif
+
+/*
+ * ValidateBackend -- validate "path" as a POSTGRES executable file
+ *
+ * returns 0 if the file is found and no error is encountered.
+ * -1 if the regular file "path" does not exist or cannot be executed.
+ * -2 if the file is otherwise valid but cannot be read.
+ */
+int
+ValidateBackend(char *path)
+{
+#ifndef WIN32
+ struct stat buf;
+ uid_t euid;
+ struct group *gp;
+ struct passwd *pwp;
+ int i;
+ int is_r = 0;
+ int is_x = 0;
+ int in_grp = 0;
+#else
+ DWORD file_attributes;
+#endif /* WIN32 */
+
+ /*
+ * Ensure that the file exists and is a regular file.
+ *
+ * XXX if you have a broken system where stat() looks at the symlink
+ * instead of the underlying file, you lose.
+ */
+ if (strlen(path) >= MAXPGPATH) {
+ if (DebugLvl > 1)
+ fprintf(stderr, "ValidateBackend: pathname \"%s\" is too long\n",
+ path);
+ return(-1);
+ }
+
+#ifndef WIN32
+ if (stat(path, &buf) < 0) {
+ if (DebugLvl > 1)
+ fprintf(stderr, "ValidateBackend: can't stat \"%s\"\n",
+ path);
+ return(-1);
+ }
+ if (!(buf.st_mode & S_IFREG)) {
+ if (DebugLvl > 1)
+ fprintf(stderr, "ValidateBackend: \"%s\" is not a regular file\n",
+ path);
+ return(-1);
+ }
+
+ /*
+ * Ensure that we are using an authorized backend.
+ *
+ * XXX I'm open to suggestions here. I would like to enforce ownership
+ * of backends by user "postgres" but people seem to like to run
+ * as users other than "postgres"...
+ */
+
+ /*
+ * Ensure that the file is both executable and readable (required for
+ * dynamic loading).
+ *
+ * We use the effective uid here because the backend will not have
+ * executed setuid() by the time it calls this routine.
+ */
+ euid = geteuid();
+ if (euid == buf.st_uid) {
+ is_r = buf.st_mode & S_IRUSR;
+ is_x = buf.st_mode & S_IXUSR;
+ if (DebugLvl > 1 && !(is_r && is_x))
+ fprintf(stderr, "ValidateBackend: \"%s\" is not user read/execute\n",
+ path);
+ return(is_x ? (is_r ? 0 : -2) : -1);
+ }
+ pwp = getpwuid(euid);
+ if (pwp) {
+ if (pwp->pw_gid == buf.st_gid) {
+ ++in_grp;
+ } else if (pwp->pw_name &&
+ (gp = getgrgid(buf.st_gid))) {
+ for (i = 0; gp->gr_mem[i]; ++i) {
+ if (!strcmp(gp->gr_mem[i], pwp->pw_name)) {
+ ++in_grp;
+ break;
+ }
+ }
+ }
+ if (in_grp) {
+ is_r = buf.st_mode & S_IRGRP;
+ is_x = buf.st_mode & S_IXGRP;
+ if (DebugLvl > 1 && !(is_r && is_x))
+ fprintf(stderr, "ValidateBackend: \"%s\" is not group read/execute\n",
+ path);
+ return(is_x ? (is_r ? 0 : -2) : -1);
+ }
+ }
+ is_r = buf.st_mode & S_IROTH;
+ is_x = buf.st_mode & S_IXOTH;
+ if (DebugLvl > 1 && !(is_r && is_x))
+ fprintf(stderr, "ValidateBackend: \"%s\" is not other read/execute\n",
+ path);
+ return(is_x ? (is_r ? 0 : -2) : -1);
+#else
+ file_attributes = GetFileAttributes(path);
+ if(file_attributes != 0xFFFFFFFF)
+ return(0);
+ else
+ return(-1);
+#endif /* WIN32 */
+}
+
+/*
+ * FindBackend -- find an absolute path to a valid backend executable
+ *
+ * The reason we have to work so hard to find an absolute path is that
+ * we need to feed the backend server the location of its actual
+ * executable file -- otherwise, we can't do dynamic loading.
+ */
+int
+FindBackend(char *backend, char *argv0)
+{
+ char buf[MAXPGPATH + 2];
+ char *p;
+ char *path, *startp, *endp;
+ int pathlen;
+
+#ifdef WIN32
+ strcpy(backend, argv0);
+ return(0);
+#endif /* WIN32 */
+
+ /*
+ * for the postmaster:
+ * First try: use the backend that's located in the same directory
+ * as the postmaster, if it was invoked with an explicit path.
+ * Presumably the user used an explicit path because it wasn't in
+ * PATH, and we don't want to use incompatible executables.
+ *
+ * This has the neat property that it works for installed binaries,
+ * old source trees (obj/support/post{master,gres}) and new marc
+ * source trees (obj/post{master,gres}) because they all put the
+ * two binaries in the same place.
+ *
+ * for the backend server:
+ * First try: if we're given some kind of path, use it (making sure
+ * that a relative path is made absolute before returning it).
+ */
+ if (argv0 && (p = strrchr(argv0, '/')) && *++p) {
+ if (*argv0 == '/' || !getcwd(buf, MAXPGPATH))
+ buf[0] = '\0';
+ else
+ (void) strcat(buf, "/");
+ (void) strcat(buf, argv0);
+ p = strrchr(buf, '/');
+ (void) strcpy(++p, "postgres");
+ if (!ValidateBackend(buf)) {
+ (void) strncpy(backend, buf, MAXPGPATH);
+ if (DebugLvl)
+ fprintf(stderr, "FindBackend: found \"%s\" using argv[0]\n",
+ backend);
+ return(0);
+ }
+ fprintf(stderr, "FindBackend: invalid backend \"%s\"\n",
+ buf);
+ return(-1);
+ }
+
+ /*
+ * Second try: since no explicit path was supplied, the user must
+ * have been relying on PATH. We'll use the same PATH.
+ */
+ if ((p = getenv("PATH")) && *p) {
+ if (DebugLvl)
+ fprintf(stderr, "FindBackend: searching PATH ...\n");
+ pathlen = strlen(p);
+ path = malloc(pathlen + 1);
+ (void) strcpy(path, p);
+ for (startp = path, endp = strchr(path, ':');
+ startp && *startp;
+ startp = endp + 1, endp = strchr(startp, ':')) {
+ if (startp == endp) /* it's a "::" */
+ continue;
+ if (endp)
+ *endp = '\0';
+ if (*startp == '/' || !getcwd(buf, MAXPGPATH))
+ buf[0] = '\0';
+ (void) strcat(buf, startp);
+ (void) strcat(buf, "/postgres");
+ switch (ValidateBackend(buf)) {
+ case 0: /* found ok */
+ (void) strncpy(backend, buf, MAXPGPATH);
+ if (DebugLvl)
+ fprintf(stderr, "FindBackend: found \"%s\" using PATH\n",
+ backend);
+ free(path);
+ return(0);
+ case -1: /* wasn't even a candidate, keep looking */
+ break;
+ case -2: /* found but disqualified */
+ fprintf(stderr, "FindBackend: could not read backend \"%s\"\n",
+ buf);
+ free(path);
+ return(-1);
+ }
+ if (!endp) /* last one */
+ break;
+ }
+ free(path);
+ }
+
+ fprintf(stderr, "FindBackend: could not find a backend to execute...\n");
+ return(-1);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * globals.c--
+ * global variable declarations
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/init/globals.c,v 1.1.1.1 1996/07/09 06:22:08 scrappy Exp $
+ *
+ * NOTES
+ * Globals used all over the place should be declared here and not
+ * in other modules.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "postgres.h"
+#include "miscadmin.h" /* where the declarations go */
+
+#include "access/heapam.h"
+#include "utils/tqual.h"
+#include "storage/sinval.h"
+#include "storage/sinvaladt.h"
+#include "storage/lmgr.h"
+#include "utils/elog.h"
+
+#include "catalog/catname.h"
+
+int Portfd = -1;
+int Noversion = 0;
+int Quiet = 1;
+
+int MasterPid;
+char* DataDir;
+
+char OutputFileName[MAXPGPATH] = "";
+
+BackendId MyBackendId;
+BackendTag MyBackendTag;
+
+char *UserName = NULL;
+char *DatabaseName = NULL;
+char *DatabasePath = NULL;
+
+bool MyDatabaseIdIsInitialized = false;
+Oid MyDatabaseId = InvalidOid;
+bool TransactionInitWasProcessed = false;
+
+bool IsUnderPostmaster = false;
+bool IsPostmaster = false;
+
+short DebugLvl = 0;
+
+char *IndexedCatalogNames[] = {
+ AttributeRelationName,
+ ProcedureRelationName,
+ TypeRelationName,
+ RelationRelationName,
+ 0
+};
+
+
+/* ----------------
+ * we just do a linear search now so there's no requirement that the list
+ * be ordered. The list is so small it shouldn't make much difference.
+ * make sure the list is null-terminated
+ * - jolly 8/19/95
+ *
+ * OLD COMMENT
+ * WARNING WARNING WARNING WARNING WARNING WARNING
+ *
+ * keep SharedSystemRelationNames[] in SORTED order! A binary search
+ * is done on it in catalog.c!
+ *
+ * XXX this is a serious hack which should be fixed -cim 1/26/90
+ * ----------------
+ */
+char *SharedSystemRelationNames[] = {
+ DatabaseRelationName,
+ DefaultsRelationName,
+ DemonRelationName,
+ GroupRelationName,
+ HostsRelationName,
+ LogRelationName,
+ MagicRelationName,
+ ServerRelationName,
+ TimeRelationName,
+ UserRelationName,
+ VariableRelationName,
+ 0
+};
+
+/* set up global variables, pointers, etc. */
+void InitGlobals()
+{
+ MasterPid = getpid();
+ DataDir = GetPGData();
+}
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * magic.c--
+ * magic number management routines
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/init/Attic/magic.c,v 1.1.1.1 1996/07/09 06:22:09 scrappy Exp $
+ *
+ * NOTES
+ * XXX eventually, should be able to handle version identifiers
+ * of length != 4.
+ *
+ * STANDALONE CODE - do not use error routines as this code is linked with
+ * stuff that does not cinterface.a
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "postgres.h"
+
+#include "utils/elog.h"
+#include "miscadmin.h" /* for global decls */
+
+#include "storage/fd.h" /* for O_ */
+
+static char Pg_verfile[] = PG_VERFILE;
+
+
+/*
+ * private function prototypes
+ */
+static void PathSetVersionFilePath(char path[], char filepathbuf[]);
+
+/*
+ * DatabaseMetaGunkIsConsistent
+ *
+ * Returns 1 iff all version numbers and ownerships are consistent.
+ *
+ * Note that we have to go through the whole rigmarole of generating the path
+ * and checking the existence of the database whether Noversion is set or not.
+ */
+int
+DatabaseMetaGunkIsConsistent(char *database, char *path)
+{
+ int isValid;
+#ifndef WIN32
+ struct stat statbuf;
+#else
+ struct _stat statbuf;
+#endif
+
+ /* XXX We haven't changed PG_VERSION since 1.1! */
+#ifndef WIN32
+ isValid = ValidPgVersion(DataDir);
+ sprintf(path, "%s/base/%s", DataDir, database);
+ isValid = ValidPgVersion(path) || isValid;
+#endif /* WIN32 */
+
+ if (stat(path, &statbuf) < 0)
+ elog(FATAL, "database %s does not exist, bailing out...",
+ database);
+
+ return(isValid);
+}
+
+
+/*
+ * ValidPgVersion - verifies the consistency of the database
+ *
+ * Returns 1 iff the catalog version number (from the version number file
+ * in the directory specified in "path") is consistent with the backend
+ * version number.
+ */
+int
+ValidPgVersion(char *path)
+{
+ int fd;
+ char version[4], buf[MAXPGPATH+1];
+#ifndef WIN32
+ struct stat statbuf;
+#else
+ struct _stat statbuf;
+#endif
+ u_short my_euid = geteuid();
+
+ PathSetVersionFilePath(path, buf);
+
+ if (stat(buf, &statbuf) >= 0) {
+ if (statbuf.st_uid != my_euid && my_euid != 0)
+ elog(FATAL,
+ "process userid (%d) != database owner (%d)",
+ my_euid, statbuf.st_uid);
+ } else
+ return(0);
+
+ if ((fd = open(buf, O_RDONLY, 0)) < 0) {
+ if (!Noversion)
+ elog(DEBUG, "ValidPgVersion: %s: %m", buf);
+ return(0);
+ }
+
+ if (read(fd, version, 4) < 4 ||
+ !isascii(version[0]) || !isdigit(version[0]) ||
+ version[1] != '.' ||
+ !isascii(version[2]) || !isdigit(version[2]) ||
+ version[3] != '\n')
+ elog(FATAL, "ValidPgVersion: %s: bad format", buf);
+ if (version[2] != '0' + PG_VERSION ||
+ version[0] != '0' + PG_RELEASE) {
+ if (!Noversion)
+ elog(DEBUG,
+ "ValidPgVersion: should be %d.%d not %c.%c",
+ PG_RELEASE, PG_VERSION, version[0], version[2]);
+ close(fd);
+ return(0);
+ }
+ close(fd);
+ return(1);
+}
+
+
+/*
+ * SetPgVersion - writes the version to a database directory
+ */
+void
+SetPgVersion(char *path)
+{
+ int fd;
+ char version[4], buf[MAXPGPATH+1];
+
+ PathSetVersionFilePath(path, buf);
+
+ if ((fd = open(buf, O_WRONLY|O_CREAT|O_EXCL, 0666)) < 0)
+ elog(FATAL, "SetPgVersion: %s: %m", buf);
+
+ version[0] = '0' + PG_RELEASE;
+ version[1] = '.';
+ version[2] = '0' + PG_VERSION;
+ version[3] = '\n';
+ if (write(fd, version, 4) != 4)
+ elog(WARN, "SetPgVersion: %s: %m", buf);
+
+ close(fd);
+}
+
+
+/*
+ * PathSetVersionFilePath
+ *
+ * Destructively change "filepathbuf" to contain the concatenation of "path"
+ * and the name of the version file name.
+ */
+static void
+PathSetVersionFilePath(char *path, char *filepathbuf)
+{
+ if (strlen(path) > (MAXPGPATH - sizeof(Pg_verfile) - 1))
+ elog(FATAL, "PathSetVersionFilePath: %s: path too long");
+ (void) sprintf(filepathbuf, "%s%c%s", path, SEP_CHAR, Pg_verfile);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * miscinit.c--
+ * miscellanious initialization support stuff
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/init/miscinit.c,v 1.1.1.1 1996/07/09 06:22:09 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include /* for MAXPATHLEN */
+#include
+#include
+#include
+#include
+#ifndef WIN32
+#include /* for getgrgid */
+#include
/* for getpwuid */+#endif /* WIN32 */
+
+#include "postgres.h"
+
+#include "utils/portal.h" /* for EnablePortalManager, etc. */
+#include "utils/exc.h" /* for EnableExceptionHandling, etc. */
+#include "utils/mcxt.h" /* for EnableMemoryContext, etc. */
+#include "utils/elog.h"
+#include "utils/builtins.h"
+
+#include "miscadmin.h" /* where the declarations go */
+
+#include "catalog/catname.h"
+#include "catalog/pg_user.h"
+#include "catalog/pg_proc.h"
+#include "utils/syscache.h"
+
+#include "storage/fd.h" /* for O_ */
+
+/*
+ * EnableAbortEnvVarName --
+ * Enables system abort iff set to a non-empty string in environment.
+ */
+#define EnableAbortEnvVarName "POSTGRESABORT"
+
+extern char *getenv(const char *name); /* XXX STDLIB */
+
+/* from globals.c */
+extern char *DatabaseName;
+extern char *UserName;
+extern char *DatabasePath;
+
+
+/*
+ * Define USE_ENVIRONMENT to get PGDATA, etc. from environment variables.
+ * This is the default on UNIX platforms.
+ */
+#ifndef WIN32
+#define USE_ENVIRONMENT
+#endif
+
+/* ----------------------------------------------------------------
+ * some of the 19 ways to leave postgres
+ * ----------------------------------------------------------------
+ */
+
+/*
+ * ExitPostgres --
+ * Exit POSTGRES with a status code.
+ *
+ * Note:
+ * This function never returns.
+ * ...
+ *
+ * Side effects:
+ * ...
+ *
+ * Exceptions:
+ * none
+ */
+void
+ExitPostgres(ExitStatus status)
+{
+#ifdef __SABER__
+ saber_stop();
+#endif
+ exitpg(status);
+}
+
+/*
+ * AbortPostgres --
+ * Abort POSTGRES dumping core.
+ *
+ * Note:
+ * This function never returns.
+ * ...
+ *
+ * Side effects:
+ * Core is dumped iff EnableAbortEnvVarName is set to a non-empty string.
+ * ...
+ *
+ * Exceptions:
+ * none
+ */
+void
+AbortPostgres()
+{
+ char *abortValue = getenv(EnableAbortEnvVarName);
+
+#ifdef __SABER__
+ saber_stop();
+#endif
+
+ if (PointerIsValid(abortValue) && abortValue[0] != '\0')
+ abort();
+ else
+ exitpg(FatalExitStatus);
+}
+
+/* ----------------
+ * StatusBackendExit
+ * ----------------
+ */
+void
+StatusBackendExit(int status)
+{
+ /* someday, do some real cleanup and then call the LISP exit */
+ /* someday, call StatusPostmasterExit if running without postmaster */
+ exitpg(status);
+}
+
+/* ----------------
+ * StatusPostmasterExit
+ * ----------------
+ */
+void
+StatusPostmasterExit(int status)
+{
+ /* someday, do some real cleanup and then call the LISP exit */
+ exitpg(status);
+}
+
+/* ----------------------------------------------------------------
+ * processing mode support stuff (used to be in pmod.c)
+ * ----------------------------------------------------------------
+ */
+static ProcessingMode Mode = NoProcessing;
+
+/*
+ * IsNoProcessingMode --
+ * True iff processing mode is NoProcessing.
+ */
+bool
+IsNoProcessingMode()
+{
+ return ((bool)(Mode == NoProcessing));
+}
+
+/*
+ * IsBootstrapProcessingMode --
+ * True iff processing mode is BootstrapProcessing.
+ */
+bool
+IsBootstrapProcessingMode()
+{
+ return ((bool)(Mode == BootstrapProcessing));
+}
+
+/*
+ * IsInitProcessingMode --
+ * True iff processing mode is InitProcessing.
+ */
+bool
+IsInitProcessingMode()
+{
+ return ((bool)(Mode == InitProcessing));
+}
+
+/*
+ * IsNormalProcessingMode --
+ * True iff processing mode is NormalProcessing.
+ */
+bool
+IsNormalProcessingMode()
+{
+ return ((bool)(Mode == NormalProcessing));
+}
+
+/*
+ * SetProcessingMode --
+ * Sets mode of processing as specified.
+ *
+ * Exceptions:
+ * BadArg if called with invalid mode.
+ *
+ * Note:
+ * Mode is NoProcessing before the first time this is called.
+ */
+void
+SetProcessingMode(ProcessingMode mode)
+{
+ AssertArg(mode == NoProcessing || mode == BootstrapProcessing ||
+ mode == InitProcessing || mode == NormalProcessing);
+
+ Mode = mode;
+}
+
+ProcessingMode
+GetProcessingMode()
+{
+ return (Mode);
+}
+
+/* ----------------------------------------------------------------
+ * database path / name support stuff
+ * ----------------------------------------------------------------
+ */
+
+/*
+ * GetDatabasePath --
+ * Returns path to database.
+ *
+ */
+char*
+GetDatabasePath()
+{
+ return DatabasePath;
+}
+
+/*
+ * GetDatabaseName --
+ * Returns name of database.
+ */
+char*
+GetDatabaseName()
+{
+ return DatabaseName;
+}
+
+void
+SetDatabasePath(char *path)
+{
+ /* use malloc since this is done before memory contexts are set up */
+ if (DatabasePath)
+ free(DatabasePath);
+ DatabasePath = malloc(strlen(path)+1);
+ strcpy(DatabasePath, path);
+}
+
+void
+SetDatabaseName(char *name)
+{
+ if (DatabaseName)
+ free (DatabaseName);
+ DatabaseName = malloc(strlen(name)+1);
+ strcpy(DatabaseName, name);
+}
+
+/* ----------------
+ * GetPgUserName and SetPgUserName
+ *
+ * SetPgUserName must be called before InitPostgres, since the setuid()
+ * is done there.
+ * ----------------
+ */
+char*
+GetPgUserName()
+{
+ return UserName;
+}
+
+void
+SetPgUserName()
+{
+#ifndef NO_SECURITY
+ char *p;
+ struct passwd *pw;
+
+ if (IsUnderPostmaster) {
+ /* use the (possibly) authenticated name that's provided */
+ if (!(p = getenv("PG_USER")))
+ elog(FATAL, "SetPgUserName: PG_USER environment variable unset");
+ } else {
+ /* setuid() has not yet been done, see above comment */
+ if (!(pw = getpwuid(geteuid())))
+ elog(FATAL, "SetPgUserName: no entry in passwd file");
+ p = pw->pw_name;
+ }
+ if (UserName)
+ free(UserName);
+ UserName = malloc(strlen(p)+1);
+ strcpy(UserName, p);
+#endif /* NO_SECURITY */
+
+#ifdef WIN32
+ /* XXX We'll figure out how to get the user name later */
+ if (UserName)
+ free(UserName);
+ UserName = malloc(strlen(p)+1);
+ strcpy(UserName, "postgres");
+#endif /* WIN32 */
+
+}
+
+/* ----------------------------------------------------------------
+ * GetUserId and SetUserId
+ * ----------------------------------------------------------------
+ */
+static Oid UserId = InvalidOid;
+
+Oid
+GetUserId()
+{
+ Assert(OidIsValid(UserId));
+ return(UserId);
+}
+
+void
+SetUserId()
+{
+ HeapTuple userTup;
+ char *userName;
+
+ Assert(!OidIsValid(UserId)); /* only once */
+
+ /*
+ * Don't do scans if we're bootstrapping, none of the system
+ * catalogs exist yet, and they should be owned by postgres
+ * anyway.
+ */
+ if (IsBootstrapProcessingMode()) {
+ UserId = geteuid();
+ return;
+ }
+
+ userName = GetPgUserName();
+ userTup = SearchSysCacheTuple(USENAME, PointerGetDatum(userName),
+ 0,0,0);
+ if (!HeapTupleIsValid(userTup))
+ elog(FATAL, "SetUserId: user \"%s\" is not in \"%s\"",
+ userName,
+ UserRelationName);
+ UserId = (Oid) ((Form_pg_user) GETSTRUCT(userTup))->usesysid;
+}
+
+/* ----------------
+ * GetPGHome
+ *
+ * Get POSTGRESHOME from environment, or return default.
+ * ----------------
+ */
+char *
+GetPGHome()
+{
+#ifdef USE_ENVIRONMENT
+ char *h;
+
+ if ((h = getenv("POSTGRESHOME")) != (char *) NULL)
+ return (h);
+#endif /* USE_ENVIRONMENT */
+ return (POSTGRESDIR);
+
+}
+
+char *
+GetPGData()
+{
+#ifdef USE_ENVIRONMENT
+ char *p;
+
+ if ((p = getenv("PGDATA")) != (char *) NULL) {
+ return (p);
+ }
+#endif /* USE_ENVIRONMENT */
+ return (PGDATADIR);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * postinit.c--
+ * postgres initialization utilities
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/init/postinit.c,v 1.1.1.1 1996/07/09 06:22:09 scrappy Exp $
+ *
+ * NOTES
+ * InitPostgres() is the function called from PostgresMain
+ * which does all non-trival initialization, mainly by calling
+ * all the other initialization functions. InitPostgres()
+ * is only used within the "postgres" backend and so that routine
+ * is in tcop/postgres.c InitPostgres() is needed in cinterface.a
+ * because things like the bootstrap backend program need it. Hence
+ * you find that in this file...
+ *
+ * If you feel the need to add more initialization code, it should be
+ * done in InitPostgres() or someplace lower. Do not start
+ * putting stuff in PostgresMain - if you do then someone
+ * will have to clean it up later, and it's not going to be me!
+ * -cim 10/3/90
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "postgres.h"
+
+#include "machine.h" /* for BLCKSZ, for InitMyDatabaseId()
+ * and where the decarations for this file go
+ */
+#include "access/heapam.h"
+#include "access/xact.h"
+#include "storage/bufmgr.h"
+#include "access/transam.h" /* XXX dependency problem */
+#include "utils/tqual.h"
+#include "utils/syscache.h"
+#include "storage/bufpage.h" /* for page layout, for InitMyDatabaseId() */
+#include "storage/sinval.h"
+#include "storage/sinvaladt.h"
+#include "storage/lmgr.h"
+
+#include "miscadmin.h" /* for global decls */
+#include "utils/portal.h" /* for EnablePortalManager, etc. */
+
+#include "utils/exc.h" /* for EnableExceptionHandling, etc. */
+#include "fmgr.h" /* for EnableDynamicFunctionManager, etc. */
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/mcxt.h" /* for EnableMemoryContext, etc. */
+
+#include "catalog/catname.h"
+#include "catalog/pg_database.h"
+
+#include "port-protos.h"
+#include "libpq/libpq-be.h"
+
+
+static IPCKey PostgresIpcKey;
+
+
+#ifndef private
+#ifndef EBUG
+#define private static
+#else /* !defined(EBUG) */
+#define private
+#endif /* !defined(EBUG) */
+#endif /* !defined(private) */
+
+/* ----------------------------------------------------------------
+ * InitPostgres support
+ * ----------------------------------------------------------------
+ */
+
+/* --------------------------------
+ * InitMyDatabaseId() -- Find and record the OID of the database we are
+ * to open.
+ *
+ * The database's oid forms half of the unique key for the system
+ * caches and lock tables. We therefore want it initialized before
+ * we open any relations, since opening relations puts things in the
+ * cache. To get around this problem, this code opens and scans the
+ * pg_database relation by hand.
+ *
+ * This algorithm relies on the fact that first attribute in the
+ * pg_database relation schema is the database name. It also knows
+ * about the internal format of tuples on disk and the length of
+ * the datname attribute. It knows the location of the pg_database
+ * file.
+ *
+ * This code is called from InitDatabase(), after we chdir() to the
+ * database directory but before we open any relations.
+ * --------------------------------
+ */
+void
+InitMyDatabaseId()
+{
+ int dbfd;
+ int fileflags;
+ int nbytes;
+ int max, i;
+ HeapTuple tup;
+ Page pg;
+ PageHeader ph;
+ char *dbfname;
+ Form_pg_database tup_db;
+
+ /*
+ * At bootstrap time, we don't need to check the oid of the database
+ * in use, since we're not using shared memory. This is lucky, since
+ * the database may not be in the tables yet.
+ */
+
+ if (IsBootstrapProcessingMode()) {
+ LockDisable(true);
+ return;
+ }
+
+ dbfname = (char *) palloc(strlen(DataDir) + strlen("pg_database") + 2);
+ sprintf(dbfname, "%s%cpg_database", DataDir, SEP_CHAR);
+ fileflags = O_RDONLY;
+#ifdef WIN32
+ fileflags |= _O_BINARY;
+#endif /* WIN32 */
+
+ if ((dbfd = open(dbfname, O_RDONLY, 0666)) < 0)
+ elog(FATAL, "Cannot open %s", dbfname);
+
+ pfree(dbfname);
+
+ /* ----------------
+ * read and examine every page in pg_database
+ *
+ * Raw I/O! Read those tuples the hard way! Yow!
+ *
+ * Why don't we use the access methods or move this code
+ * someplace else? This is really pg_database schema dependent
+ * code. Perhaps it should go in lib/catalog/pg_database?
+ * -cim 10/3/90
+ *
+ * mao replies 4 apr 91: yeah, maybe this should be moved to
+ * lib/catalog. however, we CANNOT use the access methods since
+ * those use the buffer cache, which uses the relation cache, which
+ * requires that the dbid be set, which is what we're trying to do
+ * here.
+ * ----------------
+ */
+ pg = (Page) palloc(BLCKSZ);
+ ph = (PageHeader) pg;
+
+ while ((nbytes = read(dbfd, pg, BLCKSZ)) == BLCKSZ) {
+ max = PageGetMaxOffsetNumber(pg);
+
+ /* look at each tuple on the page */
+ for (i = 0; i <= max; i++) {
+ int offset;
+
+ /* if it's a freed tuple, ignore it */
+ if (!(ph->pd_linp[i].lp_flags & LP_USED))
+ continue;
+
+ /* get a pointer to the tuple itself */
+ offset = (int) ph->pd_linp[i].lp_off;
+ tup = (HeapTuple) (((char *) pg) + offset);
+
+ /*
+ * if the tuple has been deleted (the database was destroyed),
+ * skip this tuple. XXX warning, will robinson: violation of
+ * transaction semantics happens right here. we should check
+ * to be sure that the xact that deleted this tuple actually
+ * committed. only way to do this at init time is to paw over
+ * the log relation by hand, too. let's be optimistic.
+ *
+ * XXX This is an evil type cast. tup->t_xmax is char[5] while
+ * TransactionId is struct * { char data[5] }. It works but
+ * if data is ever moved and no longer the first field this
+ * will be broken!! -mer 11 Nov 1991.
+ */
+ if (TransactionIdIsValid((TransactionId)tup->t_xmax))
+ continue;
+
+ /*
+ * Okay, see if this is the one we want.
+ * XXX 1 july 91: mao and mer discover that tuples now squash
+ * t_bits. Why is this?
+ *
+ * 24 july 92: mer realizes that the t_bits field is only
+ * used in the event of null values. If no
+ * fields are null we reduce the header size
+ * by doing the squash. t_hoff tells you exactly
+ * how big the header actually is. use the PC
+ * means of getting at sys cat attrs.
+ */
+ tup_db = (Form_pg_database)GETSTRUCT(tup);
+
+ if (strncmp(GetDatabaseName(),
+ &(tup_db->datname.data[0]),
+ 16) == 0)
+ {
+ MyDatabaseId = tup->t_oid;
+ goto done;
+ }
+ }
+ }
+
+ done:
+ (void) close(dbfd);
+ pfree(pg);
+
+ if (!OidIsValid(MyDatabaseId))
+ elog(FATAL,
+ "Database %s does not exist in %s",
+ GetDatabaseName(),
+ DatabaseRelationName);
+}
+
+/*
+ * DoChdirAndInitDatabaseNameAndPath --
+ * Sets current directory appropriately for given path and name.
+ *
+ * Arguments:
+ * Path and name are invalid if it invalid as a string.
+ * Path is "badly formated" if it is not a string containing a path
+ * to a writable directory.
+ * Name is "badly formated" if it contains more than 16 characters or if
+ * it is a bad file name (e.g., it contains a '/' or an 8-bit character).
+ *
+ * Side effects:
+ * Initially, DatabasePath and DatabaseName are invalid. They are
+ * set to valid strings before this function returns.
+ *
+ * Exceptions:
+ * BadState if called more than once.
+ * BadArg if both path and name are "badly formated" or invalid.
+ * BadArg if path and name are both "inconsistent" and valid.
+ */
+/* ----------------
+ * DoChdirAndInitDatabaseNameAndPath
+ *
+ * this just chdir's to the proper data/base directory
+ * XXX clean this up more.
+ *
+ * XXX The following code is an incorrect of the semantics
+ * XXX described in the header file. Handling of defaults
+ * XXX should happen here, too.
+ * ----------------
+ */
+void
+DoChdirAndInitDatabaseNameAndPath(char *name, /* name of database */
+ char *path) /* full path to database */
+{
+ /* ----------------
+ * check the path
+ * ----------------
+ */
+ if (path)
+ SetDatabasePath(path);
+ else
+ elog(FATAL, "DoChdirAndInitDatabaseNameAndPath: path:%s is not valid",
+ path);
+
+ /* ----------------
+ * check the name
+ * ----------------
+ */
+ if (name)
+ SetDatabaseName(name);
+ else
+ elog(FATAL, "DoChdirAndInitDatabaseNameAndPath: name:%s is not valid",
+ name);
+
+ /* ----------------
+ * change to the directory, or die trying.
+ *
+ * XXX unless the path hasn't been set because we're bootstrapping.
+ * HP-UX doesn't like chdir("") so check for that case before
+ * doing anything drastic.
+ * ----------------
+ */
+ if (*path && (chdir(path) < 0))
+ elog(FATAL, "DoChdirAndInitDatabaseNameAndPath: chdir(\"%s\"): %m",
+ path);
+}
+
+/* --------------------------------
+ * InitUserid
+ *
+ * initializes crap associated with the user id.
+ * --------------------------------
+ */
+void
+InitUserid()
+{
+ setuid(geteuid());
+ SetUserId();
+}
+
+/* --------------------------------
+ * InitCommunication
+ *
+ * This routine initializes stuff needed for ipc, locking, etc.
+ * it should be called something more informative.
+ *
+ * Note:
+ * This does not set MyBackendId. MyBackendTag is set, however.
+ * --------------------------------
+ */
+void
+InitCommunication()
+{
+ char *getenv(); /* XXX style */
+ char *postid;
+ char *postport;
+ IPCKey key;
+
+ /* ----------------
+ * try and get the backend tag from POSTID
+ * ----------------
+ */
+ MyBackendId = -1;
+
+ postid = getenv("POSTID");
+ if (!PointerIsValid(postid)) {
+ MyBackendTag = -1;
+ } else {
+ MyBackendTag = atoi(postid);
+ Assert(MyBackendTag >= 0);
+ }
+
+ /* ----------------
+ * try and get the ipc key from POSTPORT
+ * ----------------
+ */
+ postport = getenv("POSTPORT");
+
+ if (PointerIsValid(postport)) {
+ SystemPortAddress address = atoi(postport);
+
+ if (address == 0)
+ elog(FATAL, "InitCommunication: invalid POSTPORT");
+
+ if (MyBackendTag == -1)
+ elog(FATAL, "InitCommunication: missing POSTID");
+
+ key = SystemPortAddressCreateIPCKey(address);
+
+ /*
+ * Enable this if you are trying to force the backend to run as if it
+ * is running under the postmaster.
+ *
+ * This goto forces Postgres to attach to shared memory instead of
+ * using malloc'ed memory (which is the normal behavior if run
+ * directly).
+ *
+ * To enable emulation, run the following shell commands (in addition
+ * to enabling this goto)
+ *
+ * % setenv POSTID 1
+ * % setenv POSTPORT 4321
+ * % postmaster &
+ * % kill -9 %1
+ *
+ * Upon doing this, Postmaster will have allocated the shared memory
+ * resources that Postgres will attach to if you enable
+ * EMULATE_UNDER_POSTMASTER.
+ *
+ * This comment may well age with time - it is current as of
+ * 8 January 1990
+ *
+ * Greg
+ */
+
+#ifdef EMULATE_UNDER_POSTMASTER
+
+ goto forcesharedmemory;
+
+#endif
+
+ } else if (IsUnderPostmaster) {
+ elog(FATAL,
+ "InitCommunication: under postmaster and POSTPORT not set");
+ } else {
+ /* ----------------
+ * assume we're running a postgres backend by itself with
+ * no front end or postmaster.
+ * ----------------
+ */
+ if (MyBackendTag == -1) {
+ MyBackendTag = 1;
+ }
+
+ key = PrivateIPCKey;
+ }
+
+ /* ----------------
+ * initialize shared memory and semaphores appropriately.
+ * ----------------
+ */
+#ifdef EMULATE_UNDER_POSTMASTER
+
+ forcesharedmemory:
+
+#endif
+
+ PostgresIpcKey = key;
+ AttachSharedMemoryAndSemaphores(key);
+}
+
+
+/* --------------------------------
+ * InitStdio
+ *
+ * this routine consists of a bunch of code fragments
+ * that used to be randomly scattered through cinit().
+ * they all seem to do stuff associated with io.
+ * --------------------------------
+ */
+void
+InitStdio()
+{
+ (void) DebugFileOpen();
+}
+
+/* --------------------------------
+ * InitPostgres --
+ * Initialize POSTGRES.
+ *
+ * Note:
+ * Be very careful with the order of calls in the InitPostgres function.
+ * --------------------------------
+ */
+bool PostgresIsInitialized = false;
+extern int NBuffers;
+
+/*
+ * this global is used by wei for testing his code, but must be declared
+ * here rather than in postgres.c so that it's defined for cinterface.a
+ * applications.
+ */
+
+/*int testFlag = 0;*/
+int lockingOff = 0;
+
+/*
+ */
+void
+InitPostgres(char *name) /* database name */
+{
+ bool bootstrap; /* true if BootstrapProcessing */
+
+ /* ----------------
+ * see if we're running in BootstrapProcessing mode
+ * ----------------
+ */
+ bootstrap = IsBootstrapProcessingMode();
+
+ /* ----------------
+ * turn on the exception handler. Note: we cannot use elog, Assert,
+ * AssertState, etc. until after exception handling is on.
+ * ----------------
+ */
+ EnableExceptionHandling(true);
+
+ /* ----------------
+ * A stupid check to make sure we don't call this more than once.
+ * But things like ReinitPostgres() get around this by just diddling
+ * the PostgresIsInitialized flag.
+ * ----------------
+ */
+ AssertState(!PostgresIsInitialized);
+
+ /* ----------------
+ * Memory system initialization.
+ * (we may call palloc after EnableMemoryContext())
+ *
+ * Note EnableMemoryContext() must happen before EnablePortalManager().
+ * ----------------
+ */
+ EnableMemoryContext(true); /* initializes the "top context" */
+ EnablePortalManager(true); /* memory for portal/transaction stuff */
+
+ /* ----------------
+ * initialize the backend local portal stack used by
+ * internal PQ function calls. see src/lib/libpq/be-dumpdata.c
+ * This is different from the "portal manager" so this goes here.
+ * -cim 2/12/91
+ * ----------------
+ */
+ be_portalinit();
+
+ /* ----------------
+ * attach to shared memory and semaphores, and initialize our
+ * input/output/debugging file descriptors.
+ * ----------------
+ */
+ InitCommunication();
+ InitStdio();
+
+ /*
+ * initialize the local buffer manager
+ */
+ InitLocalBuffer();
+
+ if (!TransactionFlushEnabled())
+ on_exitpg(FlushBufferPool, (caddr_t) NULL);
+
+ /* ----------------
+ * check for valid "meta gunk" (??? -cim 10/5/90) and change to
+ * database directory.
+ *
+ * Note: DatabaseName, MyDatabaseName, and DatabasePath are all
+ * initialized with DatabaseMetaGunkIsConsistent(), strncpy() and
+ * DoChdirAndInitDatabase() below! XXX clean this crap up!
+ * -cim 10/5/90
+ * ----------------
+ */
+ {
+ char myPath[MAXPGPATH] = "."; /* DatabasePath points here! */
+
+ /* ----------------
+ * DatabaseMetaGunkIsConsistent fills in myPath, but what about
+ * when bootstrap or Noversion is true?? -cim 10/5/90
+ * ----------------
+ */
+
+ if (! bootstrap &&
+ ! DatabaseMetaGunkIsConsistent(name, myPath) &&
+ ! Noversion) {
+ elog(NOTICE, "InitPostgres: could not locate valid PG_VERSION\n");
+ elog(NOTICE, "files for %s and %s.", DataDir, name);
+ elog(FATAL, "Have you run initdb/createdb and set PGDATA properly?");
+ }
+
+ /* ----------------
+ * ok, we've figured out myName and myPath, now save these
+ * and chdir to myPath.
+ * ----------------
+ */
+ DoChdirAndInitDatabaseNameAndPath(name, myPath);
+ }
+
+ /* ********************************
+ * code after this point assumes we are in the proper directory!
+ * ********************************
+ */
+
+ /* ----------------
+ * initialize the database id used for system caches and lock tables
+ * ----------------
+ */
+ InitMyDatabaseId();
+
+ smgrinit();
+
+ /* ----------------
+ * initialize the transaction system and the relation descriptor
+ * cache. Note we have to make certain the lock manager is off while
+ * we do this.
+ * ----------------
+ */
+ AmiTransactionOverride(IsBootstrapProcessingMode());
+ LockDisable(true);
+
+ /*
+ * Part of the initialization processing done here sets a read
+ * lock on pg_log. Since locking is disabled the set doesn't have
+ * intended effect of locking out writers, but this is ok, since
+ * we only lock it to examine AMI transaction status, and this is
+ * never written after initdb is done. -mer 15 June 1992
+ */
+ RelationInitialize(); /* pre-allocated reldescs created here */
+ InitializeTransactionSystem(); /* pg_log,etc init/crash recovery here */
+
+ LockDisable(false);
+
+ /* ----------------
+ * anyone knows what this does? something having to do with
+ * system catalog cache invalidation in the case of multiple
+ * backends, I think -cim 10/3/90
+ * Sets up MyBackendId a unique backend identifier.
+ * ----------------
+ */
+ InitSharedInvalidationState();
+
+ /* ----------------
+ * Set up a per backend process in shared memory. Must be done after
+ * InitSharedInvalidationState() as it relies on MyBackendId being
+ * initialized already. XXX -mer 11 Aug 1991
+ * ----------------
+ */
+ InitProcess(PostgresIpcKey);
+
+ if (MyBackendId > MaxBackendId || MyBackendId <= 0) {
+ elog(FATAL, "cinit2: bad backend id %d (%d)",
+ MyBackendTag,
+ MyBackendId);
+ }
+
+ /* ----------------
+ * initialize the access methods.
+ * ----------------
+ */
+ initam();
+
+ /* ----------------
+ * initialize all the system catalog caches.
+ * ----------------
+ */
+ zerocaches();
+ InitCatalogCache();
+
+ /* ----------------
+ * set ourselves to the proper user id and figure out our postgres
+ * user id. If we ever add security so that we check for valid
+ * postgres users, we might do it here.
+ * ----------------
+ */
+ InitUserid();
+
+ /* ----------------
+ * ok, all done, now let's make sure we don't do it again.
+ * ----------------
+ */
+ PostgresIsInitialized = true;
+/* on_exitpg(DestroyLocalRelList, (caddr_t) NULL); */
+
+ /* ----------------
+ * Done with "InitPostgres", now change to NormalProcessing unless
+ * we're in BootstrapProcessing mode.
+ * ----------------
+ */
+ if (!bootstrap)
+ SetProcessingMode(NormalProcessing);
+/* if (testFlag || lockingOff) */
+ if (lockingOff)
+ LockDisable(true);
+}
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * inval.h--
+ * POSTGRES cache invalidation dispatcher definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: inval.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef INVAL_H
+#define INVAL_H
+
+#include "postgres.h"
+#include "access/htup.h"
+#include "utils/rel.h"
+
+extern void DiscardInvalid(void);
+
+extern void RegisterInvalid(bool send);
+
+extern void SetRefreshWhenInvalidate(bool on);
+
+extern void RelationInvalidateHeapTuple(Relation relation, HeapTuple tuple);
+
+/*
+ * POSTGRES local cache invalidation definitions. (originates from linval.h)
+ */
+typedef struct InvalidationUserData {
+ struct InvalidationUserData *dataP[1]; /* VARIABLE LENGTH */
+} InvalidationUserData; /* VARIABLE LENGTH STRUCTURE */
+
+typedef struct InvalidationEntryData {
+ InvalidationUserData *nextP;
+ InvalidationUserData userData; /* VARIABLE LENGTH ARRAY */
+} InvalidationEntryData; /* VARIABLE LENGTH STRUCTURE */
+
+typedef Pointer InvalidationEntry;
+
+typedef InvalidationEntry LocalInvalid;
+
+#define EmptyLocalInvalid NULL
+
+extern InvalidationEntry InvalidationEntryAllocate(uint16 size);
+
+extern LocalInvalid LocalInvalidRegister(LocalInvalid invalid,
+ InvalidationEntry entry);
+
+extern void LocalInvalidInvalidate(LocalInvalid invalid, void (*function)());
+
+extern void getmyrelids(void);
+
+#endif /* INVAL_H */
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * lselect.h--
+ * definitions for the replacement selection algorithm.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: lselect.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef LSELECT_H
+#define LSELECT_H
+
+#include "c.h"
+#include "access/htup.h"
+
+struct leftist {
+ short lt_dist; /* distance to leaf/empty node */
+ short lt_devnum; /* device number of tuple */
+ HeapTuple lt_tuple;
+ struct leftist *lt_left;
+ struct leftist *lt_right;
+};
+
+extern struct leftist *Tuples;
+
+extern struct leftist *lmerge(struct leftist *pt, struct leftist *qt);
+extern HeapTuple gettuple(struct leftist **treep, short *devnum);
+extern int puttuple(struct leftist **treep, HeapTuple newtuple, int devnum);
+extern void dumptuples(FILE *file);
+extern int tuplecmp(HeapTuple ltup, HeapTuple rtup);
+
+#ifdef EBUG
+extern void checktree(struct leftist *tree);
+extern int checktreer(struct leftist *tree, int level);
+#endif /* EBUG */
+
+#endif /* LSELECT_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * lsyscache.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: lsyscache.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef LSYSCACHE_H
+#define LSYSCACHE_H
+
+#include "access/htup.h"
+
+extern bool op_class(Oid opid, int32 opclass, Oid amopid);
+extern char *get_attname(Oid relid, AttrNumber attnum);
+extern AttrNumber get_attnum(Oid relid, char *attname);
+extern Oid get_atttype(Oid relid, AttrNumber attnum);
+extern bool get_attisset(Oid relid, char *attname);
+extern RegProcedure get_opcode(Oid opid);
+extern char *get_opname(Oid opid);
+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);
+extern HeapTuple get_operator_tuple(Oid opno);
+extern Oid get_negator(Oid opid);
+extern RegProcedure get_oprrest(Oid opid);
+extern RegProcedure get_oprjoin(Oid opid);
+extern int get_relnatts(Oid relid);
+extern char *get_rel_name(Oid relid);
+extern struct varlena * get_relstub(Oid relid, int no, bool *islast);
+extern Oid get_ruleid(char *rulename);
+extern Oid get_eventrelid(Oid ruleid);
+extern int16 get_typlen(Oid typid);
+extern char get_typalign(Oid typid);
+extern bool get_typbyval(Oid typid);
+extern struct varlena *get_typdefault(Oid typid);
+extern char get_typtype(Oid typid);
+
+#endif /* LSYSCACHE_H */
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * mcxt.h--
+ * POSTGRES memory context definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: mcxt.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MCXT_H
+#define MCXT_H
+
+#include "c.h"
+
+#include "nodes/memnodes.h"
+#include "nodes/nodes.h"
+
+extern MemoryContext CurrentMemoryContext;
+extern MemoryContext TopMemoryContext;
+
+
+/*
+ * MaxAllocSize --
+ * Arbitrary limit on size of allocations.
+ *
+ * Note:
+ * There is no guarantee that allocations smaller than MaxAllocSize
+ * will succeed. Allocation requests larger than MaxAllocSize will
+ * be summarily denied.
+ *
+ * This value should not be referenced except in one place in the code.
+ *
+ * XXX This should be defined in a file of tunable constants.
+ */
+#define MaxAllocSize (0xfffffff) /* 16G - 1 */
+
+/*
+ * prototypes for functions in mcxt.c
+ */
+extern void EnableMemoryContext(bool on);
+extern Pointer MemoryContextAlloc(MemoryContext context, Size size);
+extern Pointer MemoryContextRealloc(MemoryContext context,
+ Pointer pointer,
+ Size size);
+extern void MemoryContextFree(MemoryContext context, Pointer pointer);
+extern char *MemoryContextGetName(MemoryContext context);
+extern Size PointerGetAllocSize(Pointer pointer);
+extern MemoryContext MemoryContextSwitchTo(MemoryContext context);
+extern GlobalMemory CreateGlobalMemory(char *name);
+extern void GlobalMemoryDestroy(GlobalMemory context);
+
+
+#endif /* MCXT_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * memutils.h--
+ * this file contains general memory alignment, allocation
+ * and manipulation stuff that used to be spread out
+ * between the following files:
+ *
+ * align.h alignment macros
+ * aset.h memory allocation set stuff
+ * oset.h (used by aset.h)
+ * (bit.h bit array type / extern)
+ * clib.h mem routines
+ * limit.h max bits/byte, etc.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: memutils.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ * NOTES
+ * some of the information in this file will be moved to
+ * other files, (like MaxHeapTupleSize and MaxAttributeSize).
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MEMUTILS_H
+#define MEMUTILS_H
+
+#include "c.h"
+
+#if 0
+/*****************************************************************************
+ * align.h - alignment macros *
+ ****************************************************************************
+ [TRH] Let the compiler decide what alignment it uses instead of
+tending
+ we know better.
+ GCC (at least v2.5.8 and up) has an __alignof__ keyword.
+ However, we cannot use it here since on some architectures it reports
+ just a _recommended_ alignment instead of the actual alignment used in
+ padding structures (or at least, this is how I understand gcc's
+s...)
+ So define a macro that gives us the _actual_ alignment inside a struct.
+ {{note: assumes that alignment size is always a power of 2.}}
+ */
+#define _ALIGNSIZE(TYPE) offsetof(struct { char __c; TYPE __t;}, __t)
+#define _ALIGN(TYPE, LEN) \
+ (((long)(LEN) + (_ALIGNSIZE(TYPE) - 1)) & ~(_ALIGNSIZE(TYPE) - 1))
+#define SHORTALIGN(LEN) _ALIGN(short, (LEN))
+#define INTALIGN(LEN) _ALIGN(int, (LEN))
+#define LONGALIGN(LEN) _ALIGN(long, (LEN))
+#define DOUBLEALIGN(LEN) _ALIGN(double, (LEN))
+#define MAXALIGN(LEN) _ALIGN(double, (LEN))
+
+#endif /* 0 */
+
+/*
+ * SHORTALIGN(LEN) - length (or address) aligned for shorts
+ */
+#define SHORTALIGN(LEN)\
+ (((long)(LEN) + (sizeof (short) - 1)) & ~(sizeof (short) - 1))
+
+#define INTALIGN(LEN)\
+ (((long)(LEN) + (sizeof (int) - 1)) & ~(sizeof (int) -1))
+
+/*
+ * LONGALIGN(LEN) - length (or address) aligned for longs
+ */
+#if defined(sun) && ! defined(sparc)
+#define LONGALIGN(LEN) SHORTALIGN(LEN)
+#elif defined (PORTNAME_alpha)
+#define LONGALIGN(LEN)\
+ (((long)(LEN) + (sizeof (int) - 1)) & ~(sizeof (int) -1))
+#else
+#define LONGALIGN(LEN)\
+ (((long)(LEN) + (sizeof (long) - 1)) & ~(sizeof (long) -1))
+#endif
+
+#define DOUBLEALIGN(LEN)\
+ (((long)(LEN) + (sizeof (double) - 1)) & ~(sizeof (double) -1))
+
+#define MAXALIGN(LEN)\
+ (((long)(LEN) + (sizeof (double) - 1)) & ~(sizeof (double) -1))
+
+/*****************************************************************************
+ * bit.h *
+ *****************************************************************************/
+#include "utils/bit.h"
+
+/*****************************************************************************
+ * oset.h -- Fixed format ordered set definitions. *
+ *****************************************************************************/
+/* Note:
+ * Fixed format ordered sets are .
+ * XXX This is a preliminary version. Work is needed to explain
+ * XXX semantics of the external definitions. Otherwise, the
+ * XXX functional interface should not change.
+ *
+ * Identification:
+ * $Header: /cvsroot/pgsql/src/backend/utils/Attic/memutils.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ */
+
+typedef struct OrderedElemData OrderedElemData;
+typedef OrderedElemData* OrderedElem;
+
+typedef struct OrderedSetData OrderedSetData;
+typedef OrderedSetData* OrderedSet;
+
+struct OrderedElemData {
+ OrderedElem next; /* Next elem or &this->set->dummy */
+ OrderedElem prev; /* Previous elem or &this->set->head */
+ OrderedSet set; /* Parent set */
+};
+
+struct OrderedSetData {
+ OrderedElem head; /* First elem or &this->dummy */
+ OrderedElem dummy; /* (hack) Terminator == NULL */
+ OrderedElem tail; /* Last elem or &this->head */
+ Offset offset; /* Offset from struct base to elem */
+ /* this could be signed short int! */
+};
+
+extern void OrderedSetInit(OrderedSet set, Offset offset);
+extern bool OrderedSetContains(OrderedSet set, OrderedElem elem);
+extern Pointer OrderedSetGetHead(OrderedSet set);
+extern Pointer OrderedSetGetTail(OrderedSet set);
+extern Pointer OrderedElemGetPredecessor(OrderedElem elem);
+extern Pointer OrderedElemGetSuccessor(OrderedElem elem);
+extern void OrderedElemPop(OrderedElem elem);
+extern void OrderedElemPushInto(OrderedElem elem, OrderedSet Set);
+
+/*****************************************************************************
+ * aset.h -- Allocation set definitions. *
+ *****************************************************************************/
+/*
+ * Description:
+ * An allocation set is a set containing allocated elements. When
+ * an allocation is requested for a set, memory is allocated and a
+ * pointer is returned. Subsequently, this memory may be freed or
+ * reallocated. In addition, an allocation set may be reset which
+ * will cause all allocated memory to be freed.
+ *
+ * Allocations may occur in four different modes. The mode of
+ * allocation does not affect the behavior of allocations except in
+ * terms of performance. The allocation mode is set at the time of
+ * set initialization. Once the mode is chosen, it cannot be changed
+ * unless the set is reinitialized.
+ *
+ * "Dynamic" mode forces all allocations to occur in a heap. This
+ * is a good mode to use when small memory segments are allocated
+ * and freed very frequently. This is a good choice when allocation
+ * characteristics are unknown. This is the default mode.
+ *
+ * "Static" mode attemts to allocate space as efficiently as possible
+ * without regard to freeing memory. This mode should be chosen only
+ * when it is known that many allocations will occur but that very
+ * little of the allocated memory will be explicitly freed.
+ *
+ * "Tunable" mode is a hybrid of dynamic and static modes. The
+ * tunable mode will use static mode allocation except when the
+ * allocation request exceeds a size limit supplied at the time of set
+ * initialization. "Big" objects are allocated using dynamic mode.
+ *
+ * "Bounded" mode attempts to allocate space efficiently given a limit
+ * on space consumed by the allocation set. This restriction can be
+ * considered a "soft" restriction, because memory segments will
+ * continue to be returned after the limit is exceeded. The limit is
+ * specified at the time of set initialization like for tunable mode.
+ *
+ * Note:
+ * Allocation sets are not automatically reset on a system reset.
+ * Higher level code is responsible for cleaning up.
+ *
+ * There may other modes in the future.
+ */
+
+/*
+ * AllocPointer --
+ * Aligned pointer which may be a member of an allocation set.
+ */
+typedef Pointer AllocPointer;
+
+/*
+ * AllocMode --
+ * Mode of allocation for an allocation set.
+ *
+ * Note:
+ * See above for a description of the various nodes.
+ */
+typedef enum AllocMode {
+ DynamicAllocMode, /* always dynamically allocate */
+ StaticAllocMode, /* always "statically" allocate */
+ TunableAllocMode, /* allocations are "tuned" */
+ BoundedAllocMode /* allocations bounded to fixed usage */
+} AllocMode;
+
+#define DefaultAllocMode DynamicAllocMode
+
+/*
+ * AllocSet --
+ * Allocation set.
+ */
+typedef struct AllocSetData {
+ OrderedSetData setData;
+ /* Note: this will change in the future to support other modes */
+} AllocSetData;
+
+typedef AllocSetData *AllocSet;
+
+/*
+ * AllocPointerIsValid --
+ * True iff pointer is valid allocation pointer.
+ */
+#define AllocPointerIsValid(pointer) PointerIsValid(pointer)
+
+/*
+ * AllocSetIsValid --
+ * True iff set is valid allocation set.
+ */
+#define AllocSetIsValid(set) PointerIsValid(set)
+
+extern void AllocSetInit(AllocSet set, AllocMode mode, Size limit);
+
+extern void AllocSetReset(AllocSet set);
+
+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,
+ Size size);
+
+extern int AllocSetIterate(AllocSet set,
+ void (*function)(AllocPointer pointer));
+
+extern int AllocSetCount(AllocSet set);
+
+extern void AllocPointerDump(AllocPointer pointer);
+extern void AllocSetDump(AllocSet set);
+
+/*****************************************************************************
+ * clib.h -- Standard C library definitions *
+ *****************************************************************************/
+/*
+ * Note:
+ * This file is OPERATING SYSTEM dependent!!!
+ *
+ */
+/* #include */
+/* use because it's ANSI */
+#include
+
+/*
+ * LibCCopyLength is only used within this file. -cim 6/12/90
+ *
+ */
+typedef int LibCCopyLength;
+
+typedef CLibCopyLength;
+
+/*
+ * MemoryCopy --
+ * Copies fixed length block of memory to another.
+ */
+#define MemoryCopy(toBuffer, fromBuffer, length)\
+ memcpy(toBuffer, fromBuffer, length)
+
+/*****************************************************************************
+ * limit.h -- POSTGRES limit definitions. *
+ *****************************************************************************/
+
+#define MaxBitsPerByte 8
+
+typedef uint32 AttributeSize; /* XXX should be defined elsewhere */
+
+#define MaxHeapTupleSize 0x7fffffff
+#define MaxAttributeSize 0x7fffffff
+
+#define MaxIndexAttributeNumber 7
+
+
+#endif /* MEMUTILS_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for utils/mmgr
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/utils/mmgr/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:22:09 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= aset.c mcxt.c palloc.c portalmem.c oset.c
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * aset.c--
+ * Allocation set definitions.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/aset.c,v 1.1.1.1 1996/07/09 06:22:09 scrappy Exp $
+ *
+ * NOTE
+ * XXX This is a preliminary implementation which lacks fail-fast
+ * XXX validity checking of arguments.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "c.h"
+#include "utils/excid.h" /* for ExhaustedMemory */
+#include "utils/memutils.h" /* where funnction declarations go */
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+#undef AllocSetReset
+#undef malloc
+#undef free
+
+/*
+ * Internal type definitions
+ */
+
+/*
+ * AllocElem --
+ * Allocation element.
+ */
+typedef struct AllocElemData {
+ OrderedElemData elemData; /* elem in AllocSet */
+ Size size;
+} AllocElemData;
+
+typedef AllocElemData *AllocElem;
+
+
+/*
+ * Private method definitions
+ */
+
+/*
+ * AllocPointerGetAllocElem --
+ * Returns allocation (internal) elem given (external) pointer.
+ */
+#define AllocPointerGetAllocElem(pointer) (&((AllocElem)(pointer))[-1])
+
+/*
+ * AllocElemGetAllocPointer --
+ * Returns allocation (external) pointer given (internal) elem.
+ */
+#define AllocElemGetAllocPointer(alloc) ((AllocPointer)&(alloc)[1])
+
+/*
+ * AllocElemIsValid --
+ * True iff alloc is valid.
+ */
+#define AllocElemIsValid(alloc) PointerIsValid(alloc)
+
+/* non-export function prototypes */
+static AllocPointer AllocSetGetFirst(AllocSet set);
+static AllocPointer AllocPointerGetNext(AllocPointer pointer);
+
+/*
+ * Public routines
+ */
+
+/*
+ * AllocPointerIsValid(pointer)
+ * AllocSetIsValid(set)
+ *
+ * .. are now macros in aset.h -cim 4/27/91
+ */
+
+/*
+ * AllocSetInit --
+ * Initializes given allocation set.
+ *
+ * Note:
+ * The semantics of the mode are explained above. Limit is ignored
+ * for dynamic and static modes.
+ *
+ * Exceptions:
+ * BadArg if set is invalid pointer.
+ * BadArg if mode is invalid.
+ */
+void
+AllocSetInit(AllocSet set, AllocMode mode, Size limit)
+{
+ AssertArg(PointerIsValid(set));
+ AssertArg((int)DynamicAllocMode <= (int)mode);
+ AssertArg((int)mode <= (int)BoundedAllocMode);
+
+ /*
+ * XXX mode is currently ignored and treated as DynamicAllocMode.
+ * XXX limit is also ignored. This affects this whole file.
+ */
+
+ OrderedSetInit(&set->setData, offsetof(AllocElemData, elemData));
+}
+
+/*
+ * AllocSetReset --
+ * Frees memory which is allocated in the given set.
+ *
+ * Exceptions:
+ * BadArg if set is invalid.
+ */
+void
+AllocSetReset(AllocSet set)
+{
+ AllocPointer pointer;
+
+ AssertArg(AllocSetIsValid(set));
+
+ while (AllocPointerIsValid(pointer = AllocSetGetFirst(set))) {
+ AllocSetFree(set, pointer);
+ }
+}
+
+void
+AllocSetReset_debug(char *file, int line, AllocSet set)
+{
+ AllocPointer pointer;
+
+ AssertArg(AllocSetIsValid(set));
+
+ while (AllocPointerIsValid(pointer = AllocSetGetFirst(set))) {
+ AllocSetFree(set, pointer);
+ }
+}
+
+/*
+ * AllocSetContains --
+ * True iff allocation set contains given allocation element.
+ *
+ * Exceptions:
+ * BadArg if set is invalid.
+ * BadArg if pointer is invalid.
+ */
+bool
+AllocSetContains(AllocSet set, AllocPointer pointer)
+{
+ AssertArg(AllocSetIsValid(set));
+ AssertArg(AllocPointerIsValid(pointer));
+
+ return (OrderedSetContains(&set->setData,
+ &AllocPointerGetAllocElem(pointer)->elemData));
+}
+
+/*
+ * AllocSetAlloc --
+ * Returns pointer to allocated memory of given size; memory is added
+ * to the set.
+ *
+ * Exceptions:
+ * BadArg if set is invalid.
+ * MemoryExhausted if allocation fails.
+ */
+AllocPointer
+AllocSetAlloc(AllocSet set, Size size)
+{
+ AllocElem alloc;
+
+ AssertArg(AllocSetIsValid(set));
+
+ /* allocate */
+ alloc = (AllocElem)malloc(sizeof (*alloc) + size);
+
+ if (!PointerIsValid(alloc)) {
+ elog (FATAL, "palloc failure: memory exhausted");
+ }
+
+ /* add to allocation list */
+ OrderedElemPushInto(&alloc->elemData, &set->setData);
+
+ /* set size */
+ alloc->size = size;
+
+ return (AllocElemGetAllocPointer(alloc));
+}
+
+/*
+ * AllocSetFree --
+ * Frees allocated memory; memory is removed from the set.
+ *
+ * Exceptions:
+ * BadArg if set is invalid.
+ * BadArg if pointer is invalid.
+ * BadArg if pointer is not member of set.
+ */
+void
+AllocSetFree(AllocSet set, AllocPointer pointer)
+{
+ AllocElem alloc;
+
+ /* AssertArg(AllocSetIsValid(set)); */
+ /* AssertArg(AllocPointerIsValid(pointer)); */
+ AssertArg(AllocSetContains(set, pointer));
+
+ alloc = AllocPointerGetAllocElem(pointer);
+
+ /* remove from allocation set */
+ OrderedElemPop(&alloc->elemData);
+
+ /* free storage */
+ free(alloc);
+}
+
+/*
+ * AllocSetRealloc --
+ * Returns new pointer to allocated memory of given size; this memory
+ * is added to the set. Memory associated with given pointer is copied
+ * into the new memory, and the old memory is freed.
+ *
+ * Exceptions:
+ * BadArg if set is invalid.
+ * BadArg if pointer is invalid.
+ * BadArg if pointer is not member of set.
+ * MemoryExhausted if allocation fails.
+ */
+AllocPointer
+AllocSetRealloc(AllocSet set, AllocPointer pointer, Size size)
+{
+ AllocPointer newPointer;
+ AllocElem alloc;
+
+ /* AssertArg(AllocSetIsValid(set)); */
+ /* AssertArg(AllocPointerIsValid(pointer)); */
+ AssertArg(AllocSetContains(set, pointer));
+
+ /*
+ * Calling realloc(3) directly is not be possible (unless we use
+ * our own hacked version of malloc) since we must keep the
+ * allocations in the allocation set.
+ */
+
+ alloc = AllocPointerGetAllocElem(pointer);
+
+ /* allocate new pointer */
+ newPointer = AllocSetAlloc(set, size);
+
+ /* fill new memory */
+ memmove(newPointer, pointer, (alloc->size < size) ? alloc->size : size);
+
+ /* free old pointer */
+ AllocSetFree(set, pointer);
+
+ return (newPointer);
+}
+
+/*
+ * AllocSetIterate --
+ * Returns size of set. Iterates through set elements calling function
+ * (if valid) on each.
+ *
+ * Note:
+ * This was written as an aid to debugging. It is intended for
+ * debugging use only.
+ *
+ * Exceptions:
+ * BadArg if set is invalid.
+ */
+int
+AllocSetIterate(AllocSet set,
+ void (*function)(AllocPointer pointer))
+{
+ int count = 0;
+ AllocPointer pointer;
+
+ AssertArg(AllocSetIsValid(set));
+
+ for (pointer = AllocSetGetFirst(set);
+ AllocPointerIsValid(pointer);
+ pointer = AllocPointerGetNext(pointer)) {
+
+ if (PointerIsValid(function)) {
+ (*function)(pointer);
+ }
+ count += 1;
+ }
+
+ return (count);
+}
+
+int
+AllocSetCount(AllocSet set)
+{
+ int count = 0;
+ AllocPointer pointer;
+
+ AssertArg(AllocSetIsValid(set));
+
+ for (pointer = AllocSetGetFirst(set);
+ AllocPointerIsValid(pointer);
+ pointer = AllocPointerGetNext(pointer)) {
+ count++;
+ }
+ return count;
+}
+
+/*
+ * Private routines
+ */
+
+/*
+ * AllocSetGetFirst --
+ * Returns "first" allocation pointer in a set.
+ *
+ * Note:
+ * Assumes set is valid.
+ */
+static AllocPointer
+AllocSetGetFirst(AllocSet set)
+{
+ AllocElem alloc;
+
+ alloc = (AllocElem)OrderedSetGetHead(&set->setData);
+
+ if (!AllocElemIsValid(alloc)) {
+ return (NULL);
+ }
+
+ return (AllocElemGetAllocPointer(alloc));
+}
+
+/*
+ * AllocPointerGetNext --
+ * Returns "successor" allocation pointer.
+ *
+ * Note:
+ * Assumes pointer is valid.
+ */
+static AllocPointer
+AllocPointerGetNext(AllocPointer pointer)
+{
+ AllocElem alloc;
+
+ alloc = (AllocElem)
+ OrderedElemGetSuccessor(&AllocPointerGetAllocElem(pointer)->elemData);
+
+ if (!AllocElemIsValid(alloc)) {
+ return (NULL);
+ }
+
+ return (AllocElemGetAllocPointer(alloc));
+}
+
+
+/*
+ * Debugging routines
+ */
+
+/*
+ * XXX AllocPointerDump --
+ * Displays allocated pointer.
+ */
+void
+AllocPointerDump(AllocPointer pointer)
+{
+ printf("\t%-10d@ %0#x\n", ((long*)pointer)[-1], pointer); /* XXX */
+}
+
+/*
+ * AllocSetDump --
+ * Displays allocated set.
+ */
+void
+AllocSetDump(AllocSet set)
+{
+ int count;
+ count = AllocSetIterate(set, AllocPointerDump);
+ printf("\ttotal %d allocations\n", count);
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * mcxt.c--
+ * POSTGRES memory context code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/mcxt.c,v 1.1.1.1 1996/07/09 06:22:09 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include /* XXX for printf debugging */
+
+#include "postgres.h"
+
+#include "utils/memutils.h"
+#include "utils/module.h"
+#include "utils/excid.h"
+
+#include "nodes/memnodes.h"
+#include "nodes/nodes.h"
+
+#include "utils/mcxt.h"
+#include "utils/elog.h"
+
+#include "utils/palloc.h"
+
+#undef MemoryContextAlloc
+#undef MemoryContextFree
+#undef malloc
+#undef free
+
+/*
+ * Global State
+ */
+static int MemoryContextEnableCount = 0;
+#define MemoryContextEnabled (MemoryContextEnableCount > 0)
+
+static OrderedSetData ActiveGlobalMemorySetData; /* uninitialized */
+#define ActiveGlobalMemorySet (&ActiveGlobalMemorySetData)
+
+/*
+ * description of allocated memory representation goes here
+ */
+
+#define PSIZE(PTR) (*((int32 *)(PTR) - 1))
+#define PSIZEALL(PTR) (*((int32 *)(PTR) - 1) + sizeof (int32))
+#define PSIZESKIP(PTR) ((char *)((int32 *)(PTR) + 1))
+#define PSIZEFIND(PTR) ((char *)((int32 *)(PTR) - 1))
+#define PSIZESPACE(LEN) ((LEN) + sizeof (int32))
+
+/*
+ * AllocSizeIsValid --
+ * True iff 0 < size and size <= MaxAllocSize.
+ */
+#define AllocSizeIsValid(size) (0 < (size) && (size) <= MaxAllocSize)
+
+/*****************************************************************************
+ * GLOBAL MEMORY *
+ *****************************************************************************/
+
+/*
+ * CurrentMemoryContext --
+ * Memory context for general global allocations.
+ */
+MemoryContext CurrentMemoryContext = NULL;
+
+/*****************************************************************************
+ * PRIVATE DEFINITIONS *
+ *****************************************************************************/
+
+static Pointer GlobalMemoryAlloc(GlobalMemory this, Size size);
+static void GlobalMemoryFree(GlobalMemory this, Pointer pointer);
+static Pointer GlobalMemoryRealloc(GlobalMemory this, Pointer pointer,
+ Size size);
+static char *GlobalMemoryGetName(GlobalMemory this);
+static void GlobalMemoryDump(GlobalMemory this);
+static void DumpGlobalMemories(void);
+
+
+/*
+ * Global Memory Methods
+ */
+
+static struct MemoryContextMethodsData GlobalContextMethodsData = {
+ GlobalMemoryAlloc, /* Pointer (*)(this, uint32) palloc */
+ GlobalMemoryFree, /* void (*)(this, Pointer) pfree */
+ GlobalMemoryRealloc, /* Pointer (*)(this, Pointer) repalloc */
+ GlobalMemoryGetName, /* char* (*)(this) getName */
+ GlobalMemoryDump /* void (*)(this) dump */
+};
+
+/*
+ * Note:
+ * TopGlobalMemory is handled specially because of bootstrapping.
+ */
+/* extern bool EqualGlobalMemory(); */
+
+static struct GlobalMemory TopGlobalMemoryData = {
+ T_GlobalMemory, /* NodeTag tag */
+ &GlobalContextMethodsData, /* ContextMethods method */
+ { { 0 } }, /* uninitialized
+ * OrderedSetData allocSetD
+ */
+ "TopGlobal", /* char* name */
+ { 0 } /* uninitialized OrderedElemData elemD */
+};
+
+/*
+ * TopMemoryContext --
+ * Memory context for general global allocations.
+ *
+ * Note:
+ * Don't use this memory context for random allocations. If you
+ * allocate something here, you are expected to clean it up when
+ * appropriate.
+ */
+MemoryContext TopMemoryContext = (MemoryContext)&TopGlobalMemoryData;
+
+
+
+
+/*
+ * Module State
+ */
+
+/*
+ * EnableMemoryContext --
+ * Enables/disables memory management and global contexts.
+ *
+ * Note:
+ * This must be called before creating contexts or allocating memory.
+ * This must be called before other contexts are created.
+ *
+ * Exceptions:
+ * BadArg if on is invalid.
+ * BadState if on is false when disabled.
+ */
+void
+EnableMemoryContext(bool on)
+{
+ static bool processing = false;
+
+ AssertState(!processing);
+ AssertArg(BoolIsValid(on));
+
+ if (BypassEnable(&MemoryContextEnableCount, on)) {
+ return;
+ }
+
+ processing = true;
+
+ if (on) { /* initialize */
+ /* initialize TopGlobalMemoryData.setData */
+ AllocSetInit(&TopGlobalMemoryData.setData, DynamicAllocMode,
+ (Size)0);
+
+ /* make TopGlobalMemoryData member of ActiveGlobalMemorySet */
+ OrderedSetInit(ActiveGlobalMemorySet,
+ offsetof(struct GlobalMemory, elemData));
+ OrderedElemPushInto(&TopGlobalMemoryData.elemData,
+ ActiveGlobalMemorySet);
+
+ /* initialize CurrentMemoryContext */
+ CurrentMemoryContext = TopMemoryContext;
+
+ } else { /* cleanup */
+ GlobalMemory context;
+
+ /* walk the list of allocations */
+ while (PointerIsValid(context = (GlobalMemory)
+ OrderedSetGetHead(ActiveGlobalMemorySet))) {
+
+ if (context == &TopGlobalMemoryData) {
+ /* don't free it and clean it last */
+ OrderedElemPop(&TopGlobalMemoryData.elemData);
+ } else {
+ GlobalMemoryDestroy(context);
+ }
+ /* what is needed for the top? */
+ }
+
+ /*
+ * Freeing memory here should be safe as this is called
+ * only after all modules which allocate in TopMemoryContext
+ * have been disabled.
+ */
+
+ /* step through remaining allocations and log */
+ /* AllocSetStep(...); */
+
+ /* deallocate whatever is left */
+ AllocSetReset(&TopGlobalMemoryData.setData);
+ }
+
+ processing = false;
+}
+
+/*
+ * MemoryContextAlloc --
+ * Returns pointer to aligned allocated memory in the given context.
+ *
+ * Note:
+ * none
+ *
+ * Exceptions:
+ * BadState if called before InitMemoryManager.
+ * BadArg if context is invalid or if size is 0.
+ * BadAllocSize if size is larger than MaxAllocSize.
+ */
+Pointer
+MemoryContextAlloc(MemoryContext context, Size size)
+{
+ AssertState(MemoryContextEnabled);
+ AssertArg(MemoryContextIsValid(context));
+
+ LogTrap(!AllocSizeIsValid(size), BadAllocSize,
+ ("size=%d [0x%x]", size, size));
+
+ return (context->method->alloc(context, size));
+}
+
+/*
+ * MemoryContextFree --
+ * Frees allocated memory referenced by pointer in the given context.
+ *
+ * Note:
+ * none
+ *
+ * Exceptions:
+ * ???
+ * BadArgumentsErr if firstTime is true for subsequent calls.
+ */
+void
+MemoryContextFree(MemoryContext context, Pointer pointer)
+{
+ AssertState(MemoryContextEnabled);
+ AssertArg(MemoryContextIsValid(context));
+ AssertArg(PointerIsValid(pointer));
+
+ context->method->free_p(context, pointer);
+}
+
+/*
+ * MemoryContextRelloc --
+ * Returns pointer to aligned allocated memory in the given context.
+ *
+ * Note:
+ * none
+ *
+ * Exceptions:
+ * ???
+ * BadArgumentsErr if firstTime is true for subsequent calls.
+ */
+Pointer
+MemoryContextRealloc(MemoryContext context,
+ Pointer pointer,
+ Size size)
+{
+ AssertState(MemoryContextEnabled);
+ AssertArg(MemoryContextIsValid(context));
+ AssertArg(PointerIsValid(pointer));
+
+ LogTrap(!AllocSizeIsValid(size), BadAllocSize,
+ ("size=%d [0x%x]", size, size));
+
+ return (context->method->realloc(context, pointer, size));
+}
+
+/*
+ * MemoryContextGetName --
+ * Returns pointer to aligned allocated memory in the given context.
+ *
+ * Note:
+ * none
+ *
+ * Exceptions:
+ * ???
+ * BadArgumentsErr if firstTime is true for subsequent calls.
+ */
+char*
+MemoryContextGetName(MemoryContext context)
+{
+ AssertState(MemoryContextEnabled);
+ AssertArg(MemoryContextIsValid(context));
+
+ return (context->method->getName(context));
+}
+
+/*
+ * PointerGetAllocSize --
+ * Returns size of aligned allocated memory given pointer to it.
+ *
+ * Note:
+ * none
+ *
+ * Exceptions:
+ * ???
+ * BadArgumentsErr if firstTime is true for subsequent calls.
+ */
+Size
+PointerGetAllocSize(Pointer pointer)
+{
+ AssertState(MemoryContextEnabled);
+ AssertArg(PointerIsValid(pointer));
+
+ return (PSIZE(pointer));
+}
+
+/*
+ * MemoryContextSwitchTo --
+ * Returns the current context; installs the given context.
+ *
+ * Note:
+ * none
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadArg if context is invalid.
+ */
+MemoryContext
+MemoryContextSwitchTo(MemoryContext context)
+{
+ MemoryContext old;
+
+ AssertState(MemoryContextEnabled);
+ AssertArg(MemoryContextIsValid(context));
+
+ old = CurrentMemoryContext;
+ CurrentMemoryContext = context;
+ return (old);
+}
+
+/*
+ * External Functions
+ */
+/*
+ * CreateGlobalMemory --
+ * Returns new global memory context.
+ *
+ * Note:
+ * Assumes name is static.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadState if called outside TopMemoryContext (TopGlobalMemory).
+ * BadArg if name is invalid.
+ */
+GlobalMemory
+CreateGlobalMemory(char *name) /* XXX MemoryContextName */
+{
+ GlobalMemory context;
+ MemoryContext savecxt;
+
+ AssertState(MemoryContextEnabled);
+
+ savecxt = MemoryContextSwitchTo(TopMemoryContext);
+
+ context = (GlobalMemory)newNode(sizeof(struct GlobalMemory), T_GlobalMemory);
+ context->method = &GlobalContextMethodsData;
+ context->name = name; /* assumes name is static */
+ AllocSetInit(&context->setData, DynamicAllocMode, (Size)0);
+
+ /* link the context */
+ OrderedElemPushInto(&context->elemData, ActiveGlobalMemorySet);
+
+ MemoryContextSwitchTo(savecxt);
+ return (context);
+}
+
+/*
+ * GlobalMemoryDestroy --
+ * Destroys given global memory context.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadState if called outside TopMemoryContext (TopGlobalMemory).
+ * BadArg if context is invalid GlobalMemory.
+ * BadArg if context is TopMemoryContext (TopGlobalMemory).
+ */
+void
+GlobalMemoryDestroy(GlobalMemory context)
+{
+ AssertState(MemoryContextEnabled);
+ AssertArg(IsA(context,GlobalMemory));
+ AssertArg(context != &TopGlobalMemoryData);
+
+ AllocSetReset(&context->setData);
+
+ /* unlink and delete the context */
+ OrderedElemPop(&context->elemData);
+ MemoryContextFree(TopMemoryContext, (Pointer)context);
+}
+
+/*****************************************************************************
+ * PRIVATE *
+ *****************************************************************************/
+
+/*
+ * GlobalMemoryAlloc --
+ * Returns pointer to aligned space in the global context.
+ *
+ * Exceptions:
+ * ExhaustedMemory if allocation fails.
+ */
+static Pointer
+GlobalMemoryAlloc(GlobalMemory this, Size size)
+{
+ return (AllocSetAlloc(&this->setData, size));
+}
+
+/*
+ * GlobalMemoryFree --
+ * Frees allocated memory in the global context.
+ *
+ * Exceptions:
+ * BadContextErr if current context is not the global context.
+ * BadArgumentsErr if pointer is invalid.
+ */
+static void
+GlobalMemoryFree(GlobalMemory this,
+ Pointer pointer)
+{
+ AllocSetFree(&this->setData, pointer);
+}
+
+/*
+ * GlobalMemoryRealloc --
+ * Returns pointer to aligned space in the global context.
+ *
+ * Note:
+ * Memory associated with the pointer is freed before return.
+ *
+ * Exceptions:
+ * BadContextErr if current context is not the global context.
+ * BadArgumentsErr if pointer is invalid.
+ * NoMoreMemoryErr if allocation fails.
+ */
+static Pointer
+GlobalMemoryRealloc(GlobalMemory this,
+ Pointer pointer,
+ Size size)
+{
+ return (AllocSetRealloc(&this->setData, pointer, size));
+}
+
+/*
+ * GlobalMemoryGetName --
+ * Returns name string for context.
+ *
+ * Exceptions:
+ * ???
+ */
+static char*
+GlobalMemoryGetName(GlobalMemory this)
+{
+ return (this->name);
+}
+
+/*
+ * GlobalMemoryDump --
+ * Dumps global memory context for debugging.
+ *
+ * Exceptions:
+ * ???
+ */
+static void
+GlobalMemoryDump(GlobalMemory this)
+{
+ GlobalMemory context;
+
+ printf("--\n%s:\n", GlobalMemoryGetName(this));
+
+ context = (GlobalMemory)OrderedElemGetPredecessor(&this->elemData);
+ if (PointerIsValid(context)) {
+ printf("\tpredecessor=%s\n", GlobalMemoryGetName(context));
+ }
+
+ context = (GlobalMemory)OrderedElemGetSuccessor(&this->elemData);
+ if (PointerIsValid(context)) {
+ printf("\tsucessor=%s\n", GlobalMemoryGetName(context));
+ }
+
+ AllocSetDump(&this->setData); /* XXX is this right interface */
+}
+
+/*
+ * DumpGlobalMemories --
+ * Dumps all global memory contexts for debugging.
+ *
+ * Exceptions:
+ * ???
+ */
+static void
+DumpGlobalMemories()
+{
+ GlobalMemory context;
+
+ context = (GlobalMemory)OrderedSetGetHead(&ActiveGlobalMemorySetData);
+
+ while (PointerIsValid(context)) {
+ GlobalMemoryDump(context);
+
+ context = (GlobalMemory)OrderedElemGetSuccessor(
+ &context->elemData);
+ }
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * oset.c--
+ * Fixed format ordered set definitions.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/Attic/oset.c,v 1.1.1.1 1996/07/09 06:22:09 scrappy Exp $
+ *
+ * NOTE
+ * XXX This is a preliminary implementation which lacks fail-fast
+ * XXX validity checking of arguments.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "c.h"
+
+#include "utils/memutils.h" /* where declarations of this file goes */
+
+static Pointer OrderedElemGetBase(OrderedElem elem);
+static void OrderedElemInit(OrderedElem elem, OrderedSet set);
+static void OrderedElemPush(OrderedElem elem);
+static void OrderedElemPushHead(OrderedElem elem);
+
+/*
+ * OrderedElemGetBase --
+ * Returns base of enclosing structure.
+ */
+static Pointer
+OrderedElemGetBase(OrderedElem elem)
+{
+ if (elem == (OrderedElem) NULL)
+ return (Pointer) NULL;
+
+ return ((Pointer)((char*)(elem) - (elem)->set->offset));
+}
+
+/*
+ * OrderedSetInit --
+ */
+void
+OrderedSetInit(OrderedSet set, Offset offset)
+{
+ set->head = (OrderedElem)&set->dummy;
+ set->dummy = NULL;
+ set->tail = (OrderedElem)&set->head;
+ set->offset = offset;
+}
+
+/*
+ * OrderedElemInit --
+ */
+static void
+OrderedElemInit(OrderedElem elem, OrderedSet set)
+{
+ elem->set = set;
+ /* mark as unattached */
+ elem->next = NULL;
+ elem->prev = NULL;
+}
+
+/*
+ * OrderedSetContains --
+ * True iff ordered set contains given element.
+ */
+bool
+OrderedSetContains(OrderedSet set, OrderedElem elem)
+{
+ return ((bool)(elem->set == set && (elem->next || elem->prev)));
+}
+
+/*
+ * OrderedSetGetHead --
+ */
+Pointer
+OrderedSetGetHead(OrderedSet set)
+{
+ register OrderedElem elem;
+
+ elem = set->head;
+ if (elem->next) {
+ return (OrderedElemGetBase(elem));
+ }
+ return (NULL);
+}
+
+/*
+ * OrderedSetGetTail --
+ */
+Pointer
+OrderedSetGetTail(OrderedSet set)
+{
+ register OrderedElem elem;
+
+ elem = set->tail;
+ if (elem->prev) {
+ return (OrderedElemGetBase(elem));
+ }
+ return (NULL);
+}
+
+/*
+ * OrderedElemGetPredecessor --
+ */
+Pointer
+OrderedElemGetPredecessor(OrderedElem elem)
+{
+ elem = elem->prev;
+ if (elem->prev) {
+ return (OrderedElemGetBase(elem));
+ }
+ return (NULL);
+}
+
+/*
+ * OrderedElemGetSuccessor --
+ */
+Pointer
+OrderedElemGetSuccessor(OrderedElem elem)
+{
+ elem = elem->next;
+ if (elem->next) {
+ return (OrderedElemGetBase(elem));
+ }
+ return (NULL);
+}
+
+/*
+ * OrderedElemPop --
+ */
+void
+OrderedElemPop(OrderedElem elem)
+{
+ elem->next->prev = elem->prev;
+ elem->prev->next = elem->next;
+ /* assignments used only for error detection */
+ elem->next = NULL;
+ elem->prev = NULL;
+}
+
+/*
+ * OrderedElemPushInto --
+ */
+void
+OrderedElemPushInto(OrderedElem elem, OrderedSet set)
+{
+ OrderedElemInit(elem, set);
+ OrderedElemPush(elem);
+}
+
+/*
+ * OrderedElemPush --
+ */
+static void
+OrderedElemPush(OrderedElem elem)
+{
+ OrderedElemPushHead(elem);
+}
+
+/*
+ * OrderedElemPushHead --
+ */
+static void
+OrderedElemPushHead(OrderedElem elem)
+{
+ elem->next = elem->set->head;
+ elem->prev = (OrderedElem)&elem->set->head;
+ elem->next->prev = elem;
+ elem->prev->next = elem;
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * palloc.c--
+ * POSTGRES memory allocator code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/Attic/palloc.c,v 1.1.1.1 1996/07/09 06:22:09 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "c.h"
+
+#include "utils/mcxt.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+
+#include "nodes/memnodes.h"
+
+#include "utils/palloc.h"
+
+/* ----------------------------------------------------------------
+ * User library functions
+ * ----------------------------------------------------------------
+ */
+
+#undef palloc
+#undef pfree
+#undef MemoryContextAlloc
+#undef MemoryContextFree
+#undef malloc
+#undef free
+
+/* define PALLOC_IS_MALLOC if you want palloc to go straight to the
+ raw malloc, without concern for the extra bookkeeping needed to
+ ensure garbage is collected at the end of transactions - jolly 1/12/94 */
+
+
+/*
+ * palloc --
+ * Returns pointer to aligned memory of specified size.
+ *
+ * Exceptions:
+ * BadArgument if size < 1 or size >= MaxAllocSize.
+ * ExhaustedMemory if allocation fails.
+ * NonallocatedPointer if pointer was not returned by palloc or repalloc
+ * or may have been freed already.
+ *
+ * pfree --
+ * Frees memory associated with pointer returned from palloc or repalloc.
+ *
+ * Exceptions:
+ * BadArgument if pointer is invalid.
+ * FreeInWrongContext if pointer was allocated in a different "context."
+ * NonallocatedPointer if pointer was not returned by palloc or repalloc
+ * or may have been subsequently freed.
+ */
+void*
+palloc(Size size)
+{
+#ifdef PALLOC_IS_MALLOC
+ return malloc(size);
+#else
+ return (MemoryContextAlloc(CurrentMemoryContext, size));
+#endif /* PALLOC_IS_MALLOC */
+}
+
+void
+pfree(void *pointer)
+{
+#ifdef PALLOC_IS_MALLOC
+ free(pointer);
+#else
+ MemoryContextFree(CurrentMemoryContext, pointer);
+#endif /* PALLOC_IS_MALLOC */
+}
+
+/*
+ * repalloc --
+ * Returns pointer to aligned memory of specified size.
+ *
+ * Side effects:
+ * The returned memory is first filled with the contents of *pointer
+ * up to the minimum of size and psize(pointer). Pointer is freed.
+ *
+ * Exceptions:
+ * BadArgument if pointer is invalid or size < 1 or size >= MaxAllocSize.
+ * ExhaustedMemory if allocation fails.
+ * NonallocatedPointer if pointer was not returned by palloc or repalloc
+ * or may have been freed already.
+ */
+void *
+repalloc(void *pointer, Size size)
+{
+#ifdef PALLOC_IS_MALLOC
+ return realloc(pointer, size);
+#else
+ return (MemoryContextRealloc(CurrentMemoryContext, pointer, size));
+#endif
+}
+
+/* pstrdup
+ allocates space for and copies a string
+ just like strdup except it uses palloc instead of malloc */
+char*
+pstrdup(char* string)
+{
+ char *nstr;
+
+ nstr = strcpy((char *)palloc(strlen(string)+1), string);
+ return nstr;
+}
+
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * portalmem.c--
+ * backend portal memory context management stuff
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/portalmem.c,v 1.1.1.1 1996/07/09 06:22:09 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ * NOTES
+ * Do not confuse "Portal" with "PortalEntry" (or "PortalBuffer").
+ * When a PQexec() routine is run, the resulting tuples
+ * find their way into a "PortalEntry". The contents of the resulting
+ * "PortalEntry" can then be inspected by other PQxxx functions.
+ *
+ * A "Portal" is a structure used to keep track of queries of the
+ * form:
+ * retrieve portal FOO ( blah... ) where blah...
+ *
+ * When the backend sees a "retrieve portal" query, it allocates
+ * a "PortalD" structure, plans the query and then stores the query
+ * in the portal without executing it. Later, when the backend
+ * sees a
+ * fetch 1 into FOO
+ *
+ * the system looks up the portal named "FOO" in the portal table,
+ * gets the planned query and then calls the executor with a feature of
+ * '(EXEC_FOR 1). The executor then runs the query and returns a single
+ * tuple. The problem is that we have to hold onto the state of the
+ * portal query until we see a "close p". This means we have to be
+ * careful about memory management.
+ *
+ * Having said all that, here is what a PortalD currently looks like:
+ *
+ * struct PortalD {
+ * char* name;
+ * classObj(PortalVariableMemory) variable;
+ * classObj(PortalHeapMemory) heap;
+ * List queryDesc;
+ * EState state;
+ * void (*cleanup) ARGS((Portal portal));
+ * };
+ *
+ * I hope this makes things clearer to whoever reads this -cim 2/22/91
+ *
+ * Here is an old comment taken from nodes/memnodes.h
+ *
+ * MemoryContext --
+ * A logical context in which memory allocations occur.
+ *
+ * The types of memory contexts can be thought of as members of the
+ * following inheritance hierarchy with properties summarized below.
+ *
+ * Node
+ * |
+ * MemoryContext___
+ * / \
+ * GlobalMemory PortalMemoryContext
+ * / \
+ * PortalVariableMemory PortalHeapMemory
+ *
+ * Flushed at Flushed at Checkpoints
+ * Transaction Portal
+ * Commit Close
+ *
+ * GlobalMemory n n n
+ * PortalVariableMemory n y n
+ * PortalHeapMemory y y y *
+ *
+ */
+#include /* for sprintf() */
+#include /* for strlen, strncpy */
+
+#include "c.h"
+
+#include "lib/hasht.h"
+#include "utils/module.h"
+#include "utils/excid.h" /* for Unimplemented */
+#include "utils/elog.h"
+#include "utils/mcxt.h"
+#include "utils/hsearch.h"
+
+#include "nodes/memnodes.h"
+#include "nodes/nodes.h"
+#include "nodes/pg_list.h"
+#include "nodes/execnodes.h" /* for EState */
+
+#include "utils/portal.h"
+
+/* ----------------
+ * ALLOCFREE_ERROR_ABORT
+ * define this if you want a core dump when you try to
+ * free memory already freed -cim 2/9/91
+ * ----------------
+ */
+#undef ALLOCFREE_ERROR_ABORT
+
+/* ----------------
+ * Global state
+ * ----------------
+ */
+
+static int PortalManagerEnableCount = 0;
+#define MAX_PORTALNAME_LEN 64 /* XXX LONGALIGNable value */
+
+typedef struct portalhashent {
+ char portalname[MAX_PORTALNAME_LEN];
+ Portal portal;
+} PortalHashEnt;
+
+#define PortalManagerEnabled (PortalManagerEnableCount >= 1)
+
+static HTAB *PortalHashTable = NULL;
+#define PortalHashTableLookup(NAME, PORTAL) \
+ { PortalHashEnt *hentry; bool found; char key[MAX_PORTALNAME_LEN]; \
+ memset(key, 0, MAX_PORTALNAME_LEN); \
+ sprintf(key, "%s", NAME); \
+ hentry = (PortalHashEnt*)hash_search(PortalHashTable, \
+ key, HASH_FIND, &found); \
+ if (hentry == NULL) \
+ elog(FATAL, "error in PortalHashTable"); \
+ if (found) \
+ PORTAL = hentry->portal; \
+ else \
+ PORTAL = NULL; \
+ }
+#define PortalHashTableInsert(PORTAL) \
+ { PortalHashEnt *hentry; bool found; char key[MAX_PORTALNAME_LEN]; \
+ memset(key, 0, MAX_PORTALNAME_LEN); \
+ sprintf(key, "%s", PORTAL->name); \
+ hentry = (PortalHashEnt*)hash_search(PortalHashTable, \
+ key, HASH_ENTER, &found); \
+ if (hentry == NULL) \
+ elog(FATAL, "error in PortalHashTable"); \
+ if (found) \
+ elog(NOTICE, "trying to insert a portal name that exists."); \
+ hentry->portal = PORTAL; \
+ }
+#define PortalHashTableDelete(PORTAL) \
+ { PortalHashEnt *hentry; bool found; char key[MAX_PORTALNAME_LEN]; \
+ memset(key, 0, MAX_PORTALNAME_LEN); \
+ sprintf(key, "%s", PORTAL->name); \
+ hentry = (PortalHashEnt*)hash_search(PortalHashTable, \
+ key, HASH_REMOVE, &found); \
+ if (hentry == NULL) \
+ elog(FATAL, "error in PortalHashTable"); \
+ if (!found) \
+ elog(NOTICE, "trying to delete portal name that does not exist."); \
+ }
+
+static GlobalMemory PortalMemory = NULL;
+static char PortalMemoryName[] = "Portal";
+
+static Portal BlankPortal = NULL;
+
+/* ----------------
+ * Internal class definitions
+ * ----------------
+ */
+typedef struct HeapMemoryBlockData {
+ AllocSetData setData;
+ FixedItemData itemData;
+} HeapMemoryBlockData;
+
+typedef HeapMemoryBlockData *HeapMemoryBlock;
+
+#define HEAPMEMBLOCK(context) \
+ ((HeapMemoryBlock)(context)->block)
+
+/* ----------------------------------------------------------------
+ * Variable and heap memory methods
+ * ----------------------------------------------------------------
+ */
+/* ----------------
+ * PortalVariableMemoryAlloc
+ * ----------------
+ */
+static Pointer
+PortalVariableMemoryAlloc(PortalVariableMemory this,
+ Size size)
+{
+ return (AllocSetAlloc(&this->setData, size));
+}
+
+/* ----------------
+ * PortalVariableMemoryFree
+ * ----------------
+ */
+static void
+PortalVariableMemoryFree(PortalVariableMemory this,
+ Pointer pointer)
+{
+ AllocSetFree(&this->setData, pointer);
+}
+
+/* ----------------
+ * PortalVariableMemoryRealloc
+ * ----------------
+ */
+static Pointer
+PortalVariableMemoryRealloc(PortalVariableMemory this,
+ Pointer pointer,
+ Size size)
+{
+ return (AllocSetRealloc(&this->setData, pointer, size));
+}
+
+/* ----------------
+ * PortalVariableMemoryGetName
+ * ----------------
+ */
+static char*
+PortalVariableMemoryGetName(PortalVariableMemory this)
+{
+ return (form("%s-var", PortalVariableMemoryGetPortal(this)->name));
+}
+
+/* ----------------
+ * PortalVariableMemoryDump
+ * ----------------
+ */
+static void
+PortalVariableMemoryDump(PortalVariableMemory this)
+{
+ printf("--\n%s:\n", PortalVariableMemoryGetName(this));
+
+ AllocSetDump(&this->setData); /* XXX is this the right interface */
+}
+
+/* ----------------
+ * PortalHeapMemoryAlloc
+ * ----------------
+ */
+static Pointer
+PortalHeapMemoryAlloc(PortalHeapMemory this,
+ Size size)
+{
+ HeapMemoryBlock block = HEAPMEMBLOCK(this);
+
+ AssertState(PointerIsValid(block));
+
+ return (AllocSetAlloc(&block->setData, size));
+}
+
+/* ----------------
+ * PortalHeapMemoryFree
+ * ----------------
+ */
+static void
+PortalHeapMemoryFree(PortalHeapMemory this,
+ Pointer pointer)
+{
+ HeapMemoryBlock block = HEAPMEMBLOCK(this);
+
+ AssertState(PointerIsValid(block));
+
+ if (AllocSetContains(&block->setData, pointer))
+ AllocSetFree(&block->setData, pointer);
+ else {
+ elog(NOTICE,
+ "PortalHeapMemoryFree: 0x%x not in alloc set!",
+ pointer);
+#ifdef ALLOCFREE_ERROR_ABORT
+ Assert(AllocSetContains(&block->setData, pointer));
+#endif /* ALLOCFREE_ERROR_ABORT*/
+ }
+}
+
+/* ----------------
+ * PortalHeapMemoryRealloc
+ * ----------------
+ */
+static Pointer
+PortalHeapMemoryRealloc(PortalHeapMemory this,
+ Pointer pointer,
+ Size size)
+{
+ HeapMemoryBlock block = HEAPMEMBLOCK(this);
+
+ AssertState(PointerIsValid(block));
+
+ return (AllocSetRealloc(&block->setData, pointer, size));
+}
+
+/* ----------------
+ * PortalHeapMemoryGetName
+ * ----------------
+ */
+static char*
+PortalHeapMemoryGetName(PortalHeapMemory this)
+{
+ return (form("%s-heap", PortalHeapMemoryGetPortal(this)->name));
+}
+
+/* ----------------
+ * PortalHeapMemoryDump
+ * ----------------
+ */
+static void
+PortalHeapMemoryDump(PortalHeapMemory this)
+{
+ HeapMemoryBlock block;
+
+ printf("--\n%s:\n", PortalHeapMemoryGetName(this));
+
+ /* XXX is this the right interface */
+ if (PointerIsValid(this->block))
+ AllocSetDump(&HEAPMEMBLOCK(this)->setData);
+
+ /* dump the stack too */
+ for (block = (HeapMemoryBlock)FixedStackGetTop(&this->stackData);
+ PointerIsValid(block);
+ block = (HeapMemoryBlock)
+ FixedStackGetNext(&this->stackData, (Pointer)block)) {
+
+ printf("--\n");
+ AllocSetDump(&block->setData);
+ }
+}
+
+/* ----------------------------------------------------------------
+ * variable / heap context method tables
+ * ----------------------------------------------------------------
+ */
+static struct MemoryContextMethodsData PortalVariableContextMethodsData = {
+ PortalVariableMemoryAlloc, /* Pointer (*)(this, uint32) palloc */
+ PortalVariableMemoryFree, /* void (*)(this, Pointer) pfree */
+ PortalVariableMemoryRealloc,/* Pointer (*)(this, Pointer) repalloc */
+ PortalVariableMemoryGetName,/* char* (*)(this) getName */
+ PortalVariableMemoryDump /* void (*)(this) dump */
+};
+
+static struct MemoryContextMethodsData PortalHeapContextMethodsData = {
+ PortalHeapMemoryAlloc, /* Pointer (*)(this, uint32) palloc */
+ PortalHeapMemoryFree, /* void (*)(this, Pointer) pfree */
+ PortalHeapMemoryRealloc, /* Pointer (*)(this, Pointer) repalloc */
+ PortalHeapMemoryGetName, /* char* (*)(this) getName */
+ PortalHeapMemoryDump /* void (*)(this) dump */
+};
+
+
+/* ----------------------------------------------------------------
+ * private internal support routines
+ * ----------------------------------------------------------------
+ */
+/* ----------------
+ * CreateNewBlankPortal
+ * ----------------
+ */
+static void
+CreateNewBlankPortal()
+{
+ Portal portal;
+
+ AssertState(!PortalIsValid(BlankPortal));
+
+ /*
+ * make new portal structure
+ */
+ portal = (Portal)
+ MemoryContextAlloc((MemoryContext)PortalMemory, sizeof *portal);
+
+ /*
+ * initialize portal variable context
+ */
+ NodeSetTag((Node*)&portal->variable, T_PortalVariableMemory);
+ AllocSetInit(&portal->variable.setData, DynamicAllocMode, (Size)0);
+ portal->variable.method = &PortalVariableContextMethodsData;
+
+ /*
+ * initialize portal heap context
+ */
+ NodeSetTag((Node*)&portal->heap, T_PortalHeapMemory);
+ portal->heap.block = NULL;
+ FixedStackInit(&portal->heap.stackData,
+ offsetof (HeapMemoryBlockData, itemData));
+ portal->heap.method = &PortalHeapContextMethodsData;
+
+ /*
+ * set bogus portal name
+ */
+ portal->name = "** Blank Portal **";
+
+ /* initialize portal query */
+ portal->queryDesc = NULL;
+ portal->attinfo = NULL;
+ portal->state = NULL;
+ portal->cleanup = NULL;
+
+ /*
+ * install blank portal
+ */
+ BlankPortal = portal;
+}
+
+bool
+PortalNameIsSpecial(char *pname)
+{
+ if (strcmp(pname, VACPNAME) == 0)
+ return true;
+ return false;
+}
+
+/*
+ * This routine is used to collect all portals created in this xaction
+ * and then destroy them. There is a little trickiness required as a
+ * result of the dynamic hashing interface to getting every hash entry
+ * sequentially. Its use of static variables requires that we get every
+ * entry *before* we destroy anything (destroying updates the hashtable
+ * and screws up the sequential walk of the table). -mer 17 Aug 1992
+ */
+void
+CollectNamedPortals(Portal *portalP, int destroy)
+{
+ static Portal *portalList = (Portal *)NULL;
+ static int listIndex = 0;
+ static int maxIndex = 9;
+
+ if (portalList == (Portal *)NULL)
+ portalList = (Portal *)malloc(10*sizeof(Portal));
+
+ if (destroy != 0)
+ {
+ int i;
+
+ for (i = 0; i < listIndex; i++)
+ PortalDestroy(&portalList[i]);
+ listIndex = 0;
+ }
+ else
+ {
+ Assert(portalP);
+ Assert(*portalP);
+
+ /*
+ * Don't delete special portals, up to portal creator to do this
+ */
+ if (PortalNameIsSpecial((*portalP)->name))
+ return;
+
+ portalList[listIndex] = *portalP;
+ listIndex++;
+ if (listIndex == maxIndex)
+ {
+ portalList = (Portal *)
+ realloc(portalList, (maxIndex+11)*sizeof(Portal));
+ maxIndex += 10;
+ }
+ }
+ return;
+}
+
+void
+AtEOXact_portals()
+{
+ HashTableWalk(PortalHashTable, CollectNamedPortals, 0);
+ CollectNamedPortals(NULL, 1);
+}
+
+/* ----------------
+ * PortalDump
+ * ----------------
+ */
+static void
+PortalDump(Portal *thisP)
+{
+ /* XXX state/argument checking here */
+
+ PortalVariableMemoryDump(PortalGetVariableMemory(*thisP));
+ PortalHeapMemoryDump(PortalGetHeapMemory(*thisP));
+}
+
+/* ----------------
+ * DumpPortals
+ * ----------------
+ */
+static void
+DumpPortals()
+{
+ /* XXX state checking here */
+
+ HashTableWalk(PortalHashTable, PortalDump, 0);
+}
+
+/* ----------------------------------------------------------------
+ * public portal interface functions
+ * ----------------------------------------------------------------
+ */
+/*
+ * EnablePortalManager --
+ * Enables/disables the portal management module.
+ */
+void
+EnablePortalManager(bool on)
+{
+ static bool processing = false;
+ HASHCTL ctl;
+
+ AssertState(!processing);
+ AssertArg(BoolIsValid(on));
+
+ if (BypassEnable(&PortalManagerEnableCount, on))
+ return;
+
+ processing = true;
+
+ if (on) { /* initialize */
+ EnableMemoryContext(true);
+
+ PortalMemory = CreateGlobalMemory(PortalMemoryName);
+
+ ctl.keysize = MAX_PORTALNAME_LEN;
+ ctl.datasize = sizeof(Portal);
+
+ /* use PORTALS_PER_USER, defined in utils/portal.h
+ * as a guess of how many hash table entries to create, initially
+ */
+ PortalHashTable = hash_create(PORTALS_PER_USER * 3, &ctl, HASH_ELEM);
+
+ CreateNewBlankPortal();
+
+ } else { /* cleanup */
+ if (PortalIsValid(BlankPortal)) {
+ PortalDestroy(&BlankPortal);
+ MemoryContextFree((MemoryContext)PortalMemory,
+ (Pointer)BlankPortal);
+ BlankPortal = NULL;
+ }
+ /*
+ * Each portal must free its non-memory resources specially.
+ */
+ HashTableWalk(PortalHashTable, PortalDestroy, 0);
+ hash_destroy(PortalHashTable);
+ PortalHashTable = NULL;
+
+ GlobalMemoryDestroy(PortalMemory);
+ PortalMemory = NULL;
+
+ EnableMemoryContext(true);
+ }
+
+ processing = false;
+}
+
+/*
+ * GetPortalByName --
+ * Returns a portal given a portal name; returns blank portal given
+ * NULL; returns invalid portal if portal not found.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ */
+Portal
+GetPortalByName(char *name)
+{
+ Portal portal;
+
+ AssertState(PortalManagerEnabled);
+
+ if (PointerIsValid(name)) {
+ PortalHashTableLookup(name, portal);
+ }
+ else {
+ if (!PortalIsValid(BlankPortal))
+ CreateNewBlankPortal();
+ portal = BlankPortal;
+ }
+
+ return (portal);
+}
+
+/*
+ * BlankPortalAssignName --
+ * Returns former blank portal as portal with given name.
+ *
+ * Side effect:
+ * All references to the former blank portal become incorrect.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadState if called without an intervening call to GetPortalByName(NULL).
+ * BadArg if portal name is invalid.
+ * "WARN" if portal name is in use.
+ */
+Portal
+BlankPortalAssignName(char *name) /* XXX PortalName */
+{
+ Portal portal;
+ uint16 length;
+
+ AssertState(PortalManagerEnabled);
+ AssertState(PortalIsValid(BlankPortal));
+ AssertArg(PointerIsValid(name)); /* XXX PortalName */
+
+ portal = GetPortalByName(name);
+ if (PortalIsValid(portal)) {
+ elog(NOTICE, "BlankPortalAssignName: portal %s already exists", name);
+ return (portal);
+ }
+
+ /*
+ * remove blank portal
+ */
+ portal = BlankPortal;
+ BlankPortal = NULL;
+
+ /*
+ * initialize portal name
+ */
+ length = 1 + strlen(name);
+ portal->name = (char*)
+ MemoryContextAlloc((MemoryContext)&portal->variable, length);
+
+ strncpy(portal->name, name, length);
+
+ /*
+ * put portal in table
+ */
+ PortalHashTableInsert(portal);
+
+ return (portal);
+}
+
+/*
+ * PortalSetQuery --
+ * Attaches a "query" to portal.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadArg if portal is invalid.
+ * BadArg if queryDesc is "invalid."
+ * BadArg if state is "invalid."
+ */
+void
+PortalSetQuery(Portal portal,
+ QueryDesc *queryDesc,
+ TupleDesc attinfo,
+ EState *state,
+ void (*cleanup)(Portal portal))
+{
+ AssertState(PortalManagerEnabled);
+ AssertArg(PortalIsValid(portal));
+ AssertArg(IsA((Node*)state,EState));
+
+ portal->queryDesc = queryDesc;
+ portal->state = state;
+ portal->attinfo = attinfo;
+ portal->cleanup = cleanup;
+}
+
+/*
+ * PortalGetQueryDesc --
+ * Returns query attached to portal.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadArg if portal is invalid.
+ */
+QueryDesc *
+PortalGetQueryDesc(Portal portal)
+{
+ AssertState(PortalManagerEnabled);
+ AssertArg(PortalIsValid(portal));
+
+ return (portal->queryDesc);
+}
+
+/*
+ * PortalGetState --
+ * Returns state attached to portal.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadArg if portal is invalid.
+ */
+EState *
+PortalGetState(Portal portal)
+{
+ AssertState(PortalManagerEnabled);
+ AssertArg(PortalIsValid(portal));
+
+ return (portal->state);
+}
+
+/*
+ * CreatePortal --
+ * Returns a new portal given a name.
+ *
+ * Note:
+ * This is expected to be of very limited usability. See instead,
+ * BlankPortalAssignName.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadArg if portal name is invalid.
+ * "WARN" if portal name is in use.
+ */
+Portal
+CreatePortal(char *name) /* XXX PortalName */
+{
+ Portal portal;
+ uint16 length;
+
+ AssertState(PortalManagerEnabled);
+ AssertArg(PointerIsValid(name)); /* XXX PortalName */
+
+ portal = GetPortalByName(name);
+ if (PortalIsValid(portal)) {
+ elog(NOTICE, "CreatePortal: portal %s already exists", name);
+ return (portal);
+ }
+
+ /* make new portal structure */
+ portal = (Portal)
+ MemoryContextAlloc((MemoryContext)PortalMemory, sizeof *portal);
+
+ /* initialize portal variable context */
+ NodeSetTag((Node*)&portal->variable, T_PortalVariableMemory);
+ AllocSetInit(&portal->variable.setData, DynamicAllocMode, (Size)0);
+ portal->variable.method = &PortalVariableContextMethodsData;
+
+ /* initialize portal heap context */
+ NodeSetTag((Node*)&portal->heap, T_PortalHeapMemory);
+ portal->heap.block = NULL;
+ FixedStackInit(&portal->heap.stackData,
+ offsetof (HeapMemoryBlockData, itemData));
+ portal->heap.method = &PortalHeapContextMethodsData;
+
+ /* initialize portal name */
+ length = 1 + strlen(name);
+ portal->name = (char*)
+ MemoryContextAlloc((MemoryContext)&portal->variable, length);
+ strncpy(portal->name, name, length);
+
+ /* initialize portal query */
+ portal->queryDesc = NULL;
+ portal->attinfo = NULL;
+ portal->state = NULL;
+ portal->cleanup = NULL;
+
+ /* put portal in table */
+ PortalHashTableInsert(portal);
+
+ /* Trap(PointerIsValid(name), Unimplemented); */
+ return (portal);
+}
+
+/*
+ * PortalDestroy --
+ * Destroys portal.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadArg if portal is invalid.
+ */
+void
+PortalDestroy(Portal *portalP)
+{
+ Portal portal = *portalP;
+
+ AssertState(PortalManagerEnabled);
+ AssertArg(PortalIsValid(portal));
+
+ /* remove portal from table if not blank portal */
+ if (portal != BlankPortal)
+ PortalHashTableDelete(portal);
+
+ /* reset portal */
+ if (PointerIsValid(portal->cleanup))
+ (*portal->cleanup)(portal);
+
+ PortalResetHeapMemory(portal);
+ MemoryContextFree((MemoryContext)&portal->variable,
+ (Pointer)portal->name);
+ AllocSetReset(&portal->variable.setData); /* XXX log */
+
+ if (portal != BlankPortal)
+ MemoryContextFree((MemoryContext)PortalMemory, (Pointer)portal);
+}
+
+/* ----------------
+ * PortalResetHeapMemory --
+ * Resets portal's heap memory context.
+ *
+ * Someday, Reset, Start, and End can be optimized by keeping a global
+ * portal module stack of free HeapMemoryBlock's. This will make Start
+ * and End be fast.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadState if called when not in PortalHeapMemory context.
+ * BadArg if mode is invalid.
+ * ----------------
+ */
+void
+PortalResetHeapMemory(Portal portal)
+{
+ PortalHeapMemory context;
+ MemoryContext currentContext;
+
+ context = PortalGetHeapMemory(portal);
+
+ if (PointerIsValid(context->block)) {
+ /* save present context */
+ currentContext = MemoryContextSwitchTo((MemoryContext)context);
+
+ do {
+ EndPortalAllocMode();
+ } while (PointerIsValid(context->block));
+
+ /* restore context */
+ (void) MemoryContextSwitchTo(currentContext);
+ }
+}
+
+/*
+ * StartPortalAllocMode --
+ * Starts a new block of portal heap allocation using mode and limit;
+ * the current block is disabled until EndPortalAllocMode is called.
+ *
+ * Note:
+ * Note blocks may be stacked and restored arbitarily.
+ * The semantics of mode and limit are described in aset.h.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadState if called when not in PortalHeapMemory context.
+ * BadArg if mode is invalid.
+ */
+void
+StartPortalAllocMode(AllocMode mode, Size limit)
+{
+ PortalHeapMemory context;
+
+ AssertState(PortalManagerEnabled);
+ AssertState(IsA(CurrentMemoryContext,PortalHeapMemory));
+ /* AssertArg(AllocModeIsValid); */
+
+ context = (PortalHeapMemory)CurrentMemoryContext;
+
+ /* stack current mode */
+ if (PointerIsValid(context->block))
+ FixedStackPush(&context->stackData, context->block);
+
+ /* allocate and initialize new block */
+ context->block =
+ MemoryContextAlloc(
+ (MemoryContext)PortalHeapMemoryGetVariableMemory(context),
+ sizeof (HeapMemoryBlockData) );
+
+ /* XXX careful, context->block has never been stacked => bad state */
+
+ AllocSetInit(&HEAPMEMBLOCK(context)->setData, mode, limit);
+}
+
+/*
+ * EndPortalAllocMode --
+ * Ends current block of portal heap allocation; previous block is
+ * reenabled.
+ *
+ * Note:
+ * Note blocks may be stacked and restored arbitarily.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadState if called when not in PortalHeapMemory context.
+ */
+void
+EndPortalAllocMode()
+{
+ PortalHeapMemory context;
+
+ AssertState(PortalManagerEnabled);
+ AssertState(IsA(CurrentMemoryContext,PortalHeapMemory));
+
+ context = (PortalHeapMemory)CurrentMemoryContext;
+ AssertState(PointerIsValid(context->block)); /* XXX Trap(...) */
+
+ /* free current mode */
+ AllocSetReset(&HEAPMEMBLOCK(context)->setData);
+ MemoryContextFree((MemoryContext)PortalHeapMemoryGetVariableMemory(context),
+ context->block);
+
+ /* restore previous mode */
+ context->block = FixedStackPop(&context->stackData);
+}
+
+/*
+ * PortalGetVariableMemory --
+ * Returns variable memory context for a given portal.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadArg if portal is invalid.
+ */
+PortalVariableMemory
+PortalGetVariableMemory(Portal portal)
+{
+ return (&portal->variable);
+}
+
+/*
+ * PortalGetHeapMemory --
+ * Returns heap memory context for a given portal.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadArg if portal is invalid.
+ */
+PortalHeapMemory
+PortalGetHeapMemory(Portal portal)
+{
+ return (&portal->heap);
+}
+
+/*
+ * PortalVariableMemoryGetPortal --
+ * Returns portal containing given variable memory context.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadArg if context is invalid.
+ */
+Portal
+PortalVariableMemoryGetPortal(PortalVariableMemory context)
+{
+ return ((Portal)((char *)context - offsetof (PortalD, variable)));
+}
+
+/*
+ * PortalHeapMemoryGetPortal --
+ * Returns portal containing given heap memory context.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadArg if context is invalid.
+ */
+Portal
+PortalHeapMemoryGetPortal(PortalHeapMemory context)
+{
+ return ((Portal)((char *)context - offsetof (PortalD, heap)));
+}
+
+/*
+ * PortalVariableMemoryGetHeapMemory --
+ * Returns heap memory context associated with given variable memory.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadArg if context is invalid.
+ */
+PortalHeapMemory
+PortalVariableMemoryGetHeapMemory(PortalVariableMemory context)
+{
+ return ((PortalHeapMemory)((char *)context
+ - offsetof (PortalD, variable)
+ + offsetof (PortalD, heap)));
+}
+
+/*
+ * PortalHeapMemoryGetVariableMemory --
+ * Returns variable memory context associated with given heap memory.
+ *
+ * Exceptions:
+ * BadState if called when disabled.
+ * BadArg if context is invalid.
+ */
+PortalVariableMemory
+PortalHeapMemoryGetVariableMemory(PortalHeapMemory context)
+{
+ return ((PortalVariableMemory)((char *)context
+ - offsetof (PortalD, heap)
+ + offsetof (PortalD, variable)));
+}
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * module.h--
+ * this file contains general "module" stuff that used to be
+ * spread out between the following files:
+ *
+ * enbl.h module enable stuff
+ * trace.h module trace stuff (now gone)
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: module.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MODULE_H
+#define MODULE_H
+
+/*
+ * prototypes for functions in init/enbl.c
+ */
+extern bool BypassEnable(int *enableCountInOutP, bool on);
+
+#endif /* MODULE_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * nabstime.h--
+ * Definitions for the "new" abstime code.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: nabstime.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NABSTIME_H
+#define NABSTIME_H
+
+#include
+#include
+#if !defined(PORTNAME_irix5)
+#include
+#endif
+#include "miscadmin.h" /* for SystemTime */
+
+/* ----------------------------------------------------------------
+ * time types + support macros
+ *
+ *
+ * ----------------------------------------------------------------
+ */
+typedef int32 AbsoluteTime;
+typedef int32 RelativeTime;
+
+typedef struct {
+ int32 status;
+ AbsoluteTime data[2];
+} TimeIntervalData;
+typedef TimeIntervalData *TimeInterval;
+
+#define EPOCH_ABSTIME ((AbsoluteTime) 0)
+#define INVALID_ABSTIME ((AbsoluteTime) 2147483647) /* 2^31 - 1 */
+#define CURRENT_ABSTIME ((AbsoluteTime) 2147483646) /* 2^31 - 2 */
+#define NOEND_ABSTIME ((AbsoluteTime) 2147483645) /* 2^31 - 3 */
+
+
+#if defined(PORTNAME_aix)
+/*
+ * AIX considers 2147483648 == -2147483648 (since they have the same bit
+ * representation) but uses a different sign sense in a comparison to
+ * these integer constants depending on whether the constant is signed
+ * or not!
+ */
+#include
+/*#define NOSTART_ABSTIME ((AbsoluteTime) HIBITI) */ /* - 2^31 */
+#define NOSTART_ABSTIME ((AbsoluteTime) INT_MIN)
+#else
+/*#define NOSTART_ABSTIME ((AbsoluteTime) 2147483648)*/ /* - 2^31 */
+#define NOSTART_ABSTIME ((AbsoluteTime) -2147483647) /* - 2^31 */
+#endif /* PORTNAME_aix */
+
+#define INVALID_RELTIME ((RelativeTime) 2147483647) /* 2^31 - 1 */
+
+/* ----------------
+ * time support macros (from tim.h)
+ * ----------------
+ */
+
+#define AbsoluteTimeIsValid(time) \
+ ((bool) ((time) != INVALID_ABSTIME))
+
+#define AbsoluteTimeIsReal(time) \
+ ((bool) (((AbsoluteTime) time) < NOEND_ABSTIME && \
+ ((AbsoluteTime) time) > NOSTART_ABSTIME))
+
+/* have to include this because EPOCH_ABSTIME used to be invalid - yuk */
+#define AbsoluteTimeIsBackwardCompatiblyValid(time) \
+ ((bool) (((AbsoluteTime) time) != INVALID_ABSTIME && \
+ ((AbsoluteTime) time) > EPOCH_ABSTIME))
+
+#define AbsoluteTimeIsBackwardCompatiblyReal(time) \
+ ((bool) (((AbsoluteTime) time) < NOEND_ABSTIME && \
+ ((AbsoluteTime) time) > NOSTART_ABSTIME && \
+ ((AbsoluteTime) time) > EPOCH_ABSTIME))
+
+#define RelativeTimeIsValid(time) \
+ ((bool) (((RelativeTime) time) != INVALID_RELTIME))
+
+#define GetCurrentAbsoluteTime() \
+ ((AbsoluteTime) getSystemTime())
+
+/*
+ * getSystemTime --
+ * Returns system time.
+ */
+#define getSystemTime() \
+ ((time_t) (time(0l)))
+
+
+/*
+ * Meridian: am, pm, or 24-hour style.
+ */
+#define AM 0
+#define PM 1
+#define HR24 2
+
+/* can't have more of these than there are bits in an unsigned long */
+#define MONTH 1
+#define YEAR 2
+#define DAY 3
+#define TIME 4
+#define TZ 5
+#define DTZ 6
+#define PG_IGNORE 7
+#define AMPM 8
+/* below here are unused so far */
+#define SECONDS 9
+#define MONTHS 10
+#define YEARS 11
+#define NUMBER 12
+/* these are only for relative dates */
+#define ABS_BEFORE 13
+#define ABS_AFTER 14
+#define AGO 15
+
+
+#define SECS(n) ((time_t)(n))
+#define MINS(n) ((time_t)(n) * SECS(60))
+#define HOURS(n) ((time_t)(n) * MINS(60)) /* 3600 secs */
+#define DAYS(n) ((time_t)(n) * HOURS(24)) /* 86400 secs */
+/* months and years are not constant length, must be specially dealt with */
+
+#define TOKMAXLEN 6 /* only this many chars are stored in datetktbl */
+
+/* keep this struct small; it gets used a lot */
+typedef struct {
+#if defined(PORTNAME_aix)
+ char *token;
+#else
+ char token[TOKMAXLEN];
+#endif /* PORTNAME_aix */
+ char type;
+ char value; /* this may be unsigned, alas */
+} datetkn;
+
+/*
+ * nabstime.c prototypes
+ */
+extern AbsoluteTime nabstimein(char *timestr);
+extern int prsabsdate(char *timestr, struct tm *tm, int *tzp);
+extern int tryabsdate(char *fields[], int nf, struct tm *tm, int *tzp);
+extern int parsetime(char *time, struct tm *tm);
+extern int split(char *string, char *fields[], int nfields, char *sep);
+extern char *nabstimeout(AbsoluteTime time);
+extern AbsoluteTime dateconv(struct tm *tm, int zone);
+extern time_t qmktime(struct tm *tp);
+extern datetkn *datetoktype(char *s, int *bigvalp);
+extern datetkn *datebsearch(char *key, datetkn *base, unsigned int nel);
+extern bool AbsoluteTimeIsBefore(AbsoluteTime time1, AbsoluteTime time2);
+extern bool AbsoluteTimeIsAfter(AbsoluteTime time1, AbsoluteTime time2);
+extern int32 abstimeeq(AbsoluteTime t1, AbsoluteTime t2);
+extern int32 abstimene(AbsoluteTime t1, AbsoluteTime t2);
+extern int32 abstimelt(AbsoluteTime t1, AbsoluteTime t2);
+extern int32 abstimegt(AbsoluteTime t1, AbsoluteTime t2);
+extern int32 abstimele(AbsoluteTime t1, AbsoluteTime t2);
+extern int32 abstimege(AbsoluteTime t1, AbsoluteTime t2);
+
+#endif /* NABSTIME_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * oidcompos.h--
+ * prototype file for the oid {char16,int4} composite type functions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: oidcompos.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef OIDCOMPOS_H
+#define OIDCOMPOS_H
+
+/* oidint4.c */
+OidInt4 oidint4in(char *o);
+char *oidint4out(OidInt4 o);
+bool oidint4lt(OidInt4 o1, OidInt4 o2);
+bool oidint4le(OidInt4 o1, OidInt4 o2);
+bool oidint4eq(OidInt4 o1, OidInt4 o2);
+bool oidint4ge(OidInt4 o1, OidInt4 o2);
+bool oidint4gt(OidInt4 o1, OidInt4 o2);
+bool oidint4ne(OidInt4 o1, OidInt4 o2);
+int oidint4cmp(OidInt4 o1, OidInt4 o2);
+OidInt4 mkoidint4(Oid v_oid, uint32 v_int4);
+
+/* oidint2.c */
+OidInt2 oidint2in(char *o);
+char *oidint2out(OidInt2 o);
+bool oidint2lt(OidInt2 o1, OidInt2 o2);
+bool oidint2le(OidInt2 o1, OidInt2 o2);
+bool oidint2eq(OidInt2 o1, OidInt2 o2);
+bool oidint2ge(OidInt2 o1, OidInt2 o2);
+bool oidint2gt(OidInt2 o1, OidInt2 o2);
+bool oidint2ne(OidInt2 o1, OidInt2 o2);
+int oidint2cmp(OidInt2 o1, OidInt2 o2);
+OidInt2 mkoidint2(Oid v_oid, uint16 v_int2);
+
+/* oidname.c */
+OidName oidnamein(char *inStr);
+char *oidnameout(OidName oidname);
+bool oidnamelt(OidName o1, OidName o2);
+bool oidnamele(OidName o1, OidName o2);
+bool oidnameeq(OidName o1, OidName o2);
+bool oidnamene(OidName o1, OidName o2);
+bool oidnamege(OidName o1, OidName o2);
+bool oidnamegt(OidName o1, OidName o2);
+int oidnamecmp(OidName o1, OidName o2);
+OidName mkoidname(Oid id, char *name);
+
+#endif /* OIDCOMPOS_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * palloc.h--
+ * POSTGRES memory allocator definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: palloc.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PALLOC_H
+#define PALLOC_H
+
+#include "c.h"
+
+extern void* palloc(Size size);
+extern void pfree(void *pointer);
+extern void *repalloc(void *pointer, Size size);
+
+/* like strdup except uses palloc */
+extern char* pstrdup(char* pointer);
+
+#endif /* PALLOC_H */
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * portal.h--
+ * POSTGRES portal definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: portal.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ * Note:
+ * A portal is an abstraction which represents the execution state of
+ * a running query (or a fixed sequence of queries). The "blank portal" is
+ * a portal with an InvalidName. This blank portal is in existance except
+ * between calls to BlankPortalAssignName and GetPortalByName(NULL).
+ *
+ * Note:
+ * now that PQ calls can be made from within a backend, a portal
+ * may also be used to keep track of the tuples resulting
+ * from the execution of a query. In this case, entryIndex
+ */
+#ifndef PORTAL_H
+#define PORTAL_H
+
+#include "c.h"
+
+#include "nodes/execnodes.h" /* for EState */
+#include "nodes/memnodes.h"
+#include "nodes/nodes.h"
+#include "nodes/pg_list.h"
+#include "nodes/plannodes.h" /* for Plan */
+#include "executor/execdesc.h"
+
+typedef struct PortalBlockData {
+ AllocSetData setData;
+ FixedItemData itemData;
+} PortalBlockData;
+
+typedef PortalBlockData *PortalBlock;
+
+typedef struct PortalD PortalD;
+typedef PortalD *Portal;
+
+struct PortalD {
+ char *name; /* XXX PortalName */
+ struct PortalVariableMemory variable;
+ struct PortalHeapMemory heap;
+ QueryDesc *queryDesc;
+ TupleDesc attinfo;
+ EState *state;
+ void (*cleanup)();
+};
+
+/*
+ * PortalIsValid --
+ * True iff portal is valid.
+ */
+#define PortalIsValid(p) PointerIsValid(p)
+
+/*
+ * Special portals (well, their names anyway)
+ */
+#define VACPNAME ""
+
+extern bool PortalNameIsSpecial(char *pname);
+extern void CollectNamedPortals(Portal *portalP, int destroy);
+extern void AtEOXact_portals(void);
+extern void EnablePortalManager(bool on);
+extern Portal GetPortalByName(char *name);
+extern Portal BlankPortalAssignName(char *name);
+extern void PortalSetQuery(Portal portal, QueryDesc *queryDesc,
+ TupleDesc attinfo, EState *state,
+ void (*cleanup)(Portal portal));
+extern QueryDesc *PortalGetQueryDesc(Portal portal);
+extern EState *PortalGetState(Portal portal);
+extern Portal CreatePortal(char *name);
+extern void PortalDestroy(Portal *portalP);
+extern void PortalResetHeapMemory(Portal portal);
+extern void StartPortalAllocMode(AllocMode mode, Size limit);
+extern void EndPortalAllocMode(void);
+extern PortalVariableMemory PortalGetVariableMemory(Portal portal);
+extern PortalHeapMemory PortalGetHeapMemory(Portal portal);
+extern Portal PortalVariableMemoryGetPortal(PortalVariableMemory context);
+extern Portal PortalHeapMemoryGetPortal(PortalHeapMemory context);
+extern PortalHeapMemory PortalVariableMemoryGetHeapMemory(PortalVariableMemory context);
+extern PortalVariableMemory PortalHeapMemoryGetVariableMemory(PortalHeapMemory context);
+
+/* estimate of the maximum number of open portals a user would have,
+ * used in initially sizing the PortalHashTable in EnablePortalManager()
+ */
+#define PORTALS_PER_USER 10
+
+
+#endif /* PORTAL_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * psort.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: psort.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PSORT_H
+#define PSORT_H
+
+#define SORTMEM (1 << 18) /* 1/4 M - any static memory */
+#define MAXTAPES 7 /* 7--See Fig. 70, p273 */
+#define TAPEEXT "pg_psort.XXXXXX" /* TEMPDIR/TAPEEXT */
+#define FREE(x) free((char *) x)
+
+struct tape {
+ int tp_dummy; /* (D) */
+ int tp_fib; /* (A) */
+ FILE *tp_file; /* (TAPE) */
+ struct tape *tp_prev;
+};
+
+struct cmplist {
+ int cp_attn; /* attribute number */
+ int cp_num; /* comparison function code */
+ int cp_rev; /* invert comparison flag */
+ struct cmplist *cp_next; /* next in chain */
+};
+
+extern int Nkeys;
+extern ScanKey key;
+extern int SortMemory; /* free memory */
+extern Relation SortRdesc;
+extern struct leftist *Tuples;
+
+#ifdef EBUG
+#include
+#include "utils/elog.h"
+#include "storage/buf.h"
+#include "storage/bufmgr.h"
+
+#define PDEBUG(PROC, S1)\
+elog(DEBUG, "%s:%d>> PROC: %s.", __FILE__, __LINE__, S1)
+
+#define PDEBUG2(PROC, S1, D1)\
+elog(DEBUG, "%s:%d>> PROC: %s %d.", __FILE__, __LINE__, S1, D1)
+
+#define PDEBUG4(PROC, S1, D1, S2, D2)\
+elog(DEBUG, "%s:%d>> PROC: %s %d, %s %d.", __FILE__, __LINE__, S1, D1, S2, D2)
+
+#define VDEBUG(VAR, FMT)\
+elog(DEBUG, "%s:%d>> VAR =FMT", __FILE__, __LINE__, VAR)
+
+#define ASSERT(EXPR, STR)\
+if (!(EXPR)) elog(FATAL, "%s:%d>> %s", __FILE__, __LINE__, STR)
+
+#define TRACE(VAL, CODE)\
+if (1) CODE; else
+
+#else
+#define PDEBUG(MSG)
+#define VDEBUG(VAR, FMT)
+#define ASSERT(EXPR, MSG)
+#define TRACE(VAL, CODE)
+#endif
+
+/* psort.c */
+extern void psort(Relation oldrel, Relation newrel, int nkeys, ScanKey key);
+extern void initpsort(void);
+extern void resetpsort(void);
+extern void initialrun(Relation rdesc);
+extern bool createrun(HeapScanDesc sdesc, FILE *file);
+extern HeapTuple tuplecopy(HeapTuple tup, Relation rdesc, Buffer b);
+extern FILE *mergeruns(void);
+extern void merge(struct tape *dest);
+extern void endpsort(Relation rdesc, FILE *file);
+extern FILE *gettape(void);
+extern void resettape(FILE *file);
+extern void destroytape(FILE *file);
+
+#endif /* PSORT_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * rel.h--
+ * POSTGRES relation descriptor definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: rel.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef REL_H
+#define REL_H
+
+#include "postgres.h"
+
+#include "storage/fd.h"
+#include "access/strat.h"
+#include "access/tupdesc.h"
+
+#include "catalog/pg_am.h"
+#include "catalog/pg_operator.h"
+#include "catalog/pg_class.h"
+
+#include "rewrite/prs2lock.h"
+
+typedef struct RelationData {
+ File rd_fd; /* open file descriptor */
+ int rd_nblocks; /* number of blocks in rel */
+ uint16 rd_refcnt; /* reference count */
+ bool rd_islocal; /* uses the local buffer mgr */
+ bool rd_isnailed; /* rel is nailed in cache */
+ Form_pg_am rd_am; /* AM tuple */
+ Form_pg_class rd_rel; /* RELATION tuple */
+ Oid rd_id; /* relations's object id */
+ Pointer lockInfo; /* ptr. to misc. info. */
+ TupleDesc rd_att; /* tuple desciptor */
+ RuleLock *rd_rules; /* rewrite rules */
+ IndexStrategy rd_istrat;
+ RegProcedure* rd_support;
+} RelationData;
+
+typedef RelationData *Relation;
+
+/* ----------------
+ * RelationPtr is used in the executor to support index scans
+ * where we have to keep track of several index relations in an
+ * array. -cim 9/10/89
+ * ----------------
+ */
+typedef Relation *RelationPtr;
+
+#define InvalidRelation ((Relation)NULL)
+
+typedef char ArchiveMode;
+
+/*
+ * RelationIsValid --
+ * True iff relation descriptor is valid.
+ */
+#define RelationIsValid(relation) PointerIsValid(relation)
+
+/*
+ * RelationGetSystemPort --
+ * Returns system port of a relation.
+ *
+ * Note:
+ * Assumes relation descriptor is valid.
+ */
+#define RelationGetSystemPort(relation) ((relation)->rd_fd)
+
+/*
+ * RelationGetLockInfo --
+ * Returns the lock information structure in the reldesc
+ *
+ */
+#define RelationGetLockInfo(relation) ((relation)->lockInfo)
+
+/*
+ * RelationHasReferenceCountZero --
+ * True iff relation reference count is zero.
+ *
+ * Note:
+ * Assumes relation descriptor is valid.
+ */
+#define RelationHasReferenceCountZero(relation) \
+ ((bool)((relation)->rd_refcnt == 0))
+
+/*
+ * RelationSetReferenceCount --
+ * Sets relation reference count.
+ */
+#define RelationSetReferenceCount(relation,count) ((relation)->rd_refcnt = count)
+
+/*
+ * RelationIncrementReferenceCount --
+ * Increments relation reference count.
+ */
+#define RelationIncrementReferenceCount(relation) ((relation)->rd_refcnt += 1);
+
+/*
+ * RelationDecrementReferenceCount --
+ * Decrements relation reference count.
+ */
+#define RelationDecrementReferenceCount(relation) ((relation)->rd_refcnt -= 1)
+
+/*
+ * RelationGetAccessMethodTupleForm --
+ * Returns access method attribute values for a relation.
+ *
+ * Note:
+ * Assumes relation descriptor is valid.
+ */
+#define RelationGetAccessMethodTupleForm(relation) ((relation)->rd_am)
+
+/*
+ * RelationGetRelationTupleForm --
+ * Returns relation attribute values for a relation.
+ *
+ * Note:
+ * Assumes relation descriptor is valid.
+ */
+#define RelationGetRelationTupleForm(relation) ((relation)->rd_rel)
+
+
+/*
+ * RelationGetRelationId --
+ *
+ * returns the object id of the relation
+ *
+ */
+#define RelationGetRelationId(relation) ((relation)->rd_id)
+
+/*
+ * RelationGetFile --
+ *
+ * Returns the open File decscriptor
+ */
+#define RelationGetFile(relation) ((relation)->rd_fd)
+
+
+/*
+ * RelationGetRelationName --
+ *
+ * Returns a Relation Name
+ */
+#define RelationGetRelationName(relation) (&(relation)->rd_rel->relname)
+
+/*
+ * RelationGetRelationName --
+ *
+ * Returns a the number of attributes.
+ */
+#define RelationGetNumberOfAttributes(relation) ((relation)->rd_rel->relnatts)
+
+/*
+ * RelationGetTupleDescriptor --
+ * Returns tuple descriptor for a relation.
+ *
+ * Note:
+ * Assumes relation descriptor is valid.
+ */
+#define RelationGetTupleDescriptor(relation) ((relation)->rd_att)
+
+extern IndexStrategy RelationGetIndexStrategy(Relation relation);
+
+extern void RelationSetIndexSupport(Relation relation, IndexStrategy strategy,
+ RegProcedure *support);
+#endif /* REL_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * rel2.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: rel2.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef TMP_REL2_H
+#define TMP_REL2_H
+
+#include "access/istrat.h"
+
+extern IndexStrategy RelationGetIndexStrategy(Relation relation);
+
+extern void RelationSetIndexSupport(Relation relation, IndexStrategy strategy,
+ RegProcedure *support);
+
+#endif /* TMP_REL2_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * relcache.h--
+ * Relation descriptor cache definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: relcache.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef RELCACHE_H
+#define RELCACHE_H
+
+#include
+
+#include "postgres.h"
+#include "utils/rel.h"
+
+/*
+ * relation lookup routines
+ */
+extern Relation RelationIdCacheGetRelation(Oid relationId);
+extern Relation RelationNameCacheGetRelation(char *relationName);
+extern Relation RelationIdGetRelation(Oid relationId);
+extern Relation RelationNameGetRelation(char *relationName);
+extern Relation getreldesc(char *relationName);
+
+extern void RelationClose(Relation relation);
+extern void RelationFlushRelation(Relation *relationPtr,
+ bool onlyFlushReferenceCountZero);
+extern void RelationIdInvalidateRelationCacheByRelationId(Oid relationId);
+
+extern void
+RelationIdInvalidateRelationCacheByAccessMethodId(Oid accessMethodId);
+
+extern void RelationCacheInvalidate(bool onlyFlushReferenceCountZero);
+
+extern void RelationRegisterRelation(Relation relation);
+extern void RelationPurgeLocalRelation(bool xactComitted);
+extern void RelationInitialize();
+extern void init_irels();
+extern void write_irels();
+
+
+#endif /* RELCACHE_H */
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * sets.h--
+ *
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: sets.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef SETS_H
+#define SETS_H
+
+/* Temporary name of set, before SetDefine changes it. */
+#define GENERICSETNAME "zyxset"
+
+extern Oid SetDefine(char *querystr, char *typename);
+extern int seteval(Oid funcoid);
+
+#endif /* SETS_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for utils/sort
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:22:10 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= lselect.c psort.c
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * lselect.c--
+ * leftist tree selection algorithm (linked priority queue--Knuth, Vol.3,
+ * pp.150-52)
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/lselect.c,v 1.1.1.1 1996/07/09 06:22:10 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+
+#include "c.h"
+
+#include "storage/buf.h"
+#include "access/skey.h"
+#include "access/heapam.h"
+#include "access/htup.h"
+#include "utils/rel.h"
+
+#include "utils/psort.h"
+#include "utils/lselect.h"
+
+extern Relation SortRdesc; /* later static */
+
+/*
+ * PUTTUP - writes the next tuple
+ * ENDRUN - mark end of run
+ * GETLEN - reads the length of the next tuple
+ * ALLOCTUP - returns space for the new tuple
+ * SETTUPLEN - stores the length into the tuple
+ * GETTUP - reads the tuple
+ *
+ * Note:
+ * LEN field must be a short; FP is a stream
+ */
+
+#define PUTTUP(TUP, FP) fwrite((char *)TUP, (TUP)->t_len, 1, FP)
+#define ENDRUN(FP) fwrite((char *)&shortzero, sizeof (shortzero), 1, FP)
+#define GETLEN(LEN, FP) fread(&(LEN), sizeof (shortzero), 1, FP)
+#define ALLOCTUP(LEN) ((HeapTuple)malloc((unsigned)LEN))
+#define GETTUP(TUP, LEN, FP)\
+ fread((char *)(TUP) + sizeof (shortzero), 1, (LEN) - sizeof (shortzero), FP)
+#define SETTUPLEN(TUP, LEN) (TUP)->t_len = LEN
+
+/*
+ * USEMEM - record use of memory
+ * FREEMEM - record freeing of memory
+ * FULLMEM - 1 iff a tuple will fit
+ */
+
+#define USEMEM(AMT) SortMemory -= (AMT)
+#define FREEMEM(AMT) SortMemory += (AMT)
+#define LACKMEM() (SortMemory <= BLCKSZ) /* not accurate */
+
+/*
+ * lmerge - merges two leftist trees into one
+ *
+ * Note:
+ * Enforcing the rule that pt->lt_dist >= qt->lt_dist may
+ * simplifify much of the code. Removing recursion will not
+ * speed up code significantly.
+ */
+struct leftist *
+lmerge(struct leftist *pt, struct leftist *qt)
+{
+ register struct leftist *root, *majorLeftist, *minorLeftist;
+ int dist;
+
+ if (tuplecmp(pt->lt_tuple, qt->lt_tuple)) {
+ root = pt;
+ majorLeftist = qt;
+ } else {
+ root = qt;
+ majorLeftist = pt;
+ }
+ if (root->lt_left == NULL)
+ root->lt_left = majorLeftist;
+ else {
+ if ((minorLeftist = root->lt_right) != NULL)
+ majorLeftist = lmerge(majorLeftist, minorLeftist);
+ if ((dist = root->lt_left->lt_dist) < majorLeftist->lt_dist) {
+ root->lt_dist = 1 + dist;
+ root->lt_right = root->lt_left;
+ root->lt_left = majorLeftist;
+ } else {
+ root->lt_dist = 1 + majorLeftist->lt_dist;
+ root->lt_right = majorLeftist;
+ }
+ }
+ return(root);
+}
+
+static struct leftist *
+linsert(struct leftist *root, struct leftist *new1)
+{
+ register struct leftist *left, *right;
+
+ if (! tuplecmp(root->lt_tuple, new1->lt_tuple)) {
+ new1->lt_left = root;
+ return(new1);
+ }
+ left = root->lt_left;
+ right = root->lt_right;
+ if (right == NULL) {
+ if (left == NULL)
+ root->lt_left = new1;
+ else {
+ root->lt_right = new1;
+ root->lt_dist = 2;
+ }
+ return(root);
+ }
+ right = linsert(right, new1);
+ if (right->lt_dist < left->lt_dist) {
+ root->lt_dist = 1 + left->lt_dist;
+ root->lt_left = right;
+ root->lt_right = left;
+ } else {
+ root->lt_dist = 1 + right->lt_dist;
+ root->lt_right = right;
+ }
+ return(root);
+}
+
+/*
+ * gettuple - returns tuple at top of tree (Tuples)
+ *
+ * Returns:
+ * tuple at top of tree, NULL if failed ALLOC()
+ * *devnum is set to the devnum of tuple returned
+ * *treep is set to the new tree
+ *
+ * Note:
+ * *treep must not be NULL
+ * NULL is currently never returned BUG
+ */
+HeapTuple
+gettuple(struct leftist **treep,
+ short *devnum) /* device from which tuple came */
+{
+ register struct leftist *tp;
+ HeapTuple tup;
+
+ tp = *treep;
+ tup = tp->lt_tuple;
+ *devnum = tp->lt_devnum;
+ if (tp->lt_dist == 1) /* lt_left == NULL */
+ *treep = tp->lt_left;
+ else
+ *treep = lmerge(tp->lt_left, tp->lt_right);
+
+ FREEMEM(sizeof (struct leftist));
+ FREE(tp);
+ return(tup);
+}
+
+/*
+ * puttuple - inserts new tuple into tree
+ *
+ * Returns:
+ * NULL iff failed ALLOC()
+ *
+ * Note:
+ * Currently never returns NULL BUG
+ */
+int
+puttuple(struct leftist **treep, HeapTuple newtuple, int devnum)
+{
+ register struct leftist *new1;
+ register struct leftist *tp;
+
+ new1 = (struct leftist *) malloc((unsigned) sizeof (struct leftist));
+ USEMEM(sizeof (struct leftist));
+ new1->lt_dist = 1;
+ new1->lt_devnum = devnum;
+ new1->lt_tuple = newtuple;
+ new1->lt_left = NULL;
+ new1->lt_right = NULL;
+ if ((tp = *treep) == NULL)
+ *treep = new1;
+ else
+ *treep = linsert(tp, new1);
+ return(1);
+}
+
+
+/*
+ * dumptuples - stores all the tuples in tree into file
+ */
+void
+dumptuples(FILE *file)
+{
+ register struct leftist *tp;
+ register struct leftist *newp;
+ HeapTuple tup;
+
+ tp = Tuples;
+ while (tp != NULL) {
+ tup = tp->lt_tuple;
+ if (tp->lt_dist == 1) /* lt_right == NULL */
+ newp = tp->lt_left;
+ else
+ newp = lmerge(tp->lt_left, tp->lt_right);
+ FREEMEM(sizeof (struct leftist));
+ FREE(tp);
+ PUTTUP(tup, file);
+ FREEMEM(tup->t_len);
+ FREE(tup);
+ tp = newp;
+ }
+ Tuples = NULL;
+}
+
+/*
+ * tuplecmp - Compares two tuples with respect CmpList
+ *
+ * Returns:
+ * 1 if left < right ;0 otherwise
+ * Assumtions:
+ */
+int
+tuplecmp(HeapTuple ltup, HeapTuple rtup)
+{
+ register char *lattr, *rattr;
+ int nkey = 0;
+ extern int Nkeys;
+ extern ScanKey Key;
+ int result = 0;
+ bool isnull;
+
+ if (ltup == (HeapTuple)NULL)
+ return(0);
+ if (rtup == (HeapTuple)NULL)
+ return(1);
+ while (nkey < Nkeys && !result) {
+ lattr = heap_getattr(ltup, InvalidBuffer,
+ Key[nkey].sk_attno,
+ RelationGetTupleDescriptor(SortRdesc),
+ &isnull);
+ if (isnull)
+ return(0);
+ rattr = heap_getattr(rtup, InvalidBuffer,
+ Key[nkey].sk_attno,
+ RelationGetTupleDescriptor(SortRdesc),
+ &isnull);
+ if (isnull)
+ return(1);
+ if (Key[nkey].sk_flags & SK_COMMUTE) {
+ if (!(result = (long) (*Key[nkey].sk_func) (rattr, lattr)))
+ result = -(long) (*Key[nkey].sk_func) (lattr, rattr);
+ } else if (!(result = (long) (*Key[nkey].sk_func) (lattr, rattr)))
+ result = -(long) (*Key[nkey].sk_func) (rattr, lattr);
+ nkey++;
+ }
+ return (result == 1);
+}
+
+#ifdef EBUG
+void
+checktree(struct leftist *tree)
+{
+ int lnodes;
+ int rnodes;
+
+ if (tree == NULL) {
+ puts("Null tree.");
+ return;
+ }
+ lnodes = checktreer(tree->lt_left, 1);
+ rnodes = checktreer(tree->lt_right, 1);
+ if (lnodes < 0) {
+ lnodes = -lnodes;
+ puts("0:\tBad left side.");
+ }
+ if (rnodes < 0) {
+ rnodes = -rnodes;
+ puts("0:\tBad right side.");
+ }
+ if (lnodes == 0) {
+ if (rnodes != 0)
+ puts("0:\tLeft and right reversed.");
+ if (tree->lt_dist != 1)
+ puts("0:\tDistance incorrect.");
+ } else if (rnodes == 0) {
+ if (tree->lt_dist != 1)
+ puts("0:\tDistance incorrect.");
+ } else if (tree->lt_left->lt_dist < tree->lt_right->lt_dist) {
+ puts("0:\tLeft and right reversed.");
+ if (tree->lt_dist != 1 + tree->lt_left->lt_dist)
+ puts("0:\tDistance incorrect.");
+ } else if (tree->lt_dist != 1+ tree->lt_right->lt_dist)
+ puts("0:\tDistance incorrect.");
+ if (lnodes > 0)
+ if (tuplecmp(tree->lt_left->lt_tuple, tree->lt_tuple))
+ printf("%d:\tLeft child < parent.\n");
+ if (rnodes > 0)
+ if (tuplecmp(tree->lt_right->lt_tuple, tree->lt_tuple))
+ printf("%d:\tRight child < parent.\n");
+ printf("Tree has %d nodes\n", 1 + lnodes + rnodes);
+}
+
+int
+checktreer(struct leftist *tree, int level)
+{
+ int lnodes, rnodes;
+ int error = 0;
+
+ if (tree == NULL)
+ return(0);
+ lnodes = checktreer(tree->lt_left, level + 1);
+ rnodes = checktreer(tree->lt_right, level + 1);
+ if (lnodes < 0) {
+ error = 1;
+ lnodes = -lnodes;
+ printf("%d:\tBad left side.\n", level);
+ }
+ if (rnodes < 0) {
+ error = 1;
+ rnodes = -rnodes;
+ printf("%d:\tBad right side.\n", level);
+ }
+ if (lnodes == 0) {
+ if (rnodes != 0) {
+ error = 1;
+ printf("%d:\tLeft and right reversed.\n", level);
+ }
+ if (tree->lt_dist != 1) {
+ error = 1;
+ printf("%d:\tDistance incorrect.\n", level);
+ }
+ } else if (rnodes == 0) {
+ if (tree->lt_dist != 1) {
+ error = 1;
+ printf("%d:\tDistance incorrect.\n", level);
+ }
+ } else if (tree->lt_left->lt_dist < tree->lt_right->lt_dist) {
+ error = 1;
+ printf("%d:\tLeft and right reversed.\n", level);
+ if (tree->lt_dist != 1 + tree->lt_left->lt_dist)
+ printf("%d:\tDistance incorrect.\n", level);
+ } else if (tree->lt_dist != 1+ tree->lt_right->lt_dist) {
+ error = 1;
+ printf("%d:\tDistance incorrect.\n", level);
+ }
+ if (lnodes > 0)
+ if (tuplecmp(tree->lt_left->lt_tuple, tree->lt_tuple)) {
+ error = 1;
+ printf("%d:\tLeft child < parent.\n");
+ }
+ if (rnodes > 0)
+ if (tuplecmp(tree->lt_right->lt_tuple, tree->lt_tuple)) {
+ error = 1;
+ printf("%d:\tRight child < parent.\n");
+ }
+ if (error)
+ return(-1 + -lnodes + -rnodes);
+ return(1 + lnodes + rnodes);
+}
+#endif
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * psort.c--
+ * Polyphase merge sort.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/psort.c,v 1.1.1.1 1996/07/09 06:22:10 scrappy Exp $
+ *
+ * NOTES
+ * Sorts the first relation into the second relation. The sort may
+ * not be called twice simultaneously.
+ *
+ * Use the tape-splitting method (Knuth, Vol. III, pp281-86) in the future.
+ *
+ * Arguments? Variables?
+ * MAXMERGE, MAXTAPES
+ *-------------------------------------------------------------------------
+ */
+#include
+#include
+
+#include "c.h"
+
+#include "executor/execdebug.h"
+#include "access/heapam.h"
+#include "access/htup.h"
+#include "access/relscan.h"
+#include "access/skey.h"
+#include "utils/tqual.h" /* for NowTimeQual */
+
+#include "storage/buf.h"
+#include "storage/bufmgr.h" /* for BLCKSZ */
+#include "utils/portal.h" /* for {Start,End}PortalAllocMode */
+#include "utils/elog.h"
+#include "utils/rel.h"
+
+#include "utils/psort.h"
+#include "utils/lselect.h"
+
+#include "storage/fd.h"
+
+#define TEMPDIR "./"
+
+int Nkeys;
+ScanKey Key;
+int SortMemory;
+
+static int TapeRange; /* number of tapes - 1 (T) */
+static int Level; /* (l) */
+static int TotalDummy; /* summation of tp_dummy */
+static struct tape Tape[MAXTAPES];
+static long shortzero = 0; /* used to delimit runs */
+static struct tuple *LastTuple = NULL; /* last output */
+
+static int BytesRead; /* to keep track of # of IO */
+static int BytesWritten;
+
+Relation SortRdesc; /* current tuples in memory */
+struct leftist *Tuples; /* current tuples in memory */
+
+/*
+ * psort - polyphase merge sort entry point
+ */
+void
+psort(Relation oldrel, Relation newrel, int nkeys, ScanKey key)
+{
+ AssertArg(nkeys >= 1);
+ AssertArg(key[0].sk_attno != 0);
+ AssertArg(key[0].sk_procedure != 0);
+
+ Nkeys = nkeys;
+ Key = key;
+ SortMemory = 0;
+ SortRdesc = oldrel;
+ BytesRead = 0;
+ BytesWritten = 0;
+ /*
+ * may not be the best place.
+ *
+ * Pass 0 for the "limit" as the argument is currently ignored.
+ * Previously, only one arg was passed. -mer 12 Nov. 1991
+ */
+ StartPortalAllocMode(StaticAllocMode, (Size)0);
+ initpsort();
+ initialrun(oldrel);
+ /* call finalrun(newrel, mergerun()) instead */
+ endpsort(newrel, mergeruns());
+ EndPortalAllocMode();
+ NDirectFileRead += (int)ceil((double)BytesRead / BLCKSZ);
+ NDirectFileWrite += (int)ceil((double)BytesWritten / BLCKSZ);
+}
+
+/*
+ * TAPENO - number of tape in Tape
+ */
+
+#define TAPENO(NODE) (NODE - Tape)
+#define TUPLENO(TUP) ((TUP == NULL) ? -1 : (int) TUP->t_iid)
+
+/*
+ * initpsort - initializes the tapes
+ * - (polyphase merge Alg.D(D1)--Knuth, Vol.3, p.270)
+ * Returns:
+ * number of allocated tapes
+ */
+void
+initpsort()
+{
+ register int i;
+ register struct tape *tp;
+
+ /*
+ ASSERT(ntapes >= 3 && ntapes <= MAXTAPES,
+ "initpsort: Invalid number of tapes to initialize.\n");
+ */
+
+ tp = Tape;
+ for (i = 0; i < MAXTAPES && (tp->tp_file = gettape()) != NULL; i++) {
+ tp->tp_dummy = 1;
+ tp->tp_fib = 1;
+ tp->tp_prev = tp - 1;
+ tp++;
+ }
+ TapeRange = --tp - Tape;
+ tp->tp_dummy = 0;
+ tp->tp_fib = 0;
+ Tape[0].tp_prev = tp;
+
+ if (TapeRange <= 1)
+ elog(WARN, "initpsort: Could only allocate %d < 3 tapes\n",
+ TapeRange + 1);
+
+ Level = 1;
+ TotalDummy = TapeRange;
+
+ SortMemory = SORTMEM;
+ LastTuple = NULL;
+ Tuples = NULL;
+}
+
+/*
+ * resetpsort - resets (frees) malloc'd memory for an aborted Xaction
+ *
+ * Not implemented yet.
+ */
+void
+resetpsort()
+{
+ ;
+}
+
+/*
+ * PUTTUP - writes the next tuple
+ * ENDRUN - mark end of run
+ * GETLEN - reads the length of the next tuple
+ * ALLOCTUP - returns space for the new tuple
+ * SETTUPLEN - stores the length into the tuple
+ * GETTUP - reads the tuple
+ *
+ * Note:
+ * LEN field must be a short; FP is a stream
+ */
+
+#define PUTTUP(TUP, FP)\
+ BytesWritten += (TUP)->t_len; \
+ fwrite((char *)TUP, (TUP)->t_len, 1, FP)
+#define ENDRUN(FP) fwrite((char *)&shortzero, sizeof (shortzero), 1, FP)
+#define GETLEN(LEN, FP) fread((char *)&(LEN), sizeof (shortzero), 1, FP)
+#define ALLOCTUP(LEN) ((HeapTuple)malloc((unsigned)LEN))
+#define GETTUP(TUP, LEN, FP)\
+ IncrProcessed(); \
+ BytesRead += (LEN) - sizeof (shortzero); \
+ fread((char *)(TUP) + sizeof (shortzero), (LEN) - sizeof (shortzero), 1, FP)
+#define SETTUPLEN(TUP, LEN) (TUP)->t_len = LEN
+
+ /*
+ * USEMEM - record use of memory
+ * FREEMEM - record freeing of memory
+ * FULLMEM - 1 iff a tuple will fit
+ */
+
+#define USEMEM(AMT) SortMemory -= (AMT)
+#define FREEMEM(AMT) SortMemory += (AMT)
+#define LACKMEM() (SortMemory <= BLCKSZ) /* not accurate */
+#define TRACEMEM(FUNC)
+#define TRACEOUT(FUNC, TUP)
+
+/*
+ * initialrun - distributes tuples from the relation
+ * - (replacement selection(R2-R3)--Knuth, Vol.3, p.257)
+ * - (polyphase merge Alg.D(D2-D4)--Knuth, Vol.3, p.271)
+ *
+ * Explaination:
+ * Tuples are distributed to the tapes as in Algorithm D.
+ * A "tuple" with t_size == 0 is used to mark the end of a run.
+ *
+ * Note:
+ * The replacement selection algorithm has been modified
+ * to go from R1 directly to R3 skipping R2 the first time.
+ *
+ * Maybe should use closer(rdesc) before return
+ * Perhaps should adjust the number of tapes if less than n.
+ * used--v. likely to have problems in mergeruns().
+ * Must know if should open/close files before each
+ * call to psort()? If should--messy??
+ *
+ * Possible optimization:
+ * put the first xxx runs in quickly--problem here since
+ * I (perhaps prematurely) combined the 2 algorithms.
+ * Also, perhaps allocate tapes when needed. Split into 2 funcs.
+ */
+void
+initialrun(Relation rdesc)
+{
+ /* register struct tuple *tup; */
+ register struct tape *tp;
+ HeapScanDesc sdesc;
+ int baseruns; /* D:(a) */
+ int morepasses; /* EOF */
+
+ sdesc = heap_beginscan(rdesc, 0, NowTimeQual, 0,
+ (ScanKey)NULL);
+ tp = Tape;
+
+ if ((bool)createrun(sdesc, tp->tp_file) != false)
+ morepasses = 0;
+ else
+ morepasses = 1 + (Tuples != NULL); /* (T != N) ? 2 : 1 */
+
+ for ( ; ; ) {
+ tp->tp_dummy--;
+ TotalDummy--;
+ if (tp->tp_dummy < (tp + 1)->tp_dummy)
+ tp++;
+ else if (tp->tp_dummy != 0)
+ tp = Tape;
+ else {
+ Level++;
+ baseruns = Tape[0].tp_fib;
+ for (tp = Tape; tp - Tape < TapeRange; tp++) {
+ TotalDummy +=
+ (tp->tp_dummy = baseruns
+ + (tp + 1)->tp_fib
+ - tp->tp_fib);
+ tp->tp_fib = baseruns
+ + (tp + 1)->tp_fib;
+ }
+ tp = Tape; /* D4 */
+ } /* D3 */
+ if (morepasses)
+ if (--morepasses) {
+ dumptuples(tp->tp_file);
+ ENDRUN(tp->tp_file);
+ continue;
+ } else
+ break;
+ if ((bool)createrun(sdesc, tp->tp_file) == false)
+ morepasses = 1 + (Tuples != NULL);
+ /* D2 */
+ }
+ for (tp = Tape + TapeRange; tp >= Tape; tp--)
+ rewind(tp->tp_file); /* D. */
+ heap_endscan(sdesc);
+}
+
+/*
+ * createrun - places the next run on file
+ *
+ * Uses:
+ * Tuples, which should contain any tuples for this run
+ *
+ * Returns:
+ * FALSE iff process through end of relation
+ * Tuples contains the tuples for the following run upon exit
+ */
+bool
+createrun(HeapScanDesc sdesc, FILE *file)
+{
+ register HeapTuple lasttuple;
+ register HeapTuple btup, tup;
+ struct leftist *nextrun;
+ Buffer b;
+ bool foundeor;
+ short junk;
+
+ lasttuple = NULL;
+ nextrun = NULL;
+ foundeor = false;
+ for ( ; ; ) {
+ while (LACKMEM() && Tuples != NULL) {
+ if (lasttuple != NULL) {
+ FREEMEM(lasttuple->t_len);
+ FREE(lasttuple);
+ TRACEMEM(createrun);
+ }
+ lasttuple = tup = gettuple(&Tuples, &junk);
+ PUTTUP(tup, file);
+ TRACEOUT(createrun, tup);
+ }
+ if (LACKMEM())
+ break;
+ btup = heap_getnext(sdesc, 0, &b);
+ if (!HeapTupleIsValid(btup)) {
+ foundeor = true;
+ break;
+ }
+ IncrProcessed();
+ tup = tuplecopy(btup, sdesc->rs_rd, b);
+ USEMEM(tup->t_len);
+ TRACEMEM(createrun);
+ if (lasttuple != NULL && tuplecmp(tup, lasttuple))
+ puttuple(&nextrun, tup, 0);
+ else
+ puttuple(&Tuples, tup, 0);
+ ReleaseBuffer(b);
+ }
+ if (lasttuple != NULL) {
+ FREEMEM(lasttuple->t_len);
+ FREE(lasttuple);
+ TRACEMEM(createrun);
+ }
+ dumptuples(file);
+ ENDRUN(file);
+ /* delimit the end of the run */
+ Tuples = nextrun;
+ return((bool)! foundeor); /* XXX - works iff bool is {0,1} */
+}
+
+/*
+ * tuplecopy - see also tuple.c:palloctup()
+ *
+ * This should eventually go there under that name? And this will
+ * then use malloc directly (see version -r1.2).
+ */
+HeapTuple
+tuplecopy(HeapTuple tup, Relation rdesc, Buffer b)
+{
+ HeapTuple rettup;
+
+ if (!HeapTupleIsValid(tup)) {
+ return(NULL); /* just in case */
+ }
+ rettup = (HeapTuple)malloc(tup->t_len);
+ memmove((char *)rettup, (char *)tup, tup->t_len); /* XXX */
+ return(rettup);
+}
+
+/*
+ * mergeruns - merges all runs from input tapes
+ * (polyphase merge Alg.D(D6)--Knuth, Vol.3, p271)
+ *
+ * Returns:
+ * file of tuples in order
+ */
+FILE *
+mergeruns()
+{
+ register struct tape *tp;
+
+ tp = Tape + TapeRange;
+ merge(tp);
+ rewind(tp->tp_file);
+ while (--Level != 0) {
+ tp = tp->tp_prev;
+ rewind(tp->tp_file);
+ /* resettape(tp->tp_file); -not sufficient */
+ merge(tp);
+ rewind(tp->tp_file);
+ }
+ return(tp->tp_file);
+}
+
+/*
+ * merge - handles a single merge of the tape
+ * (polyphase merge Alg.D(D5)--Knuth, Vol.3, p271)
+ */
+void
+merge(struct tape *dest)
+{
+ register HeapTuple tup;
+ register struct tape *lasttp; /* (TAPE[P]) */
+ register struct tape *tp;
+ struct leftist *tuples;
+ FILE *destfile;
+ int times; /* runs left to merge */
+ int outdummy; /* complete dummy runs */
+ short fromtape;
+ long tuplen;
+
+ lasttp = dest->tp_prev;
+ times = lasttp->tp_fib;
+ for (tp = lasttp ; tp != dest; tp = tp->tp_prev)
+ tp->tp_fib -= times;
+ tp->tp_fib += times;
+ /* Tape[].tp_fib (A[]) is set to proper exit values */
+
+ if (TotalDummy < TapeRange) /* no complete dummy runs */
+ outdummy = 0;
+ else {
+ outdummy = TotalDummy; /* a large positive number */
+ for (tp = lasttp; tp != dest; tp = tp->tp_prev)
+ if (outdummy > tp->tp_dummy)
+ outdummy = tp->tp_dummy;
+ for (tp = lasttp; tp != dest; tp = tp->tp_prev)
+ tp->tp_dummy -= outdummy;
+ tp->tp_dummy += outdummy;
+ TotalDummy -= outdummy * TapeRange;
+ /* do not add the outdummy runs yet */
+ times -= outdummy;
+ }
+ destfile = dest->tp_file;
+ while (times-- != 0) { /* merge one run */
+ tuples = NULL;
+ if (TotalDummy == 0)
+ for (tp = dest->tp_prev; tp != dest; tp = tp->tp_prev) {
+ GETLEN(tuplen, tp->tp_file);
+ tup = ALLOCTUP(tuplen);
+ USEMEM(tuplen);
+ TRACEMEM(merge);
+ SETTUPLEN(tup, tuplen);
+ GETTUP(tup, tuplen, tp->tp_file);
+ puttuple(&tuples, tup, TAPENO(tp));
+ }
+ else {
+ for (tp = dest->tp_prev; tp != dest; tp = tp->tp_prev) {
+ if (tp->tp_dummy != 0) {
+ tp->tp_dummy--;
+ TotalDummy--;
+ } else {
+ GETLEN(tuplen, tp->tp_file);
+ tup = ALLOCTUP(tuplen);
+ USEMEM(tuplen);
+ TRACEMEM(merge);
+ SETTUPLEN(tup, tuplen);
+ GETTUP(tup, tuplen, tp->tp_file);
+ puttuple(&tuples, tup, TAPENO(tp));
+ }
+ }
+ }
+ while (tuples != NULL) {
+ /* possible optimization by using count in tuples */
+ tup = gettuple(&tuples, &fromtape);
+ PUTTUP(tup, destfile);
+ FREEMEM(tup->t_len);
+ FREE(tup);
+ TRACEMEM(merge);
+ GETLEN(tuplen, Tape[fromtape].tp_file);
+ if (tuplen == 0)
+ ;
+ else {
+ tup = ALLOCTUP(tuplen);
+ USEMEM(tuplen);
+ TRACEMEM(merge);
+ SETTUPLEN(tup, tuplen);
+ GETTUP(tup, tuplen, Tape[fromtape].tp_file);
+ puttuple(&tuples, tup, fromtape);
+ }
+ }
+ ENDRUN(destfile);
+ }
+ TotalDummy += outdummy;
+}
+
+/*
+ * endpsort - creates the new relation and unlinks the tape files
+ */
+void
+endpsort(Relation rdesc, FILE *file)
+{
+ register struct tape *tp;
+ register HeapTuple tup;
+ long tuplen;
+
+ if (! feof(file))
+ while (GETLEN(tuplen, file) && tuplen != 0) {
+ tup = ALLOCTUP(tuplen);
+ SortMemory += tuplen;
+ SETTUPLEN(tup, tuplen);
+ GETTUP(tup, tuplen, file);
+ heap_insert(rdesc, tup);
+ FREE(tup);
+ SortMemory -= tuplen;
+ }
+ for (tp = Tape + TapeRange; tp >= Tape; tp--)
+ destroytape(tp->tp_file);
+}
+
+/*
+ * gettape - handles access temporary files in polyphase merging
+ *
+ * Optimizations:
+ * If guarenteed that only one sort running/process,
+ * can simplify the file generation--and need not store the
+ * name for later unlink.
+ */
+
+struct tapelst {
+ char *tl_name;
+ int tl_fd;
+ struct tapelst *tl_next;
+};
+
+static struct tapelst *Tapes = NULL;
+static char Tempfile[MAXPGPATH] = TEMPDIR;
+
+/*
+ * gettape - returns an open stream for writing/reading
+ *
+ * Returns:
+ * Open stream for writing/reading.
+ * NULL if unable to open temporary file.
+ */
+FILE *
+gettape()
+{
+ register struct tapelst *tp;
+ FILE *file;
+ static int tapeinit = 0;
+ char *mktemp();
+
+ tp = (struct tapelst *)malloc((unsigned)sizeof (struct tapelst));
+ if (!tapeinit) {
+ Tempfile[sizeof (TEMPDIR) - 1] = '/';
+ memmove(Tempfile + sizeof(TEMPDIR), TAPEEXT, sizeof (TAPEEXT));
+ tapeinit = 1;
+ }
+ tp->tl_name = malloc((unsigned)sizeof(Tempfile));
+ /*
+ * now, copy template with final null into malloc'd space
+ */
+ memmove(tp->tl_name, Tempfile, sizeof (TEMPDIR) + sizeof (TAPEEXT));
+ mktemp(tp->tl_name);
+
+ AllocateFile();
+ file = fopen(tp->tl_name, "w+");
+ if (file == NULL) {
+ /* XXX this should not happen */
+ FreeFile();
+ FREE(tp->tl_name);
+ FREE(tp);
+ return(NULL);
+ }
+
+ tp->tl_fd = fileno(file);
+ tp->tl_next = Tapes;
+ Tapes = tp;
+ return(file);
+}
+
+/*
+ * resettape - resets the tape to size 0
+ */
+void
+resettape(FILE *file)
+{
+ register struct tapelst *tp;
+ register int fd;
+
+ Assert(PointerIsValid(file));
+
+ fd = fileno(file);
+ for (tp = Tapes; tp != NULL && tp->tl_fd != fd; tp = tp->tl_next)
+ ;
+ if (tp == NULL)
+ elog(WARN, "resettape: tape not found");
+
+ file = freopen(tp->tl_name, "w+", file);
+ if (file == NULL) {
+ elog(FATAL, "could not freopen temporary file");
+ }
+}
+
+/*
+ * distroytape - unlinks the tape
+ *
+ * Efficiency note:
+ * More efficient to destroy more recently allocated tapes first.
+ *
+ * Possible bugs:
+ * Exits instead of returning status, if given invalid tape.
+ */
+void
+destroytape(FILE *file)
+{
+ register struct tapelst *tp, *tq;
+ register int fd;
+
+ if ((tp = Tapes) == NULL)
+ elog(FATAL, "destroytape: tape not found");
+
+ if ((fd = fileno(file)) == tp->tl_fd) {
+ Tapes = tp->tl_next;
+ fclose(file);
+ FreeFile();
+ unlink(tp->tl_name);
+ FREE(tp->tl_name);
+ FREE(tp);
+ } else
+ for ( ; ; ) {
+ if (tp->tl_next == NULL)
+ elog(FATAL, "destroytape: tape not found");
+ if (tp->tl_next->tl_fd == fd) {
+ fclose(file);
+ FreeFile();
+ tq = tp->tl_next;
+ tp->tl_next = tq->tl_next;
+ unlink(tq->tl_name);
+ FREE((tq->tl_name));
+ FREE(tq);
+ break;
+ }
+ tp = tp->tl_next;
+ }
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * syscache.h--
+ * System catalog cache definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: syscache.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef SYSCACHE_H
+#define SYSCACHE_H
+
+/*#define CACHEDEBUG*/ /* turns DEBUG elogs on */
+
+#include "postgres.h"
+#include "access/htup.h"
+#include "nodes/pg_list.h"
+
+/*
+ * Declarations for util/syscache.c.
+ *
+ * SysCache identifiers.
+ *
+ * The order of these must match the order
+ * they are entered into the structure cacheinfo[] in syscache.c
+ * The best thing to do is to add yours at the END, because some
+ * code assumes that certain caches are at certain places in this
+ * array.
+ */
+
+#define AMOPOPID 0
+#define AMOPSTRATEGY 1
+#define ATTNAME 2
+#define ATTNUM 3
+#define INDEXRELID 4
+#define LANNAME 5
+#define OPRNAME 6
+#define OPROID 7
+#define PRONAME 8
+#define PROOID 9
+#define RELNAME 10
+#define RELOID 11
+#define TYPNAME 12
+#define TYPOID 13
+#define AMNAME 14
+#define CLANAME 15
+#define INDRELIDKEY 16
+#define INHRELID 17
+#define RULOID 18
+#define AGGNAME 19
+#define LISTENREL 20
+#define USENAME 21
+#define USESYSID 22
+#define GRONAME 23
+#define GROSYSID 24
+#define REWRITENAME 25
+#define PROSRC 26
+
+/* ----------------
+ * struct cachedesc: information needed for a call to InitSysCache()
+ * ----------------
+ */
+struct cachedesc {
+ char *name; /* this is Name * so that we can initialize it */
+ int nkeys;
+ int key[4];
+ int size; /* sizeof(appropriate struct) */
+ char *indname; /* index relation for this cache, if exists */
+ HeapTuple (*iScanFunc)(); /* function to handle index scans */
+};
+
+extern void zerocaches(void);
+extern void InitCatalogCache(void);
+extern HeapTuple SearchSysCacheTuple(int cacheId, Datum key1, Datum key2,
+ Datum key3, Datum key4);
+extern int32 SearchSysCacheStruct(int cacheId, char *returnStruct,
+ Datum key1, Datum key2, Datum key3, Datum key4);
+extern void *SearchSysCacheGetAttribute(int cacheId,
+ AttrNumber attributeNumber,
+ Datum key1,
+ Datum key2,
+ Datum key3,
+ Datum key4);
+extern void *TypeDefaultRetrieve(Oid typId);
+
+#endif /* SYSCACHE_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for utils/time
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/backend/utils/time/Attic/Makefile.inc,v 1.1.1.1 1996/07/09 06:22:10 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SUBSRCS+= tqual.c
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * tqual.c--
+ * POSTGRES time qualification code.
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/utils/time/tqual.c,v 1.1.1.1 1996/07/09 06:22:10 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+
+/* #define TQUALDEBUG 1 */
+
+#include "postgres.h"
+
+#include "access/htup.h"
+#include "access/xact.h"
+#include "storage/bufmgr.h"
+#include "access/transam.h"
+#include "utils/elog.h"
+#include "utils/palloc.h"
+#include "utils/nabstime.h"
+
+#include "utils/tqual.h"
+
+/*
+ * TimeQualMode --
+ * Mode indicator for treatment of time qualifications.
+ */
+typedef uint16 TimeQualMode;
+
+#define TimeQualAt 0x1
+#define TimeQualNewer 0x2
+#define TimeQualOlder 0x4
+#define TimeQualAll 0x8
+
+#define TimeQualMask 0xf
+
+#define TimeQualEvery 0x0
+#define TimeQualRange (TimeQualNewer | TimeQualOlder)
+#define TimeQualAllAt (TimeQualAt | TimeQualAll)
+
+typedef struct TimeQualData {
+ AbsoluteTime start;
+ AbsoluteTime end;
+ TimeQualMode mode;
+} TimeQualData;
+
+typedef TimeQualData *InternalTimeQual;
+
+static TimeQualData SelfTimeQualData;
+TimeQual SelfTimeQual = (Pointer)&SelfTimeQualData;
+
+extern bool PostgresIsInitialized;
+
+/*
+ * XXX Transaction system override hacks start here
+ */
+#ifndef GOODAMI
+
+static TransactionId HeapSpecialTransactionId = InvalidTransactionId;
+static CommandId HeapSpecialCommandId = FirstCommandId;
+
+void
+setheapoverride(bool on)
+{
+ if (on) {
+ TransactionIdStore(GetCurrentTransactionId(),
+ &HeapSpecialTransactionId);
+ HeapSpecialCommandId = GetCurrentCommandId();
+ } else {
+ HeapSpecialTransactionId = InvalidTransactionId;
+ }
+}
+
+/* static */
+bool
+heapisoverride()
+{
+ if (!TransactionIdIsValid(HeapSpecialTransactionId)) {
+ return (false);
+ }
+
+ if (!TransactionIdEquals(GetCurrentTransactionId(),
+ HeapSpecialTransactionId) ||
+ GetCurrentCommandId() != HeapSpecialCommandId) {
+ HeapSpecialTransactionId = InvalidTransactionId;
+
+ return (false);
+ }
+ return (true);
+}
+
+#endif /* !defined(GOODAMI) */
+/*
+ * XXX Transaction system override hacks end here
+ */
+
+static bool HeapTupleSatisfiesItself(HeapTuple tuple);
+static bool HeapTupleSatisfiesNow(HeapTuple tuple);
+static bool HeapTupleSatisfiesSnapshotInternalTimeQual(HeapTuple tuple,
+ InternalTimeQual qual);
+static bool HeapTupleSatisfiesUpperBoundedInternalTimeQual(HeapTuple tuple,
+ InternalTimeQual qual);
+static bool HeapTupleSatisfiesUpperUnboundedInternalTimeQual(HeapTuple tuple,
+ InternalTimeQual qual);
+
+
+
+/*
+ * TimeQualIsValid --
+ * True iff time qualification is valid.
+ */
+bool
+TimeQualIsValid(TimeQual qual)
+{
+ bool hasStartTime;
+
+ if (!PointerIsValid(qual) || qual == SelfTimeQual) {
+ return (true);
+ }
+
+ if (((InternalTimeQual)qual)->mode & ~TimeQualMask) {
+ return (false);
+ }
+
+ if (((InternalTimeQual)qual)->mode & TimeQualAt) {
+ return (AbsoluteTimeIsBackwardCompatiblyValid(((InternalTimeQual)qual)->start));
+ }
+
+ hasStartTime = false;
+
+ if (((InternalTimeQual)qual)->mode & TimeQualNewer) {
+ if (!AbsoluteTimeIsBackwardCompatiblyValid(((InternalTimeQual)qual)->start)) {
+ return (false);
+ }
+ hasStartTime = true;
+ }
+
+ if (((InternalTimeQual)qual)->mode & TimeQualOlder) {
+ if (!AbsoluteTimeIsBackwardCompatiblyValid(((InternalTimeQual)qual)->end)) {
+ return (false);
+ }
+ if (hasStartTime) {
+ return ((bool)!AbsoluteTimeIsBefore(
+ ((InternalTimeQual)qual)->end,
+ ((InternalTimeQual)qual)->start));
+ }
+ }
+ return (true);
+}
+
+/*
+ * TimeQualIsLegal --
+ * True iff time qualification is legal.
+ * I.e., true iff time qualification does not intersects the future,
+ * relative to the transaction start time.
+ *
+ * Note:
+ * Assumes time qualification is valid.
+ */
+bool
+TimeQualIsLegal(TimeQual qual)
+{
+ Assert(TimeQualIsValid(qual));
+
+ if (qual == NowTimeQual || qual == SelfTimeQual) {
+ return (true);
+ }
+
+ /* TimeQualAt */
+ if (((InternalTimeQual)qual)->mode & TimeQualAt) {
+ AbsoluteTime a, b;
+
+ a = ((InternalTimeQual)qual)->start;
+ b = GetCurrentTransactionStartTime();
+
+ if (AbsoluteTimeIsAfter(a, b))
+ return (false);
+ else
+ return (true);
+ }
+
+ /* TimeQualOlder or TimeQualRange */
+ if (((InternalTimeQual)qual)->mode & TimeQualOlder) {
+ AbsoluteTime a, b;
+
+ a = ((InternalTimeQual)qual)->end;
+ b = GetCurrentTransactionStartTime();
+
+ if (AbsoluteTimeIsAfter(a, b))
+ return (false);
+ else
+ return (true);
+ }
+
+ /* TimeQualNewer */
+ if (((InternalTimeQual)qual)->mode & TimeQualNewer) {
+ AbsoluteTime a, b;
+
+ a = ((InternalTimeQual)qual)->start;
+ b = GetCurrentTransactionStartTime();
+
+ if (AbsoluteTimeIsAfter(a, b))
+ return (false);
+ else
+ return (true);
+ }
+
+ /* TimeQualEvery */
+ return (true);
+}
+
+/*
+ * TimeQualIncludesNow --
+ * True iff time qualification includes "now."
+ *
+ * Note:
+ * Assumes time qualification is valid.
+ */
+bool
+TimeQualIncludesNow(TimeQual qual)
+{
+ Assert(TimeQualIsValid(qual));
+
+ if (qual == NowTimeQual || qual == SelfTimeQual) {
+ return (true);
+ }
+
+ if (((InternalTimeQual)qual)->mode & TimeQualAt) {
+ return (false);
+ }
+ if (((InternalTimeQual)qual)->mode & TimeQualOlder &&
+ !AbsoluteTimeIsAfter(
+ ((InternalTimeQual)qual)->end,
+ GetCurrentTransactionStartTime())) {
+
+ return (false);
+ }
+ return (true);
+}
+
+/*
+ * TimeQualIncludesPast --
+ * True iff time qualification includes some time in the past.
+ *
+ * Note:
+ * Assumes time qualification is valid.
+ * XXX may not be needed?
+ */
+bool
+TimeQualIncludesPast(TimeQual qual)
+{
+ Assert(TimeQualIsValid(qual));
+
+ if (qual == NowTimeQual || qual == SelfTimeQual) {
+ return (false);
+ }
+
+ /* otherwise, must check archive (setting locks as appropriate) */
+ return (true);
+}
+
+/*
+ * TimeQualIsSnapshot --
+ * True iff time qualification is a snapshot qualification.
+ *
+ * Note:
+ * Assumes time qualification is valid.
+ */
+bool
+TimeQualIsSnapshot(TimeQual qual)
+{
+ Assert(TimeQualIsValid(qual));
+
+ if (qual == NowTimeQual || qual == SelfTimeQual) {
+ return (false);
+ }
+
+ return ((bool)!!(((InternalTimeQual)qual)->mode & TimeQualAt));
+}
+
+/*
+ * TimeQualIsRanged --
+ * True iff time qualification is a ranged qualification.
+ *
+ * Note:
+ * Assumes time qualification is valid.
+ */
+bool
+TimeQualIsRanged(TimeQual qual)
+{
+ Assert(TimeQualIsValid(qual));
+
+ if (qual == NowTimeQual || qual == SelfTimeQual) {
+ return (false);
+ }
+
+ return ((bool)!(((InternalTimeQual)qual)->mode & TimeQualAt));
+}
+
+/*
+ * TimeQualIndicatesDisableValidityChecking --
+ * True iff time qualification indicates validity checking should be
+ * disabled.
+ *
+ * Note:
+ * XXX This should not be implemented since this does not make sense.
+ */
+bool
+TimeQualIndicatesDisableValidityChecking(TimeQual qual)
+{
+ Assert (TimeQualIsValid(qual));
+
+ if (qual == NowTimeQual || qual == SelfTimeQual) {
+ return (false);
+ }
+
+ if (((InternalTimeQual)qual)->mode & TimeQualAll) {
+ return (true);
+ }
+ return (false);
+}
+
+/*
+ * TimeQualGetSnapshotTime --
+ * Returns time for a snapshot time qual.
+ *
+ * Note:
+ * Assumes time qual is valid snapshot time qual.
+ */
+AbsoluteTime
+TimeQualGetSnapshotTime(TimeQual qual)
+{
+ Assert(TimeQualIsSnapshot(qual));
+
+ return (((InternalTimeQual)qual)->start);
+}
+
+/*
+ * TimeQualGetStartTime --
+ * Returns start time for a ranged time qual.
+ *
+ * Note:
+ * Assumes time qual is valid ranged time qual.
+ */
+AbsoluteTime
+TimeQualGetStartTime(TimeQual qual)
+{
+ Assert(TimeQualIsRanged(qual));
+
+ return (((InternalTimeQual)qual)->start);
+}
+
+/*
+ * TimeQualGetEndTime --
+ * Returns end time for a ranged time qual.
+ *
+ * Note:
+ * Assumes time qual is valid ranged time qual.
+ */
+AbsoluteTime
+TimeQualGetEndTime(TimeQual qual)
+{
+ Assert(TimeQualIsRanged(qual));
+
+ return (((InternalTimeQual)qual)->end);
+}
+
+/*
+ * TimeFormSnapshotTimeQual --
+ * Returns snapshot time qual for a time.
+ *
+ * Note:
+ * Assumes time is valid.
+ */
+TimeQual
+TimeFormSnapshotTimeQual(AbsoluteTime time)
+{
+ InternalTimeQual qual;
+
+ Assert(AbsoluteTimeIsBackwardCompatiblyValid(time));
+
+ qual = (InternalTimeQual)palloc(sizeof *qual);
+
+ qual->start = time;
+ qual->end = INVALID_ABSTIME;
+ qual->mode = TimeQualAt;
+
+ return ((TimeQual)qual);
+}
+
+/*
+ * TimeFormRangedTimeQual --
+ * Returns ranged time qual for a pair of times.
+ *
+ * Note:
+ * If start time is invalid, it is regarded as the epoch.
+ * If end time is invalid, it is regarded as "now."
+ * Assumes start time is before (or the same as) end time.
+ */
+TimeQual
+TimeFormRangedTimeQual(AbsoluteTime startTime,
+ AbsoluteTime endTime)
+{
+ InternalTimeQual qual;
+
+ qual = (InternalTimeQual)palloc(sizeof *qual);
+
+ qual->start = startTime;
+ qual->end = endTime;
+ qual->mode = TimeQualEvery;
+
+ if (AbsoluteTimeIsBackwardCompatiblyValid(startTime)) {
+ qual->mode |= TimeQualNewer;
+ }
+ if (AbsoluteTimeIsBackwardCompatiblyValid(endTime)) {
+ qual->mode |= TimeQualOlder;
+ }
+
+ return ((TimeQual)qual);
+}
+
+/*
+ * HeapTupleSatisfiesTimeQual --
+ * True iff heap tuple satsifies a time qual.
+ *
+ * Note:
+ * Assumes heap tuple is valid.
+ * Assumes time qual is valid.
+ * XXX Many of the checks may be simplified and still remain correct.
+ * XXX Partial answers to the checks may be cached in an ItemId.
+ */
+bool
+HeapTupleSatisfiesTimeQual(HeapTuple tuple, TimeQual qual)
+{
+/* extern TransactionId AmiTransactionId; */
+
+ Assert(HeapTupleIsValid(tuple));
+ Assert(TimeQualIsValid(qual));
+
+ if (TransactionIdEquals(tuple->t_xmax, AmiTransactionId))
+ return(false);
+
+ if (qual == SelfTimeQual || heapisoverride()) {
+ return (HeapTupleSatisfiesItself(tuple));
+ }
+
+ if (qual == NowTimeQual) {
+ return (HeapTupleSatisfiesNow(tuple));
+ }
+
+ if (!TimeQualIsLegal(qual)) {
+ elog(WARN, "HeapTupleSatisfiesTimeQual: illegal time qual");
+ }
+
+ if (TimeQualIndicatesDisableValidityChecking(qual)) {
+ elog(WARN, "HeapTupleSatisfiesTimeQual: no disabled validity checking (yet)");
+ }
+
+ if (TimeQualIsSnapshot(qual)) {
+ return (HeapTupleSatisfiesSnapshotInternalTimeQual(tuple,
+ (InternalTimeQual)qual));
+ }
+
+ if (TimeQualIncludesNow(qual)) {
+ return (HeapTupleSatisfiesUpperUnboundedInternalTimeQual(tuple,
+ (InternalTimeQual)qual));
+ }
+
+ return (HeapTupleSatisfiesUpperBoundedInternalTimeQual(tuple,
+ (InternalTimeQual)qual));
+}
+
+/*
+ * HeapTupleSatisfiesItself --
+ * True iff heap tuple is valid for "itself."
+ *
+ * Note:
+ * Assumes heap tuple is valid.
+ */
+/*
+ * The satisfaction of "itself" requires the following:
+ *
+ * ((Xmin == my-transaction && (Xmax is null [|| Xmax != my-transaction)])
+ * ||
+ *
+ * (Xmin is committed &&
+ * (Xmax is null || (Xmax != my-transaction && Xmax is not committed)))
+ */
+static bool
+HeapTupleSatisfiesItself(HeapTuple tuple)
+{
+ /*
+ * XXX Several evil casts are made in this routine. Casting XID to be
+ * TransactionId works only because TransactionId->data is the first
+ * (and only) field of the structure.
+ */
+ if (!AbsoluteTimeIsBackwardCompatiblyValid(tuple->t_tmin)) {
+ if (TransactionIdIsCurrentTransactionId((TransactionId)tuple->t_xmin) &&
+ !TransactionIdIsValid((TransactionId)tuple->t_xmax)) {
+ return (true);
+ }
+
+ if (!TransactionIdDidCommit((TransactionId)tuple->t_xmin)) {
+ return (false);
+ }
+ }
+ /* the tuple was inserted validly */
+
+ if (AbsoluteTimeIsBackwardCompatiblyReal(tuple->t_tmax)) {
+ return (false);
+ }
+
+ if (!TransactionIdIsValid((TransactionId)tuple->t_xmax)) {
+ return (true);
+ }
+
+ if (TransactionIdIsCurrentTransactionId((TransactionId)tuple->t_xmax)) {
+ return (false);
+ }
+
+ return ((bool)!TransactionIdDidCommit((TransactionId)tuple->t_xmax));
+}
+
+/*
+ * HeapTupleSatisfiesNow --
+ * True iff heap tuple is valid "now."
+ *
+ * Note:
+ * Assumes heap tuple is valid.
+ */
+/*
+ * The satisfaction of "now" requires the following:
+ *
+ * ((Xmin == my-transaction && Cmin != my-command &&
+ * (Xmax is null || (Xmax == my-transaction && Cmax != my-command)))
+ * ||
+ *
+ * (Xmin is committed &&
+ * (Xmax is null || (Xmax == my-transaction && Cmax == my-command) ||
+ * (Xmax is not committed && Xmax != my-transaction))))
+ *
+ * mao says 17 march 1993: the tests in this routine are correct;
+ * if you think they're not, you're wrong, and you should think
+ * about it again. i know, it happened to me. we don't need to
+ * check commit time against the start time of this transaction
+ * because 2ph locking protects us from doing the wrong thing.
+ * if you mess around here, you'll break serializability. the only
+ * problem with this code is that it does the wrong thing for system
+ * catalog updates, because the catalogs aren't subject to 2ph, so
+ * the serializability guarantees we provide don't extend to xacts
+ * that do catalog accesses. this is unfortunate, but not critical.
+ */
+static bool
+HeapTupleSatisfiesNow(HeapTuple tuple)
+{
+ if (AMI_OVERRIDE)
+ return true;
+ /*
+ * If the transaction system isn't yet initialized, then we assume
+ * that transactions committed. We only look at system catalogs
+ * during startup, so this is less awful than it seems, but it's
+ * still pretty awful.
+ */
+
+ if (!PostgresIsInitialized)
+ return ((bool)(TransactionIdIsValid((TransactionId)tuple->t_xmin) &&
+ !TransactionIdIsValid((TransactionId)tuple->t_xmax)));
+
+ /*
+ * XXX Several evil casts are made in this routine. Casting XID to be
+ * TransactionId works only because TransactionId->data is the first
+ * (and only) field of the structure.
+ */
+ if (!AbsoluteTimeIsBackwardCompatiblyValid(tuple->t_tmin)) {
+
+ if (TransactionIdIsCurrentTransactionId((TransactionId)tuple->t_xmin)
+ && CommandIdIsCurrentCommandId(tuple->t_cmin)) {
+
+ return (false);
+ }
+
+ if (TransactionIdIsCurrentTransactionId((TransactionId)tuple->t_xmin)
+ && !CommandIdIsCurrentCommandId(tuple->t_cmin)) {
+
+ if (!TransactionIdIsValid((TransactionId)tuple->t_xmax)) {
+ return (true);
+ }
+
+ Assert(TransactionIdIsCurrentTransactionId((TransactionId)tuple->t_xmax));
+
+ if (CommandIdIsCurrentCommandId(tuple->t_cmax)) {
+ return (true);
+ }
+ }
+
+ /*
+ * this call is VERY expensive - requires a log table lookup.
+ */
+
+ if (!TransactionIdDidCommit((TransactionId)tuple->t_xmin)) {
+ return (false);
+ }
+ }
+
+ /* by here, the inserting transaction has committed */
+ if (!TransactionIdIsValid((TransactionId)tuple->t_xmax)) {
+ return (true);
+ }
+
+ if (TransactionIdIsCurrentTransactionId((TransactionId)tuple->t_xmax)) {
+ return (false);
+ }
+
+ if (!TransactionIdDidCommit((TransactionId)tuple->t_xmax)) {
+ return (true);
+ }
+
+ /* by here, deleting transaction has committed */
+ return (false);
+}
+
+/*
+ * HeapTupleSatisfiesSnapshotInternalTimeQual --
+ * True iff heap tuple is valid at the snapshot time qualification.
+ *
+ * Note:
+ * Assumes heap tuple is valid.
+ * Assumes internal time qualification is valid snapshot qualification.
+ */
+/*
+ * The satisfaction of Rel[T] requires the following:
+ *
+ * (Xmin is committed && Tmin <= T &&
+ * (Xmax is null || (Xmax is not committed && Xmax != my-transaction) ||
+ * Tmax >= T))
+ */
+static bool
+HeapTupleSatisfiesSnapshotInternalTimeQual(HeapTuple tuple,
+ InternalTimeQual qual)
+{
+ /*
+ * XXX Several evil casts are made in this routine. Casting XID to be
+ * TransactionId works only because TransactionId->data is the first
+ * (and only) field of the structure.
+ */
+ if (!AbsoluteTimeIsBackwardCompatiblyValid(tuple->t_tmin)) {
+
+ if (!TransactionIdDidCommit((TransactionId)tuple->t_xmin)) {
+ return (false);
+ }
+
+ tuple->t_tmin = TransactionIdGetCommitTime(tuple->t_xmin);
+ }
+
+ if (AbsoluteTimeIsBefore(TimeQualGetSnapshotTime((TimeQual)qual), tuple->t_tmin)) {
+ return (false);
+ }
+ /* the tuple was inserted validly before the snapshot time */
+
+ if (!AbsoluteTimeIsBackwardCompatiblyReal(tuple->t_tmax)) {
+
+ if (!TransactionIdIsValid((TransactionId)tuple->t_xmax) ||
+ !TransactionIdDidCommit((TransactionId)tuple->t_xmax)) {
+
+ return (true);
+ }
+
+ tuple->t_tmax = TransactionIdGetCommitTime(tuple->t_xmax);
+ }
+
+ return ((bool)
+ AbsoluteTimeIsAfter(tuple->t_tmax,
+ TimeQualGetSnapshotTime((TimeQual)qual)));
+}
+
+/*
+ * HeapTupleSatisfiesUpperBoundedInternalTimeQual --
+ * True iff heap tuple is valid within a upper bounded time qualification.
+ *
+ * Note:
+ * Assumes heap tuple is valid.
+ * Assumes time qualification is valid ranged qualification with fixed
+ * upper bound.
+ */
+/*
+ * The satisfaction of [T1,T2] requires the following:
+ *
+ * (Xmin is committed && Tmin <= T2 &&
+ * (Xmax is null || (Xmax is not committed && Xmax != my-transaction) ||
+ * T1 is null || Tmax >= T1))
+ */
+static bool
+HeapTupleSatisfiesUpperBoundedInternalTimeQual(HeapTuple tuple,
+ InternalTimeQual qual)
+{
+ /*
+ * XXX Several evil casts are made in this routine. Casting XID to be
+ * TransactionId works only because TransactionId->data is the first
+ * (and only) field of the structure.
+ */
+ if (!AbsoluteTimeIsBackwardCompatiblyValid(tuple->t_tmin)) {
+
+ if (!TransactionIdDidCommit((TransactionId)tuple->t_xmin)) {
+ return (false);
+ }
+
+ tuple->t_tmin = TransactionIdGetCommitTime(tuple->t_xmin);
+ }
+
+ if (AbsoluteTimeIsBefore(TimeQualGetEndTime((TimeQual)qual), tuple->t_tmin)) {
+ return (false);
+ }
+ /* the tuple was inserted validly before the range end */
+
+ if (!AbsoluteTimeIsBackwardCompatiblyValid(TimeQualGetStartTime((TimeQual)qual))) {
+ return (true);
+ }
+
+ if (!AbsoluteTimeIsBackwardCompatiblyReal(tuple->t_tmax)) {
+
+ if (!TransactionIdIsValid((TransactionId)tuple->t_xmax) ||
+ !TransactionIdDidCommit((TransactionId)tuple->t_xmax)) {
+
+ return (true);
+ }
+
+ tuple->t_tmax = TransactionIdGetCommitTime(tuple->t_xmax);
+ }
+
+ return ((bool)AbsoluteTimeIsAfter(tuple->t_tmax,
+ TimeQualGetStartTime((TimeQual)qual)));
+}
+
+/*
+ * HeapTupleSatisfiesUpperUnboundedInternalTimeQual --
+ * True iff heap tuple is valid within a upper bounded time qualification.
+ *
+ * Note:
+ * Assumes heap tuple is valid.
+ * Assumes time qualification is valid ranged qualification with no
+ * upper bound.
+ */
+/*
+ * The satisfaction of [T1,] requires the following:
+ *
+ * ((Xmin == my-transaction && Cmin != my-command &&
+ * (Xmax is null || (Xmax == my-transaction && Cmax != my-command)))
+ * ||
+ *
+ * (Xmin is committed &&
+ * (Xmax is null || (Xmax == my-transaction && Cmax == my-command) ||
+ * (Xmax is not committed && Xmax != my-transaction) ||
+ * T1 is null || Tmax >= T1)))
+ */
+static bool
+HeapTupleSatisfiesUpperUnboundedInternalTimeQual(HeapTuple tuple,
+ InternalTimeQual qual)
+{
+ if (!AbsoluteTimeIsBackwardCompatiblyValid(tuple->t_tmin)) {
+
+ if (TransactionIdIsCurrentTransactionId((TransactionId)tuple->t_xmin) &&
+ CommandIdIsCurrentCommandId(tuple->t_cmin)) {
+
+ return (false);
+ }
+
+ if (TransactionIdIsCurrentTransactionId((TransactionId)tuple->t_xmin) &&
+ !CommandIdIsCurrentCommandId(tuple->t_cmin)) {
+
+ if (!TransactionIdIsValid((TransactionId)tuple->t_xmax)) {
+ return (true);
+ }
+
+ Assert(TransactionIdIsCurrentTransactionId((TransactionId)tuple->t_xmax));
+
+ return ((bool) !CommandIdIsCurrentCommandId(tuple->t_cmax));
+ }
+
+ if (!TransactionIdDidCommit((TransactionId)tuple->t_xmin)) {
+ return (false);
+ }
+
+ tuple->t_tmin = TransactionIdGetCommitTime(tuple->t_xmin);
+ }
+ /* the tuple was inserted validly */
+
+ if (!AbsoluteTimeIsBackwardCompatiblyValid(TimeQualGetStartTime((TimeQual)qual))) {
+ return (true);
+ }
+
+ if (!AbsoluteTimeIsBackwardCompatiblyReal(tuple->t_tmax)) {
+
+ if (!TransactionIdIsValid((TransactionId)tuple->t_xmax)) {
+ return (true);
+ }
+
+ if (TransactionIdIsCurrentTransactionId((TransactionId)tuple->t_xmax)) {
+ return (CommandIdIsCurrentCommandId(tuple->t_cmin));
+ }
+
+ if (!TransactionIdDidCommit((TransactionId)tuple->t_xmax)) {
+ return (true);
+ }
+
+ tuple->t_tmax = TransactionIdGetCommitTime(tuple->t_xmax);
+ }
+
+ return ((bool)AbsoluteTimeIsAfter(tuple->t_tmax,
+ TimeQualGetStartTime((TimeQual)qual)));
+}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * tqual.h--
+ * POSTGRES time qualification definitions.
+ *
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: tqual.h,v 1.1.1.1 1996/07/09 06:22:02 scrappy Exp $
+ *
+ * NOTE
+ * It may be desirable to allow time qualifications to indicate
+ * relative times.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef TQUAL_H
+#define TQUAL_H
+
+#include "postgres.h"
+#include "utils/nabstime.h"
+#include "access/htup.h"
+
+typedef struct TimeQualSpace {
+ char data[12];
+} TimeQualSpace;
+
+typedef Pointer TimeQual;
+
+/* Tuples valid as of StartTransactionCommand */
+#define NowTimeQual ((TimeQual) NULL)
+
+/* As above, plus updates in this command */
+extern TimeQual SelfTimeQual;
+
+extern void setheapoverride(bool on);
+extern bool heapisoverride(void);
+
+extern bool TimeQualIsValid(TimeQual qual);
+extern bool TimeQualIsLegal(TimeQual qual);
+extern bool TimeQualIncludesNow(TimeQual qual);
+extern bool TimeQualIncludesPast(TimeQual qual);
+extern bool TimeQualIsSnapshot(TimeQual qual);
+extern bool TimeQualIsRanged(TimeQual qual);
+extern bool TimeQualIndicatesDisableValidityChecking(TimeQual qual);
+extern AbsoluteTime TimeQualGetSnapshotTime(TimeQual qual);
+extern AbsoluteTime TimeQualGetStartTime(TimeQual qual);
+extern AbsoluteTime TimeQualGetEndTime(TimeQual qual);
+extern TimeQual TimeFormSnapshotTimeQual(AbsoluteTime time);
+extern TimeQual TimeFormRangedTimeQual(AbsoluteTime startTime,
+ AbsoluteTime endTime);
+extern bool HeapTupleSatisfiesTimeQual(HeapTuple tuple, TimeQual qual);
+
+
+#endif /* TQUAL_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for src/bin (utility programs)
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/bin/Makefile,v 1.1.1.1 1996/07/09 06:22:11 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+#
+# C programs
+#
+SUBDIR= monitor pg_id pg_version psql pg_dump
+
+ifeq ($(USE_TCL), true)
+SUBDIR += pgtclsh
+endif
+
+#
+# Shell scripts
+#
+SUBDIR+= cleardbdir createdb createuser destroydb destroyuser initdb
+
+
+include ../mk/postgres.subdir.mk
+
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# global configurations for Makefiles in src/bin
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/bin/Attic/Makefile.global,v 1.1.1.1 1996/07/09 06:22:11 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+CFLAGS+= -I$(HEADERDIR) -I$(srcdir)/backend -I$(srcdir)/backend/include -I$(srcdir)/libpq
+
+#
+# try locating libpq.a in the following places
+# Almost all (all?) the C programs in this directory
+# link with libpq, so we put it here.
+#
+LIBPQ:= -L$(srcdir)/libpq/$(objdir) -L$(LIBDIR) -lpq
+
+LD_ADD+= $(LIBPQ)
+DPADD+= $(LIBPQ)
+
+
+#
+# And where libpq goes, so goes the authentication stuff...
+#
+ifdef KRBVERS
+LD_ADD+= $(KRBLIBS)
+CFLAGS+= $(KRBFLAGS)
+endif
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for bin/cleardbdir
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/bin/cleardbdir/Attic/Makefile,v 1.1.1.1 1996/07/09 06:22:11 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SHPROG= cleardbdir
+
+MKDIR= ../../mk
+include $(MKDIR)/postgres.mk
+include ../Makefile.global
+
+include $(MKDIR)/postgres.shell.mk
+
--- /dev/null
+#!/bin/sh
+#-------------------------------------------------------------------------
+#
+# cleardbdir.sh--
+# completely clear out the database directory
+#
+# this program clears out the database directory, but leaves the .bki
+# files so that initdb(1) can be run again.
+#
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/bin/cleardbdir/Attic/cleardbdir.sh,v 1.1.1.1 1996/07/09 06:22:11 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+[ -z "$PGDATA" ] && PGDATA=_fUnKy_DATADIR_sTuFf_
+
+echo "This program completely destroys all the databases in the directory"
+echo "$PGDATA"
+echo _fUnKy_DASH_N_sTuFf_ "Are you sure you want to do this (y/n) [n]? "_fUnKy_BACKSLASH_C_sTuFf_
+read resp || exit
+case $resp in
+ y*) : ;;
+ *) exit ;;
+esac
+
+cd $PGDATA || exit
+for i in *
+do
+if [ $i != "files" -a $i != "pg_hba" ]
+then
+ /bin/rm -rf $i
+fi
+done
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for bin/createdb
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/bin/createdb/Attic/Makefile,v 1.1.1.1 1996/07/09 06:22:12 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SHPROG= createdb
+
+MKDIR= ../../mk
+include $(MKDIR)/postgres.mk
+include ../Makefile.global
+
+include $(MKDIR)/postgres.shell.mk
+
--- /dev/null
+#!/bin/sh
+#-------------------------------------------------------------------------
+#
+# createdb.sh--
+# create a postgres database
+#
+# this program runs the monitor with the "-c" option to create
+# the requested database.
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/bin/createdb/Attic/createdb.sh,v 1.1.1.1 1996/07/09 06:22:12 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+# ----------------
+# Set paths from environment or default values.
+# The _fUnKy_..._sTuFf_ gets set when the script is installed
+# from the default value for this build.
+# Currently the only thing we look for from the environment is
+# PGDATA, PGHOST, and PGPORT
+#
+# ----------------
+[ -z "$PGPORT" ] && PGPORT=5432
+[ -z "$PGHOST" ] && PGHOST=localhost
+BINDIR=_fUnKy_BINDIR_sTuFf_
+PATH=$BINDIR:$PATH
+
+CMDNAME=`basename $0`
+
+if [ -z "$USER" ]; then
+ if [ -z "$LOGNAME" ]; then
+ if [ -z "`whoami`" ]; then
+ echo "$CMDNAME: cannot determine user name"
+ exit 1
+ fi
+ else
+ USER=$LOGNAME
+ export USER
+ fi
+fi
+
+dbname=$USER
+
+while test -n "$1"
+do
+ case $1 in
+ -a) AUTHSYS=$2; shift;;
+ -h) PGHOST=$2; shift;;
+ -p) PGPORT=$2; shift;;
+ *) dbname=$1;;
+ esac
+ shift;
+done
+
+AUTHOPT="-a $AUTHSYS"
+[ -z "$AUTHSYS" ] && AUTHOPT=""
+
+monitor -TN $AUTHOPT -h $PGHOST -p $PGPORT -c "create database $dbname" template1 || {
+ echo "$CMDNAME: database creation failed on $dbname."
+ exit 1
+}
+
+exit 0
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for bin/createuser
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/bin/createuser/Attic/Makefile,v 1.1.1.1 1996/07/09 06:22:12 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SHPROG= createuser
+
+MKDIR= ../../mk
+include $(MKDIR)/postgres.mk
+include ../Makefile.global
+
+include $(MKDIR)/postgres.shell.mk
+
--- /dev/null
+#!/bin/sh
+#-------------------------------------------------------------------------
+#
+# createuser.sh--
+# utility for creating a user in the POSTGRES database
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/bin/createuser/Attic/createuser.sh,v 1.1.1.1 1996/07/09 06:22:12 scrappy Exp $
+#
+# Note - this should NOT be setuid.
+#
+#-------------------------------------------------------------------------
+
+# ----------------
+# Set paths from environment or default values.
+# The _fUnKy_..._sTuFf_ gets set when the script is installed
+# from the default value for this build.
+# Currently the only thing we look for from the environment is
+# PGDATA, PGHOST, and PGPORT
+#
+# ----------------
+[ -z "$PGPORT" ] && PGPORT=5432
+[ -z "$PGHOST" ] && PGHOST=localhost
+BINDIR=_fUnKy_BINDIR_sTuFf_
+PATH=$BINDIR:$PATH
+
+CMDNAME=`basename $0`
+
+if [ -z "$USER" ]; then
+ if [ -z "$LOGNAME" ]; then
+ if [ -z "`whoami`" ]; then
+ echo "$CMDNAME: cannot determine user name"
+ exit 1
+ fi
+ else
+ USER=$LOGNAME
+ export USER
+ fi
+fi
+
+while [ -n "$1" ]
+do
+ case $1 in
+ -a) AUTHSYS=$2; shift;;
+ -h) PGHOST=$2; shift;;
+ -p) PGPORT=$2; shift;;
+ *) NEWUSER=$1;;
+ esac
+ shift;
+done
+
+AUTHOPT="-a $AUTHSYS"
+[ -z "$AUTHSYS" ] && AUTHOPT=""
+
+MARGS="-TN $AUTHOPT -h $PGHOST -p $PGPORT"
+
+#
+# generate the first part of the actual monitor command
+#
+
+MONITOR="monitor $MARGS"
+
+#
+# see if user $USER is allowed to create new users
+#
+
+QUERY="select usesuper from pg_user where usename = '$USER'"
+#echo $QUERY
+
+ADDUSER=`$MONITOR -TN -c "$QUERY" template1`
+
+if [ $? -ne 0 ]
+then
+ echo "$CMDNAME: database access failed." 1>&2
+ exit 1
+fi
+
+if [ -n "$ADDUSER" ]
+then
+
+if [ $ADDUSER != "t" ]
+then
+ echo "$CMDNAME: $USER cannot create users." 1>&2
+ exit 1
+fi
+fi
+
+#
+# get the user name of the new user. Make sure it doesn't already exist.
+#
+
+if [ -z "$NEWUSER" ]
+then
+ echo _fUnKy_DASH_N_sTuFf_ "Enter name of user to add ---> "_fUnKy_BACKSLASH_C_sTuFf_
+ read NEWUSER
+fi
+
+QUERY="select usesysid from pg_user where usename = '$NEWUSER'"
+
+RES=`$MONITOR -TN -c "$QUERY" template1`
+
+if [ $? -ne 0 ]
+then
+ echo "$CMDNAME: database access failed." 1>&2
+ exit 1
+fi
+
+if [ -n "$RES" ]
+then
+ echo "$CMDNAME: user "\"$NEWUSER\"" already exists" 1>&2
+ exit 1
+fi
+
+done=0
+
+#
+# get the system id of the new user. Make sure it is unique.
+#
+
+while [ $done -ne 1 ]
+do
+ SYSID=
+ DEFSYSID=`pg_id $NEWUSER 2>/dev/null`
+ if [ $? -eq 0 ]; then
+ DEFMSG=" or RETURN to use unix user ID: $DEFSYSID"
+ else
+ DEFMSG=
+ DEFSYSID=
+ fi
+ while [ -z "$SYSID" ]
+ do
+ echo _fUnKy_DASH_N_sTuFf_ "Enter user's postgres ID$DEFMSG -> "_fUnKy_BACKSLASH_C_sTuFf_
+ read SYSID
+ [ -z "$SYSID" ] && SYSID=$DEFSYSID;
+ SYSIDISNUM=`echo $SYSID | egrep '^[0-9]+$'`
+ if [ -z "$SYSIDISNUM" ]
+ then
+ echo "$CMDNAME: the postgres ID must be a number"
+ exit 1
+ fi
+ QUERY="select usename from pg_user where usesysid = '$SYSID'::int4"
+ RES=`$MONITOR -TN -c "$QUERY" template1`
+ if [ $? -ne 0 ]
+ then
+ echo "$CMDNAME: database access failed."
+ exit 1
+ fi
+ if [ -n "$RES" ]
+ then
+ echo
+ echo "$CMDNAME: $SYSID already belongs to $RES, pick another"
+ DEFMSG= DEFSYSID= SYSID=
+ else
+ done=1
+ fi
+ done
+done
+
+#
+# get the rest of the user info...
+#
+
+#
+# can the user create databases?
+#
+
+yn=f
+
+while [ "$yn" != y -a "$yn" != n ]
+do
+ echo _fUnKy_DASH_N_sTuFf_ "Is user \"$NEWUSER\" allowed to create databases (y/n) "_fUnKy_BACKSLASH_C_sTuFf_
+ read yn
+done
+
+if [ "$yn" = y ]
+then
+ CANCREATE=t
+else
+ CANCREATE=f
+fi
+
+#
+# can the user add users?
+#
+
+yn=f
+
+while [ "$yn" != y -a "$yn" != n ]
+do
+ echo _fUnKy_DASH_N_sTuFf_ "Is user \"$NEWUSER\" allowed to add users? (y/n) "_fUnKy_BACKSLASH_C_sTuFf_
+ read yn
+done
+
+if (test "$yn" = y)
+then
+ CANADDUSER=t
+else
+ CANADDUSER=f
+fi
+
+QUERY="insert into pg_user \
+ (usename, usesysid, usecreatedb, usetrace, usesuper, usecatupd) \
+ values \
+ ('$NEWUSER', $SYSID, '$CANCREATE', 't', '$CANADDUSER','t')"
+
+RES=`$MONITOR -TN -c "$QUERY" template1`
+
+#
+# Wrap things up. If the user was created successfully, AND the user was
+# NOT allowed to create databases, remind the DBA to create one for the user.
+#
+
+if [ $? -ne 0 ]
+then
+ echo "$CMDNAME: $NEWUSER was NOT added successfully"
+else
+ echo "$CMDNAME: $NEWUSER was successfully added"
+ if [ "$CANCREATE" = f ]
+ then
+ echo "don't forget to create a database for $NEWUSER"
+ fi
+fi
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for bin/destroydb
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/bin/destroydb/Attic/Makefile,v 1.1.1.1 1996/07/09 06:22:12 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SHPROG= destroydb
+
+MKDIR= ../../mk
+include $(MKDIR)/postgres.mk
+include ../Makefile.global
+
+include $(MKDIR)/postgres.shell.mk
+
--- /dev/null
+#!/bin/sh
+#-------------------------------------------------------------------------
+#
+# destroydb.sh--
+# destroy a postgres database
+#
+# this program runs the monitor with the ? option to destroy
+# the requested database.
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/bin/destroydb/Attic/destroydb.sh,v 1.1.1.1 1996/07/09 06:22:12 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+# ----------------
+# Set paths from environment or default values.
+# The _fUnKy_..._sTuFf_ gets set when the script is installed
+# from the default value for this build.
+# Currently the only thing we look for from the environment is
+# PGDATA, PGHOST, and PGPORT
+#
+# ----------------
+[ -z "$PGPORT" ] && PGPORT=5432
+[ -z "$PGHOST" ] && PGHOST=localhost
+BINDIR=_fUnKy_BINDIR_sTuFf_
+PATH=$BINDIR:$PATH
+
+CMDNAME=`basename $0`
+
+if [ -z "$USER" ]; then
+ if [ -z "$LOGNAME" ]; then
+ if [ -z "`whoami`" ]; then
+ echo "$CMDNAME: cannot determine user name"
+ exit 1
+ fi
+ else
+ USER=$LOGNAME
+ export USER
+ fi
+fi
+
+dbname=$USER
+
+while [ -n "$1" ]
+do
+ case $1 in
+ -a) AUTHSYS=$2; shift;;
+ -h) PGHOST=$2; shift;;
+ -p) PGPORT=$2; shift;;
+ *) dbname=$1;;
+ esac
+ shift;
+done
+
+AUTHOPT="-a $AUTHSYS"
+[ -z "$AUTHSYS" ] && AUTHOPT=""
+
+monitor -TN -h $PGHOST -p $PGPORT -c "drop database $dbname" template1
+
+if [ $? -ne 0 ]
+then
+ echo "$CMDNAME: database destroy failed on $dbname."
+ exit 1
+fi
+
+exit 0
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for bin/destroyuser
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/bin/destroyuser/Attic/Makefile,v 1.1.1.1 1996/07/09 06:22:12 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SHPROG= destroyuser
+
+MKDIR= ../../mk
+include $(MKDIR)/postgres.mk
+include ../Makefile.global
+
+include $(MKDIR)/postgres.shell.mk
+
--- /dev/null
+#!/bin/sh
+#-------------------------------------------------------------------------
+#
+# destroyuser.sh--
+# utility for destroying a user from the POSTGRES database.
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/bin/destroyuser/Attic/destroyuser.sh,v 1.1.1.1 1996/07/09 06:22:12 scrappy Exp $
+#
+# Note - this should NOT be setuid.
+#
+#-------------------------------------------------------------------------
+
+# ----------------
+# Set paths from environment or default values.
+# The _fUnKy_..._sTuFf_ gets set when the script is installed
+# from the default value for this build.
+# Currently the only thing we look for from the environment is
+# PGDATA, PGHOST, and PGPORT
+#
+# ----------------
+[ -z "$PGPORT" ] && PGPORT=5432
+[ -z "$PGHOST" ] && PGHOST=localhost
+BINDIR=_fUnKy_BINDIR_sTuFf_
+PATH=$BINDIR:$PATH
+
+CMDNAME=`basename $0`
+
+if [ -z "$USER" ]; then
+ if [ -z "$LOGNAME" ]; then
+ if [ -z "`whoami`" ]; then
+ echo "$CMDNAME: cannot determine user name"
+ exit 1
+ fi
+ else
+ USER=$LOGNAME
+ export USER
+ fi
+fi
+
+while (test -n "$1")
+do
+ case $1 in
+ -a) AUTHSYS=$2; shift;;
+ -h) PGHOST=$2; shift;;
+ -p) PGPORT=$2; shift;;
+ *) DELUSER=$1;;
+ esac
+ shift;
+done
+
+AUTHOPT="-a $AUTHSYS"
+[ -z "$AUTHSYS" ] && AUTHOPT=""
+
+MARGS="-TN $AUTHOPT -p $PGPORT -h $PGHOST"
+
+#
+# generate the first part of the actual monitor command
+#
+MONITOR="monitor $MARGS"
+
+#
+# see if user $USER is allowed to create new users. Only a user who can
+# create users can delete them.
+#
+
+QUERY="select usesuper from pg_user where usename = '$USER'"
+ADDUSER=`$MONITOR -c "$QUERY" template1`
+
+if [ $? -ne 0 ]
+then
+ echo "$CMDNAME: database access failed."
+ exit 1
+fi
+
+if [ $ADDUSER != "t" ]
+then
+ echo "$CMDNAME: $USER cannot delete users."
+fi
+
+#
+# get the user name of the user to delete. Make sure it exists.
+#
+
+if [ -z "$DELUSER" ]
+then
+ echo _fUnKy_DASH_N_sTuFf_ "Enter name of user to delete ---> "_fUnKy_BACKSLASH_C_sTuFf_
+ read DELUSER
+fi
+
+QUERY="select usesysid from pg_user where usename = '$DELUSER'"
+
+RES=`$MONITOR -c "$QUERY" template1`
+
+if [ $? -ne 0 ]
+then
+ echo "$CMDNAME: database access failed."
+ exit 1
+fi
+
+if [ ! -n "$RES" ]
+then
+ echo "$CMDNAME: user "\"$DELUSER\"" does not exist."
+ exit 1
+fi
+
+SYSID=`echo $RES | sed 's/ //g'`
+
+#
+# destroy the databases owned by the deleted user. First, use this query
+# to find out what they are.
+#
+
+QUERY="select datname from pg_database where datdba = '$SYSID'::oid"
+
+
+ALLDBS=`$MONITOR -c "$QUERY" template1`
+
+if [ $? -ne 0 ]
+then
+ echo "$CMDNAME: database access failed - exiting..."
+ exit 1
+fi
+
+
+#
+# don't try to delete template1!
+#
+
+for i in $ALLDBS
+do
+ if [ $i != "template1" ]
+ then
+ DBLIST="$DBLIST $i"
+ fi
+done
+
+if [ -n "$DBLIST" ]
+then
+ echo "User $DELUSER owned the following databases:"
+ echo $DBLIST
+ echo
+
+#
+# Now we warn the DBA that deleting this user will destroy a bunch of databases
+#
+
+ yn=f
+ while [ $yn != y -a $yn != n ]
+ do
+ echo _fUnKy_DASH_N_sTuFf_ "Deleting user $DELUSER will destroy them. Continue (y/n)? "_fUnKy_BACKSLASH_C_sTuFf_
+ read yn
+ done
+
+ if [ $yn = n ]
+ then
+ echo "$CMDNAME: exiting"
+ exit 1
+ fi
+
+ #
+ # now actually destroy the databases
+ #
+
+ for i in $DBLIST
+ do
+ echo "destroying database $i"
+
+ QUERY="drop database $i"
+ $MONITOR -c "$QUERY" template1
+ if [ $? -ne 0 ]
+ then
+ echo "$CMDNAME: drop database on $i failed - exiting"
+ exit 1
+ fi
+ done
+fi
+
+QUERY="delete from pg_user where usename = '$DELUSER'"
+
+$MONITOR -c "$QUERY" template1
+if [ $? -ne 0 ]
+then
+ echo "$CMDNAME: delete of user $DELUSER was UNSUCCESSFUL"
+else
+ echo "$CMDNAME: delete of user $DELUSER was successful."
+fi
+
+exit 0
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for bin/initdb
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/bin/initdb/Makefile,v 1.1.1.1 1996/07/09 06:22:13 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SHPROG= initdb
+
+MKDIR= ../../mk
+include $(MKDIR)/postgres.mk
+include ../Makefile.global
+
+include $(MKDIR)/postgres.shell.mk
+
--- /dev/null
+#!/bin/sh
+#-------------------------------------------------------------------------
+#
+# initdb.sh--
+# create a postgres template database
+#
+# this program feeds the proper input to the ``postgres'' program
+# to create a postgres database and register it in the
+# shared ``pg_database'' database.
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/bin/initdb/Attic/initdb.sh,v 1.1.1.1 1996/07/09 06:22:13 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+# ----------------
+# Set paths from environment or default values.
+# The _fUnKy_..._sTuFf_ gets set when the script is installed
+# from the default value for this build.
+# Currently the only thing wee look for from the environment is
+# PGDATA, PGHOST, and PGPORT
+#
+# ----------------
+[ -z "$PGDATA" ] && { PGDATA=_fUnKy_DATADIR_sTuFf_; export PGDATA; }
+[ -z "$PGPORT" ] && { PGPORT=5432; export PGPORT; }
+[ -z "$PGHOST" ] && { PGHOST=localhost; export PGHOST; }
+POSTGRESDIR=_fUnKy_POSTGRESDIR_sTuFf_
+BINDIR=_fUnKy_BINDIR_sTuFf_
+FILESDIR=$PGDATA/files
+PATH=$BINDIR:$PATH
+export PATH
+
+CMDNAME=`basename $0`
+
+# ----------------
+# check arguments:
+# -d indicates debug mode.
+# -n means don't clean up on error (so your cores don't go away)
+# ----------------
+debug=0
+noclean=0
+verbose=0
+
+for ARG
+do
+ case "$ARG" in
+ -d) debug=1; echo "$CMDNAME: debug mode on";;
+ -n) noclean=1; echo "$CMDNAME: noclean mode on";;
+ -v) verbose=1; echo "$CMDNAME: verbose mode on";;
+ *) echo "initdb [-d][-n][-v]\n -d : debug mode\n -n : noclean mode, leaves temp files around \n -v : verbose mode"; exit 0;
+ esac
+done
+
+# ----------------
+# if the debug flag is set, then
+# ----------------
+if test "$debug" -eq 1
+then
+ BACKENDARGS="-boot -C -d"
+else
+ BACKENDARGS="-boot -C -Q"
+fi
+
+
+TEMPLATE=$FILESDIR/local1_template1.bki
+GLOBAL=$FILESDIR/global1.bki
+if [ ! -f $TEMPLATE -o ! -f $GLOBAL ]
+then
+ echo "$CMDNAME: error: database initialization files not found."
+ echo "$CMDNAME: either gmake install has not been run or you're trying to"
+ echo "$CMDNAME: run this program on a machine that does not store the"
+ echo "$CMDNAME: database (PGHOST doesn't work for this)."
+ exit 1
+fi
+
+if test "$verbose" -eq 1
+then
+ echo "$CMDNAME: using $TEMPLATE"
+ echo "$CMDNAME: using $GLOBAL"
+fi
+
+#
+# Figure out who I am...
+#
+
+PG_UID=`pg_id`
+
+if test $PG_UID -eq 0
+then
+ echo "$CMDNAME: do not install POSTGRES as root"
+ exit 1
+fi
+
+# ----------------
+# create the template database if necessary
+# the first we do is create data/base, so we'll check for that.
+# ----------------
+
+if test -d "$PGDATA/base"
+then
+ echo "$CMDNAME: error: it looks like initdb has already been run. You must"
+ echo "clean out the database directory first with the cleardbdir program"
+ exit 1
+fi
+
+# umask must disallow access to group, other for files and dirs
+umask 077
+
+mkdir $PGDATA/base $PGDATA/base/template1
+
+if test "$verbose" -eq 1
+then
+ echo "$CMDNAME: creating SHARED relations in $PGDATA"
+ echo "$CMDNAME: creating template database in $PGDATA/base/template1"
+ echo "postgres $BACKENDARGS template1 < $TEMPLATE "
+fi
+
+postgres $BACKENDARGS template1 < $TEMPLATE
+
+
+if test $? -ne 0
+then
+ echo "$CMDNAME: could not create template database"
+ if test $noclean -eq 0
+ then
+ echo "$CMDNAME: cleaning up."
+ cd $PGDATA
+ for i in *
+ do
+ if [ $i != "files" -a $i != "pg_hba" ]
+ then
+ /bin/rm -rf $i
+ fi
+ done
+ else
+ echo "$CMDNAME: cleanup not done (noclean mode set)."
+ fi
+ exit 1;
+fi
+
+pg_version $PGDATA/base/template1
+
+#
+# Add the template database to pg_database
+#
+
+echo "open pg_database" > /tmp/create.$$
+echo "insert (template1 $PG_UID template1)" >> /tmp/create.$$
+#echo "show" >> /tmp/create.$$
+echo "close pg_database" >> /tmp/create.$$
+
+if test "$verbose" -eq 1
+then
+ echo "postgres $BACKENDARGS template1 < $GLOBAL"
+fi
+
+postgres $BACKENDARGS template1 < $GLOBAL
+
+if (test $? -ne 0)
+then
+ echo "$CMDNAME: could create shared relations"
+ if (test $noclean -eq 0)
+ then
+ echo "$CMDNAME: cleaning up."
+ cd $PGDATA
+ for i in *
+ do
+ if [ $i != "files" ]
+ then
+ /bin/rm -rf $i
+ fi
+ done
+ else
+ echo "$CMDNAME: cleanup not done (noclean mode set)."
+ fi
+ exit 1;
+fi
+
+pg_version $PGDATA
+
+if test "$verbose" -eq 1
+then
+ echo "postgres $BACKENDARGS template1 < /tmp/create.$$"
+fi
+
+postgres $BACKENDARGS template1 < /tmp/create.$$
+
+if test $? -ne 0
+then
+ echo "$CMDNAME: could not log template database"
+ if (test $noclean -eq 0)
+ then
+ echo "$CMDNAME: cleaning up."
+ cd $PGDATA
+ for i in *
+ do
+ if [ $i != "files" ]
+ then
+ /bin/rm -rf $i
+ fi
+ done
+ else
+ echo "$CMDNAME: cleanup not done (noclean mode set)."
+ fi
+ exit 1;
+fi
+
+if test $debug -eq 0
+then
+
+if test "$verbose" -eq 1
+then
+ echo "vacuuming template1"
+fi
+
+ echo "vacuum" | postgres -Q template1 > /dev/null
+fi
+
+rm -f /tmp/create.$$
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for bin/initdb
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/bin/ipcclean/Attic/Makefile,v 1.1.1.1 1996/07/09 06:22:13 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+SHPROG= ipcclean
+
+MKDIR= ../../mk
+include $(MKDIR)/postgres.mk
+include ../Makefile.global
+
+include $(MKDIR)/postgres.shell.mk
+
--- /dev/null
+#!/bin/sh
+#
+# $Header: /cvsroot/pgsql/src/bin/ipcclean/Attic/ipcclean.sh,v 1.1.1.1 1996/07/09 06:22:13 scrappy Exp $
+#
+PATH=_fUnKy_IPCCLEANPATH_sTuFf_:$PATH
+export PATH
+ipcs | egrep '^m .*|^s .*' | egrep "`whoami`|postgres" | \
+awk '{printf "ipcrm -%s %s\n", $1, $2}' '-' | sh
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile.inc--
+# Makefile for bin/monitor
+#
+# Copyright (c) 1994, Regents of the University of California
+#
+#
+# IDENTIFICATION
+# $Header: /cvsroot/pgsql/src/bin/monitor/Attic/Makefile,v 1.1.1.1 1996/07/09 06:22:13 scrappy Exp $
+#
+#-------------------------------------------------------------------------
+
+PROG= monitor
+
+MKDIR= ../../mk
+include $(MKDIR)/postgres.mk
+include ../Makefile.global
+
+SRCS= monitor.c
+
+include $(MKDIR)/postgres.prog.mk
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * monitor.c--
+ * POSTGRES Terminal Monitor
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/bin/monitor/Attic/monitor.c,v 1.1.1.1 1996/07/09 06:22:13 scrappy Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include
+#include "libpq/pqsignal.h" /* substitute for */
+#include
+#include
+#include
+#include /* for MAXHOSTNAMELEN on most */
+#ifndef WIN32
+#include
+#endif
+#ifdef PORTNAME_sparc_solaris
+#include /* for MAXHOSTNAMELEN on some */
+#endif
+#include
+/* #include */
+#include
+
+#include "libpq-fe.h"
+#include "libpq/libpq-fs.h"
+
+extern char *getenv();
+
+/*
+ * monitor.c -- function prototypes (all private)
+ */
+static void do_input(FILE *ifp);
+static void init_tmon();
+static void welcome();
+static void handle_editor();
+static void handle_shell();
+static void handle_send();
+static int handle_execution(char *query);
+static void handle_file_insert(FILE *ifp);
+static void handle_print();
+static void handle_exit(int exit_status);
+static void handle_clear();
+static void handle_print_time();
+static int handle_write_to_file();
+static void handle_help();
+static void stuff_buffer(char c);
+static void argsetup(int *argcP, char ***argvP);
+static void handle_copy_out(PGresult *res);
+static void handle_copy_in(PGresult *res);
+
+
+/*
+ * Functions which maintain the logical query buffer in
+ * /tmp/PQxxxxx. It in general just does a copy from input
+ * to query buffer, unless it gets a backslash escape character.
+ * It recognizes the following escapes:
+ *
+ * \e -- enter editor
+ * \g -- "GO": submit query to POSTGRES
+ * \i -- include (switch input to external file)
+ * \p -- print query buffer
+ * \q -- quit POSTGRES
+ * \r -- force reset (clear) of query buffer
+ * \s -- call shell
+ * \t -- print current time
+ * \w -- write query buffer to external file
+ * \h -- print the list of commands
+ * \? -- print the list of commands
+ * \\ -- produce a single backslash in query buffer
+ *
+ */
+
+/*
+ * Declaration of global variables (but only to the file monitor.c
+ */
+
+#define DEFAULT_EDITOR "/usr/ucb/vi"
+#define COPYBUFSIZ 8192
+static char *user_editor; /* user's desired editor */
+static int tmon_temp; /* file descriptor for temp. buffer file */
+static char *tmon_temp_filename;
+static char query_buffer[8192]; /* Max postgres buffer size */
+static char *RunOneFile = NULL;
+bool RunOneCommand = false;
+bool Debugging;
+bool Verbose;
+bool Silent;
+bool TerseOutput = false;
+bool PrintAttNames = true;
+bool SingleStepMode = false;
+bool SemicolonIsGo = true;
+
+#define COLWIDTH 12
+
+extern char *optarg;
+extern int optind,opterr;
+FILE *debug_port;
+
+/*
+ * As of release 4, we allow the user to specify options in the environment
+ * variable PGOPTION. These are treated as command-line options to the
+ * terminal monitor, and are parsed before the actual command-line args.
+ * The arge struct is used to construct an argv we can pass to getopt()
+ * containing the union of the environment and command line arguments.
+ */
+
+typedef struct arge {
+ char *a_arg;
+ struct arge *a_next;
+} arge;
+
+/* the connection to the backend */
+PGconn *conn;
+
+void
+main(int argc, char **argv)
+{
+ int c;
+ int errflag = 0;
+ char *progname;
+ char *debug_file;
+ char *dbname;
+ char *command;
+ int exit_status = 0;
+ char errbuf[ERROR_MSG_LENGTH];
+ char *username, usernamebuf[NAMEDATALEN + 1];
+
+ char *pghost = NULL;
+ char *pgtty = NULL;
+ char *pgoptions = NULL;
+ char *pgport = NULL;
+ int pgtracep = 0;
+
+ /*
+ * Processing command line arguments.
+ *
+ * h : sets the hostname.
+ * p : sets the coom. port
+ * t : sets the tty.
+ * o : sets the other options. (see doc/libpq)
+ * d : enable debugging mode.
+ * q : run in quiet mode
+ * Q : run in VERY quiet mode (no output except on errors)
+ * c : monitor will run one POSTQUEL command and exit
+ *
+ * s : step mode (pauses after each command)
+ * S : don't use semi colon as \g
+ *
+ * T : terse mode - no formatting
+ * N : no attribute names - only columns of data
+ * (these two options are useful in conjunction with the "-c" option
+ * in scripts.)
+ */
+
+ progname = *argv;
+ Debugging = false;
+ Verbose = true;
+ Silent = false;
+
+ /* prepend PGOPTION, if any */
+ argsetup(&argc, &argv);
+
+ while ((c = getopt(argc, argv, "a:h:f:p:t:d:qsSTNQc:")) != EOF) {
+ switch (c) {
+ case 'a':
+ fe_setauthsvc(optarg, errbuf);
+ break;
+ case 'h' :
+ pghost = optarg;
+ break;
+ case 'f' :
+ RunOneFile = optarg;
+ break;
+ case 'p' :
+ pgport = optarg;
+ break;
+ case 't' :
+ pgtty = optarg;
+ break;
+ case 'T' :
+ TerseOutput = true;
+ break;
+ case 'N' :
+ PrintAttNames = false;
+ break;
+ case 'd' :
+
+ /*
+ * When debugging is turned on, the debugging messages
+ * will be sent to the specified debug file, which
+ * can be a tty ..
+ */
+
+ Debugging = true;
+ debug_file = optarg;
+ debug_port = fopen(debug_file,"w+");
+ if (debug_port == NULL) {
+ fprintf(stderr,"Unable to open debug file %s \n", debug_file);
+ exit(1);
+ }
+ pgtracep = 1;
+ break;
+ case 'q' :
+ Verbose = false;
+ break;
+ case 's' :
+ SingleStepMode = true;
+ SemicolonIsGo = true;
+ break;
+ case 'S' :
+ SemicolonIsGo = false;
+ break;
+ case 'Q' :
+ Verbose = false;
+ Silent = true;
+ break;
+ case 'c' :
+ Verbose = false;
+ Silent = true;
+ RunOneCommand = true;
+ command = optarg;
+ break;
+ case '?' :
+ default :
+ errflag++;
+ break;
+ }
+ }
+
+ if (errflag ) {
+ fprintf(stderr, "usage: %s [options...] [dbname]\n", progname);
+ fprintf(stderr, "\t-a authsvc\tset authentication service\n");
+ fprintf(stderr, "\t-c command\t\texecute one command\n");
+ fprintf(stderr, "\t-d debugfile\t\tdebugging output file\n");
+ fprintf(stderr, "\t-h host\t\t\tserver host name\n");
+ fprintf(stderr, "\t-f file\t\t\trun query from file\n");
+ fprintf(stderr, "\t-p port\t\t\tserver port number\n");
+ fprintf(stderr, "\t-q\t\t\tquiet output\n");
+ fprintf(stderr, "\t-t logfile\t\terror-logging tty\n");
+ fprintf(stderr, "\t-N\t\t\toutput without attribute names\n");
+ fprintf(stderr, "\t-Q\t\t\tREALLY quiet output\n");
+ fprintf(stderr, "\t-T\t\t\tterse output\n");
+ exit(2);
+ }
+
+ /* Determine our username (according to the authentication system, if
+ * there is one).
+ */
+ if ((username = fe_getauthname(errbuf)) == (char *) NULL) {
+ fprintf(stderr, "%s: could not find a valid user name\n",
+ progname);
+ exit(2);
+ }
+ memset(usernamebuf, 0, sizeof(usernamebuf));
+ (void) strncpy(usernamebuf, username, NAMEDATALEN);
+ username = usernamebuf;
+
+ /* find database */
+ if (!(dbname = argv[optind]) &&
+ !(dbname = getenv("DATABASE")) &&
+ !(dbname = username)) {
+ fprintf(stderr, "%s: no database name specified\n", progname);
+ exit (2);
+ }
+
+ conn = PQsetdb(pghost, pgport, pgoptions, pgtty, dbname);
+ if (PQstatus(conn) == CONNECTION_BAD) {
+ fprintf(stderr,"Connection to database '%s' failed.\n", dbname);
+ fprintf(stderr,"%s",PQerrorMessage(conn));
+ exit(1);
+ }
+
+ if (pgtracep)
+ PQtrace(conn,debug_port);
+
+ /* print out welcome message and start up */
+ welcome();
+ init_tmon();
+
+ /* parse input */
+ if (RunOneCommand) {
+ exit_status = handle_execution(command);
+ } else if (RunOneFile) {
+ bool oldVerbose;
+ FILE *ifp;
+
+ if ((ifp = fopen(RunOneFile, "r")) == NULL) {
+ fprintf(stderr, "Cannot open %s\n", RunOneFile);
+ }
+
+ if (SingleStepMode) {
+ oldVerbose = Verbose;
+ Verbose = false;
+ }
+ do_input(ifp);
+ fclose(ifp);
+ if (SingleStepMode)
+ Verbose = oldVerbose;
+ } else {
+ do_input(stdin);
+ }
+
+ handle_exit(exit_status);
+}
+
+static void
+do_input(FILE *ifp)
+{
+ int c;
+ char escape;
+
+ /*
+ * Processing user input.
+ * Basically we stuff the user input to a temp. file until
+ * an escape char. is detected, after which we switch
+ * to the appropriate routine to handle the escape.
+ */
+
+ if (ifp == stdin) {
+ if (Verbose)
+ fprintf(stdout,"\nGo \n* ");
+ else {
+ if (!Silent)
+ fprintf(stdout, "* ");
+ }
+ }
+ while ((c = getc(ifp)) != EOF ) {
+ if ( c == '\\') {
+ /* handle escapes */
+ escape = getc(ifp);
+ switch( escape ) {
+ case 'e':
+ handle_editor();
+ break;
+ case 'g':
+ handle_send();
+ break;
+ case 'i':
+ {
+ bool oldVerbose;
+
+ if (SingleStepMode) {
+ oldVerbose = Verbose;
+ Verbose = false;
+ }
+ handle_file_insert(ifp);
+ if (SingleStepMode)
+ Verbose = oldVerbose;
+ }
+ break;
+ case 'p':
+ handle_print();
+ break;
+ case 'q':
+ handle_exit(0);
+ break;
+ case 'r':
+ handle_clear();
+ break;
+ case 's':
+ handle_shell();
+ break;
+ case 't':
+ handle_print_time();
+ break;
+ case 'w':
+ handle_write_to_file();
+ break;
+ case '?':
+ case 'h':
+ handle_help();
+ break;
+ case '\\':
+ c = escape;
+ stuff_buffer(c);
+ break;
+ case ';':
+ c = escape;
+ stuff_buffer(c);
+ break;
+ default:
+ fprintf(stderr, "unknown escape given\n");
+ break;
+ } /* end-of-switch */
+ if (ifp == stdin && escape != '\\') {
+ if (Verbose)
+ fprintf(stdout,"\nGo \n* ");
+ else {
+ if (!Silent)
+ fprintf(stdout, "* ");
+ }
+ }
+ } else {
+ stuff_buffer(c);
+ if (c == ';' && SemicolonIsGo) {
+ handle_send();
+ if (Verbose)
+ fprintf(stdout,"\nGo \n* ");
+ else {
+ if (!Silent)
+ fprintf(stdout, "* ");
+ }
+ }
+ }
+ }
+}
+
+/*
+ * init_tmon()
+ *
+ * set the following :
+ * user_editor, defaults to DEFAULT_EDITOR if env var is not set
+ */
+static void
+init_tmon()
+{
+ if (!RunOneCommand)
+ {
+ char *temp_editor = getenv("EDITOR");
+
+ if (temp_editor != NULL)
+ user_editor = temp_editor;
+ else
+ user_editor = DEFAULT_EDITOR;
+
+ tmon_temp_filename = malloc(20);
+ sprintf(tmon_temp_filename, "/tmp/PQ%d", getpid());
+ tmon_temp = open(tmon_temp_filename,O_CREAT | O_RDWR | O_APPEND,0666);
+ }
+
+ /*
+ * Catch signals so we can delete the scratch file GK
+ * but only if we aren't already ignoring them -mer
+ */
+
+#ifndef WIN32
+ if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
+ signal(SIGHUP, handle_exit);
+ if (signal(SIGQUIT, SIG_IGN) != SIG_IGN)
+ signal(SIGQUIT, handle_exit);
+#endif /* WIN32 we'll have to figure out how to handle these */
+ if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
+ signal(SIGTERM, handle_exit);
+ if (signal(SIGINT, SIG_IGN) != SIG_IGN)
+ signal(SIGINT, handle_exit);
+}
+
+/*
+ * welcome simply prints the Postgres welcome mesg.
+ */
+static
+void welcome()
+{
+ if (Verbose) {
+ fprintf(stdout,"Welcome to the POSTGRES95 terminal monitor\n");
+ fprintf(stdout," Please read the file COPYRIGHT for copyright terms of POSTGRES95\n");
+ }
+}
+
+
+/*
+ * handle_editor()
+ *
+ * puts the user into edit mode using the editor specified
+ * by the variable "user_editor".
+ */
+static void
+handle_editor()
+{
+ char edit_line[100];
+
+ close(tmon_temp);
+ sprintf(edit_line,"%s %s",user_editor,tmon_temp_filename);
+ system(edit_line);
+ tmon_temp = open(tmon_temp_filename,O_CREAT | O_RDWR | O_APPEND,0666);
+}
+
+static void
+handle_shell()
+{
+ char *user_shell;
+
+ user_shell = getenv("SHELL");
+ if (user_shell != NULL) {
+ system(user_shell);
+ } else {
+ system("/bin/sh");
+ }
+}
+
+/*
+ * handle_send()
+ *
+ * This is the routine that initialises the comm. with the
+ * backend. After the tuples have been returned and
+ * displayed, the query_buffer is cleared for the
+ * next query.
+ *
+ */
+
+#include
+
+static void
+handle_send()
+{
+ char c = (char)0;
+ off_t pos;
+ int cc = 0;
+ int i = 0;
+
+ pos = lseek(tmon_temp, (off_t) 0, SEEK_SET);
+
+ if (pos != 0)
+ fprintf(stderr, "Bogus file position\n");
+
+ if (Verbose)
+ printf("\n");
+
+ /* discard leading white space */
+ while ( ( cc = read(tmon_temp,&c,1) ) != 0 && isspace((int)c))
+ continue;
+
+ if ( cc != 0 ) {
+ pos = lseek(tmon_temp, (off_t) -1, SEEK_CUR);
+ }
+
+ if (SingleStepMode) {
+ char buf[1024];
+ fprintf(stdout, "\n*******************************************************************************\n");
+ while ((cc = read(tmon_temp,buf,1024))>0) {
+ buf[cc] = '\0';
+ fprintf(stdout, "%s", buf);
+ }
+ fprintf(stdout, "\n*******************************************************************************\n\n");
+ (void)lseek(tmon_temp, (off_t)pos, SEEK_SET);
+ }
+
+ query_buffer[0] = 0;
+
+ /*
+ * Stripping out comments (if any) from the query (should really be
+ * handled in the parser, of course).
+ */
+ while ( ( cc = read(tmon_temp,&c,1) ) != 0) {
+ switch(c) {
+ case '\n':
+ query_buffer[i++] = ' ';
+ break;
+ case '-': {
+ int temp;
+ char temp_c;
+ if ((temp = read(tmon_temp,&temp_c,1)) > 0) {
+ if (temp_c == '-' ) {
+ /* read till end of line */
+ while ((temp = read(tmon_temp,&temp_c,1)) != 0) {
+ if (temp_c=='\n')
+ break;
+ }
+ }else {
+ query_buffer[i++] = c;
+ query_buffer[i++] = temp_c;
+ }
+ } else {
+ query_buffer[i++] = c;
+ }
+ break;
+ }
+ case '$': {
+ int temp;
+ char temp_c[4];
+ /*
+ * monitor feature, not POSTGRES SQL. When monitor sees $PWD,
+ * it will substitute in the current directory.
+ */
+ if ((temp = read(tmon_temp,temp_c,3)) > 0) {
+ temp_c[temp] = '\0';
+ if (!strncmp(temp_c, "PWD", 3)) {
+ int len;
+ char cwdPath[MAXPATHLEN];
+ if (getcwd(cwdPath, MAXPATHLEN)==NULL) {
+ fprintf(stderr,
+ "cannot get current working directory\n");
+ break;
+ }
+ len = strlen(cwdPath);
+ query_buffer[i] = '\0';
+ strcat(query_buffer, cwdPath);
+ i += len;
+ } else {
+ int j;
+ query_buffer[i++] = c;
+ for(j = 0; j < temp; j++) {
+ query_buffer[i++] = temp_c[j];
+ }
+ }
+ } else {
+ query_buffer[i++] = c;
+ }
+ break;
+ }
+ default:
+ query_buffer[i++] = c;
+ break;
+ }
+ }
+
+ if (query_buffer[0] == 0) {
+ query_buffer[0] = ' ';
+ query_buffer[1] = 0;
+ }
+
+ if (Verbose && !SingleStepMode)
+ fprintf(stdout,"Query sent to backend is \"%s\"\n", query_buffer);
+
+ fflush(stderr);
+ fflush(stdout);
+
+ /*
+ * Repeat commands until done.
+ */
+
+ handle_execution(query_buffer);
+
+ /* clear the query buffer and temp file -- this is very expensive */
+ handle_clear();
+ memset(query_buffer,0,i);
+}
+
+/*
+ * Actually execute the query in *query.
+ *
+ * Returns 0 if the query finished successfully, 1 otherwise.
+ */
+static int
+handle_execution(char *query)
+{
+ PGresult *result;
+ int retval = 0;
+
+ result = PQexec(conn, query);
+
+ if (result == NULL) {
+ fprintf(stderr,"%s", PQerrorMessage(conn));
+ return 1;
+ }
+
+ switch (PQresultStatus(result)) {
+ case PGRES_EMPTY_QUERY:
+ break;
+ case PGRES_COMMAND_OK:
+ break;
+ case PGRES_TUPLES_OK:
+/* PQprintTuples(result,stdout,PrintAttNames,TerseOutput,COLWIDTH); */
+ if (TerseOutput)
+ PQdisplayTuples(result,stdout,1,"",PrintAttNames,TerseOutput);
+ else
+ PQdisplayTuples(result,stdout,1,"|",PrintAttNames,TerseOutput);
+ break;
+ case PGRES_COPY_OUT:
+ handle_copy_out(result);
+ break;
+ case PGRES_COPY_IN:
+ handle_copy_in(result);
+ break;
+ case PGRES_BAD_RESPONSE:
+ retval = 1;
+ break;
+ case PGRES_NONFATAL_ERROR:
+ retval = 1;
+ break;
+ case PGRES_FATAL_ERROR:
+ retval = 1;
+ break;
+ }
+
+ if (SingleStepMode) {
+ fflush(stdin);
+ printf("\npress return to continue ...\n");
+ getc(stdin); /* assume stdin is not a file! */
+ }
+ return(retval);
+}
+
+/*
+ * handle_file_insert()
+ *
+ * allows the user to insert a query file and execute it.
+ * NOTE: right now the full path name must be specified.
+ */
+static void
+handle_file_insert(FILE *ifp)
+{
+ char user_filename[50];
+ FILE *nifp;
+
+ fscanf(ifp, "%s",user_filename);
+ nifp = fopen(user_filename, "r");
+ if (nifp == (FILE *) NULL) {
+ fprintf(stderr, "Cannot open %s\n", user_filename);
+ } else {
+ do_input(nifp);
+ fclose (nifp);
+ }
+}
+
+/*
+ * handle_print()
+ *
+ * This routine prints out the contents (query) of the temp. file
+ * onto stdout.
+ */
+static void
+handle_print()
+{
+ char c;
+ off_t pos;
+ int cc;
+
+ pos = lseek(tmon_temp, (off_t) 0, SEEK_SET);
+
+ if (pos != 0 )
+ fprintf(stderr, "Bogus file position\n");
+
+ printf("\n");
+
+ while ( ( cc = read(tmon_temp,&c,1) ) != 0)
+ putchar(c);
+
+ printf("\n");
+}
+
+
+/*
+ * handle_exit()
+ *
+ * ends the comm. with the backend and exit the tm.
+ */
+static void
+handle_exit(int exit_status)
+{
+ if (!RunOneCommand) {
+ close(tmon_temp);
+ unlink(tmon_temp_filename);
+ }
+ PQfinish(conn);
+ exit(exit_status);
+}
+
+/*
+ * handle_clear()
+ *
+ * This routine clears the temp. file.
+ */
+static void
+handle_clear()
+{
+ /* high cost */
+ close(tmon_temp);
+ tmon_temp = open(tmon_temp_filename,O_TRUNC|O_RDWR|O_CREAT ,0666);
+}
+
+/*
+ * handle_print_time()
+ * prints out the date using the "date" command.
+ */
+static void
+handle_print_time()
+{
+ system("date");
+}
+
+/*
+ * handle_write_to_file()
+ *
+ * writes the contents of the temp. file to the
+ * specified file.
+ */
+static int
+handle_write_to_file()
+{
+ char filename[50];
+ static char command_line[512];
+ int status;
+
+ status = scanf("%s", filename);
+ if (status < 1 || !filename[0]) {
+ fprintf(stderr, "error: filename is empty\n");
+ return(-1);
+ }
+
+ /* XXX portable way to check return status? $%&! ultrix ... */
+ (void) sprintf(command_line, "rm -f %s", filename);
+ (void) system(command_line);
+ (void) sprintf(command_line, "cp %s %s", tmon_temp_filename, filename);
+ (void) system(command_line);
+
+ return(0);
+}
+
+/*
+ *
+ * Prints out a help message.
+ *
+ */
+static void
+handle_help()
+{
+ printf("Available commands include \n\n");
+ printf("\\e -- enter editor\n");
+ printf("\\g -- \"GO\": submit query to POSTGRES\n");
+ printf("\\i -- include (switch input to external file)\n");
+ printf("\\p -- print query buffer\n");
+ printf("\\q -- quit POSTGRES\n");
+ printf("\\r -- force reset (clear) of query buffer\n");
+ printf("\\s -- shell escape \n");
+ printf("\\t -- print current time\n");
+ printf("\\w -- write query buffer to external file\n");
+ printf("\\h -- print the list of commands\n");
+ printf("\\? -- print the list of commands\n");
+ printf("\\\\ -- produce a single backslash in query buffer\n");
+ fflush(stdin);
+}
+
+/*
+ * stuff_buffer()
+ *
+ * writes the user input into the temp. file.
+ */
+static void
+stuff_buffer(char c)
+{
+ int cc;
+
+ cc = write(tmon_temp,&c,1);
+
+ if(cc == -1)
+ fprintf(stderr, "error writing to temp file\n");
+}
+
+static void
+argsetup(int *argcP, char ***argvP)
+{
+ int argc;
+ char **argv, **curarg;
+ char *eopts;
+ char *envopts;
+ int neopts;
+ char *start, *end;
+ arge *head, *tail, *cur;
+
+ /* if no options specified in environment, we're done */
+ if ((envopts = getenv("PGOPTION")) == (char *) NULL)
+ return;
+
+ if ((eopts = (char *) malloc(strlen(envopts) + 1)) == (char *) NULL) {
+ fprintf(stderr, "cannot malloc copy space for PGOPTION\n");
+ fflush(stderr);
+ exit (2);
+ }
+
+ (void) strcpy(eopts, envopts);
+
+ /*
+ * okay, we have PGOPTION from the environment, and we want to treat
+ * them as user-specified options. to do this, we construct a new
+ * argv that has argv[0] followed by the arguments from the environment
+ * followed by the arguments on the command line.
+ */
+
+ head = cur = (arge *) NULL;
+ neopts = 0;
+
+ for (;;) {
+ while (isspace(*eopts) && *eopts)
+ eopts++;
+
+ if (*eopts == '\0')
+ break;
+
+ if ((cur = (arge *) malloc(sizeof(arge))) == (arge *) NULL) {
+ fprintf(stderr, "cannot malloc space for arge\n");
+ fflush(stderr);
+ exit (2);
+ }
+
+ end = start = eopts;
+
+ if (*start == '"') {
+ start++;
+ while (*++end != '\0' && *end != '"')
+ continue;
+ if (*end == '\0') {
+ fprintf(stderr, "unterminated string constant in env var PGOPTION\n");
+ fflush(stderr);
+ exit (2);
+ }
+ eopts = end + 1;
+ } else if (*start == '\'') {
+ start++;
+ while (*++end != '\0' && *end != '\'')
+ continue;
+ if (*end == '\0') {
+ fprintf(stderr, "unterminated string constant in env var PGOPTION\n");
+ fflush(stderr);
+ exit (2);
+ }
+ eopts = end + 1;
+ } else {
+ while (!isspace(*end) && *end)
+ end++;
+ if (isspace(*end))
+ eopts = end + 1;
+ else
+ eopts = end;
+ }
+
+ if (head == (arge *) NULL) {
+ head = tail = cur;
+ } else {
+ tail->a_next = cur;
+ tail = cur;
+ }
+
+ cur->a_arg = start;
+ cur->a_next = (arge *) NULL;
+
+ *end = '\0';
+ neopts++;
+ }
+
+ argc = *argcP + neopts;
+
+ if ((argv = (char **) malloc(argc * sizeof(char *))) == (char **) NULL) {
+ fprintf(stderr, "can't malloc space for modified argv\n");
+ fflush(stderr);
+ exit (2);
+ }
+
+ curarg = argv;
+ *curarg++ = *(*argvP)++;
+
+ /* copy env args */
+ while (head != (arge *) NULL) {
+ cur = head;
+ *curarg++ = head->a_arg;
+ head = head->a_next;
+ free(cur);
+ }
+
+ /* copy rest of args from command line */
+ while (--(*argcP))
+ *curarg++ = *(*argvP)++;
+
+ /* all done */
+ *argvP = argv;
+ *argcP = argc;
+}
+
+static void
+handle_copy_out(PGresult *res)
+{
+ bool copydone = false;
+ char copybuf[COPYBUFSIZ];
+ int ret;
+
+ if (!Silent)
+ fprintf(stdout, "Copy command returns...\n");
+
+ while (!copydone) {
+ ret = PQgetline(res->conn, copybuf, COPYBUFSIZ);
+
+ if (copybuf[0] == '.' && copybuf[1] =='\0') {
+ copydone = true; /* don't print this... */
+ } else {
+ fputs(copybuf, stdout);
+ switch (ret) {
+ case EOF:
+ copydone = true;
+ /*FALLTHROUGH*/
+ case 0:
+ fputc('\n', stdout);
+ break;
+ case 1:
+ break;
+ }
+ }
+ }
+ fflush(stdout);
+ PQendcopy(res->conn);
+}
+
+static void
+handle_copy_in(PGresult *res)
+{
+ bool copydone = false;
+ bool firstload;
+ bool linedone;
+ char copybuf[COPYBUFSIZ];
+ char *s;
+ int buflen;
+ int c;
+
+ if (!Silent) {
+ fputs("Enter info followed by a newline\n", stdout);
+ fputs("End with a dot on a line by itself.\n", stdout);
+ }
+
+ /*
+ * eat inevitable newline still in input buffer
+ *
+ * XXX the 'inevitable newline' is not always present
+ * for example `cat file | monitor -c "copy from stdin"'
+ */
+ fflush(stdin);
+ if ((c = getc(stdin)) != '\n' && c != EOF) {
+ (void) ungetc(c, stdin);
+ }
+
+ while (!copydone) { /* for each input line ... */
+ if (!Silent) {
+ fputs(">> ", stdout);
+ fflush(stdout);
+ }
+ firstload = true;
+ linedone = false;
+ while (!linedone) { /* for each buffer ... */
+ s = copybuf;
+ buflen = COPYBUFSIZ;
+ for (; buflen > 1 &&
+ !(linedone = (c = getc(stdin)) == '\n' || c == EOF);
+ --buflen) {
+ *s++ = c;
+ }
+ if (c == EOF) {
+ /* reading from stdin, but from a file */
+ PQputline(res->conn, ".");
+ copydone = true;
+ break;
+ }
+ *s = '\0';
+ PQputline(res->conn, copybuf);
+ if (firstload) {
+ if (!strcmp(copybuf, ".")) {
+ copydone = true;
+ }
+ firstload = false;
+ }
+ }
+ PQputline(res->conn, "\n");
+ }
+ PQendcopy(res->conn);
+}
--- /dev/null
+#
+# /usr/local/devel/pglite/cvs/src/bin/pg_dump/Makefile.v4r2,v 1.1 1995/05/17 18:57:10 jolly Exp
+#
+
+
+CFLAGS+= -I${.CURDIR}/../../backend/tmp
+
+PROG= pg4_dump
+
+SRCS= pg4_dump.c common.c
+
--- /dev/null
+pg4_dump is a utility for dumping out a postgres (version 4, release 2)
+database into a script file containing query commands. The script
+files are in a ASCII format and can be used to reconstruct the
+database, even on other machines and other architectures. pg_dump
+will produce the queries necessary to re-generate all user-defined
+types, functions, tables, indices, aggregates, and operators. In
+addition, all the data is copied out in ASCII format so that it can be
+readily copied in again.
+
+The sources in this directory can be used to build two different
+versions of the program. The two versions require different
+versions of libpq, and the same binary cannot serve both purposes.
+
+
+ To build:
+
+ % bmake clean install
+
+ This version of the program will read in your postgres v4r2
+database and output the schema and the data tuples in one of two
+formats: POSTQUEL or SQL. The POSTQUEL->POSTQUEL dumps are useful
+for moving from one v4r2 installation to another. The POSTQUEL->SQL
+dumps are useful for migrating from v4r2 to postgres95.
+
+Use the -o [SQL|POSTQUEL] option to specify output query language.
+
+
+How to use pg4_dump:
+-------------------
+
+The command line options are fairly self explanatory. Use -help to
+see the command line options. I recommend using -v to get more
+verbose descriptions of what pg_dump is doing.
+
+After running pg4_dump, one should examine the output script file for any
+warnings, especially in light of the limitations listed below.
+
+A typical use of pg4_dump:
+
+ % pg4_dump -v -f oldDB.dump oldDB
+ % createdb newDB
+ % monitor newDB < oldDB.dump
+
+
+Caveats and limitations:
+------------------------
+
+pg4_dump has a few limitations. The limitations mostly stem from
+difficulty in extracting certain meta-information from the system
+catalogs.
+
+ rules and views:
+ pg4_dump does not understand user-defined rules and views and
+ will fail to dump them properly. (This is due to the fact that
+ rules are stored as plans in the catalogs and not textually)
+
+ partial indices:
+ pg4_dump does not understand partial indices. (The reason is
+ the same as above. Partial index predicates are stored as plans)
+
+ source text of POSTQUEL functions:
+ pg4_dump does not convert the source text of a user-defined
+ POSTQUEL function into SQL. Manual intervention is required.
+
+ large objects:
+ pg4_dump does not handle large objects. Inversion large
+ objects are ignored and must be dealt with manually.
+
+ oid preservation:
+ pg4_dump does not preserve oid's while dumping. If you have
+ stored oid's explicitly in tables in user-defined attributes,
+ and are using them as keys, then the output scripts will not
+ regenerate your database correctly.
+
+pg4_dump has not been tested and will probably not work properly for
+versions of postgres prior to 4.2.
+
+Bug-reporting
+--------------
+
+If you should find a problem with pg4_dump, it is very important that
+you provide a (small) sample database which illustrates the problem.
+Please send bugs, questions, and feedback to the
+
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * common.c--
+ * common routines between pg_dump and pg4_dump
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * /usr/local/devel/pglite/cvs/src/bin/pg_dump/common.c,v 1.5 1995/06/28 22:32:35 jolly Exp
+ *
+ *-------------------------------------------------------------------------
+ */
+
+
+#include
+#include
+#include /* for MAXHOSTNAMELEN on most */
+#ifdef PORTNAME_sparc_solaris
+#include /* for MAXHOSTNAMELEN on some */
+#endif
+
+#include "postgres.h"
+#include "libpq-fe.h"
+#include "libpq/auth.h"
+
+#include "pg_dump.h"
+
+/*
+ * check_conn_and_db checks the connection and the database
+ */
+void
+check_conn_and_db()
+{
+ char *string= PQexec(" ");
+ switch(*string) {
+ case 'E':
+ case 'R':
+ PQfinish();
+ exit(2);
+ break;
+ }
+}
+
+
+/* dupstr : copies a string, while allocating space for it.
+ the CALLER is responsible for freeing the space
+ returns NULL if the argument is NULL*/
+char*
+dupstr(char *s)
+{
+ char* result;
+
+ if (s == NULL)
+ return NULL;
+
+ result = (char*)malloc(strlen(s)+1);
+ strcpy(result, s);
+ return result;
+}
+
+
+/*
+ * findTypeByOid
+ * given an oid of a type, return its typename
+ *
+ * if oid is "0", return "opaque" -- this is a special case
+ *
+ * NOTE: should hash this, but just do linear search for now
+ */
+
+char*
+findTypeByOid(TypeInfo* tinfo, int numTypes, char* oid)
+{
+ int i;
+
+ if (strcmp(oid, "0") == 0) return g_opaque_type;
+
+ for (i=0;i
+ if (strcmp(tinfo[i].oid, oid) == 0)
+ return tinfo[i].typname;
+ }
+
+ /* should never get here */
+ fprintf(stderr,"failed sanity check, type with oid %s was not found\n",
+ oid);
+ exit(2);
+}
+
+/*
+ * findOprByOid
+ * given the oid of an operator, return the name of the operator
+ *
+ *
+ * NOTE: should hash this, but just do linear search for now
+ *
+ */
+char*
+findOprByOid(OprInfo *oprinfo, int numOprs, char *oid)
+{
+ int i;
+ for (i=0;i
+ if (strcmp(oprinfo[i].oid, oid) == 0)
+ return oprinfo[i].oprname;
+ }
+
+ /* should never get here */
+ fprintf(stderr,"failed sanity check, opr with oid %s was not found\n",
+ oid);
+ exit(2);
+}
+
+
+/*
+ * findParentsByOid --
+ * given the oid of a class, return the names of its parent classes
+ * and assign the number of parents to the last argument.
+ *
+ *
+ * returns NULL if none
+ */
+
+char**
+findParentsByOid(TableInfo* tblinfo, int numTables,
+ InhInfo* inhinfo, int numInherits, char *oid,
+ int *numParentsPtr)
+{
+ int i,j;
+ int parentInd;
+ char** result;
+ int numParents;
+
+ numParents = 0;
+ for (i=0;i
+ if ( strcmp(inhinfo[i].inhrel, oid) == 0) {
+ numParents++;
+ }
+ }
+
+ *numParentsPtr = numParents;
+
+ if (numParents > 0) {
+ result = (char**)malloc(sizeof(char*) * numParents);
+ j = 0;
+ for (i=0;i
+ if ( strcmp(inhinfo[i].inhrel, oid) == 0) {
+ parentInd = findTableByOid(tblinfo, numTables,
+ inhinfo[i].inhparent);
+ result[j++] = tblinfo[parentInd].relname;
+ }
+ }
+ return result;
+ }
+ else
+ return NULL;
+}
+
+/*
+ * parseArgTypes
+ * parse a string of eight numbers delimited by spaces
+ * into a character array
+ */
+
+void
+parseArgTypes(char **argtypes, char* str)
+{
+ int i, j, argNum;
+ char temp[100];
+ char s;
+
+ argNum = 0;
+ j = 0;
+ while ( (s = *str) != '\0') {
+ if (s == ' ') {
+ temp[j] = '\0';
+ argtypes[argNum] = dupstr(temp);
+ argNum++;
+ j = 0;
+ } else {
+ temp[j] = s;
+ j++;
+ }
+ str++;
+ }
+ if (j != 0) {
+ temp[j] = '\0';
+ argtypes[argNum] = dupstr(temp);
+ }
+
+}
+
+
+/*
+ * strInArray:
+ * takes in a string and a string array and the number of elements in the
+ * string array.
+ * returns the index if the string is somewhere in the array, -1 otherwise
+ *
+ */
+
+int
+strInArray(char* pattern, char** arr, int arr_size)
+{
+ int i;
+ for (i=0;i
+ if (strcmp(pattern, arr[i]) == 0)
+ return i;
+ }
+ return -1;
+}
+
+/*
+ * dumpSchema:
+ * we have a valid connection, we are now going to dump the schema
+ * into the file
+ *
+ */
+
+TableInfo *
+dumpSchema(FILE* fout, int *numTablesPtr)
+{
+ int numTypes;
+ int numFuncs;
+ int numTables;
+ int numInherits;
+ int numIndices;
+ int numAggregates;
+ int numOperators;
+ TypeInfo *tinfo;
+ FuncInfo *finfo;
+ AggInfo *agginfo;
+ TableInfo *tblinfo;
+ InhInfo *inhinfo;
+ IndInfo *indinfo;
+ OprInfo *oprinfo;
+
+if (g_verbose) fprintf(stderr,"%s reading user-defined types %s\n",
+ g_comment_start, g_comment_end);
+ tinfo = getTypes(&numTypes);
+
+if (g_verbose) fprintf(stderr,"%s reading user-defined functions %s\n",
+ g_comment_start, g_comment_end);
+ finfo = getFuncs(&numFuncs);
+
+if (g_verbose) fprintf(stderr,"%s reading user-defined aggregates %s\n",
+ g_comment_start, g_comment_end);
+ agginfo = getAggregates(&numAggregates);
+
+if (g_verbose) fprintf(stderr,"%s reading user-defined operators %s\n",
+ g_comment_start, g_comment_end);
+ oprinfo = getOperators(&numOperators);
+
+if (g_verbose) fprintf(stderr,"%s reading user-defined tables %s\n",
+ g_comment_start, g_comment_end);
+ tblinfo = getTables(&numTables);
+
+if (g_verbose) fprintf(stderr,"%s reading table inheritance information %s\n",
+ g_comment_start, g_comment_end);
+ inhinfo = getInherits(&numInherits);
+
+if (g_verbose) fprintf(stderr, "%s finding the attribute names and types for each table %s\n",
+ g_comment_start, g_comment_end);
+ getTableAttrs(tblinfo, numTables);
+
+if (g_verbose) fprintf(stderr, "%s flagging inherited attributes in subtables %s\n",
+ g_comment_start, g_comment_end);
+ flagInhAttrs(tblinfo, numTables, inhinfo, numInherits);
+
+if (g_verbose) fprintf(stderr,"%s reading indices information %s\n",
+ g_comment_start, g_comment_end);
+ indinfo = getIndices(&numIndices);
+
+if (g_verbose) fprintf(stderr,"%s dumping out user-defined types %s\n",
+ g_comment_start, g_comment_end);
+ dumpTypes(fout, finfo, numFuncs, tinfo, numTypes);
+
+if (g_verbose) fprintf(stderr,"%s dumping out tables %s\n",
+ g_comment_start, g_comment_end);
+ dumpTables(fout, tblinfo, numTables, inhinfo, numInherits,
+ tinfo, numTypes);
+
+if (g_verbose) fprintf(stderr,"%s dumping out user-defined functions %s\n",
+ g_comment_start, g_comment_end);
+ dumpFuncs(fout, finfo, numFuncs, tinfo, numTypes);
+
+if (g_verbose) fprintf(stderr,"%s dumping out user-defined functions %s\n",
+ g_comment_start, g_comment_end);
+ dumpAggs(fout, agginfo, numAggregates, tinfo, numTypes);
+
+if (g_verbose) fprintf(stderr,"%s dumping out user-defined operators %s\n",
+ g_comment_start, g_comment_end);
+ dumpOprs(fout, oprinfo, numOperators, tinfo, numTypes);
+
+if (g_verbose) fprintf(stderr,"%s dumping out indices %s\n",
+ g_comment_start, g_comment_end);
+ dumpIndices(fout, indinfo, numIndices, tblinfo, numTables);
+
+ *numTablesPtr = numTables;
+ return tblinfo;
+}
+
+
+/* flagInhAttrs -
+ * for each table in tblinfo, flag its inherited attributes
+ * so when we dump the table out, we don't dump out the inherited attributes
+ *
+ * initializes the parentRels field of each table
+ *
+ * modifies tblinfo
+ *
+ */
+void
+flagInhAttrs(TableInfo* tblinfo, int numTables,
+ InhInfo* inhinfo, int numInherits)
+{
+ int i,j,k;
+ int parentInd;
+ char *parentRels;
+ int numParents;
+
+ /* we go backwards because the tables in tblinfo are in OID
+ order, meaning the subtables are after the parent tables
+ we flag inherited attributes from child tables first */
+ for (i = numTables-1; i >= 0; i--) {
+ tblinfo[i].parentRels = findParentsByOid(tblinfo, numTables,
+ inhinfo, numInherits,
+ tblinfo[i].oid,
+ &tblinfo[i].numParents);
+ for (k=0;k
+ parentInd = findTableByName(tblinfo, numTables,
+ tblinfo[i].parentRels[k]);
+ for (j=0;j
+ if (strInArray(tblinfo[i].attnames[j],
+ tblinfo[parentInd].attnames,
+ tblinfo[parentInd].numatts) != -1) {
+ tblinfo[i].inhAttrs[j] = 1;
+ }
+ }
+ }
+ }
+}
+
+
+/*
+ * findTableByName
+ * finds the index (in tblinfo) of the table with the given relname
+ * returns -1 if not found
+ *
+ * NOTE: should hash this, but just do linear search for now
+ */
+
+int
+findTableByName(TableInfo* tblinfo, int numTables, char* relname)
+{
+ int i;
+ for (i=0;i
+ if (strcmp(tblinfo[i].relname, relname) == 0)
+ return i;
+ }
+ return -1;
+}
+
+/*
+ * findTableByOid
+ * finds the index (in tblinfo) of the table with the given oid
+ * returns -1 if not found
+ *
+ * NOTE: should hash this, but just do linear search for now
+ */
+
+int
+findTableByOid(TableInfo* tblinfo, int numTables, char* oid)
+{
+ int i;
+ for (i=0;i
+ if (strcmp(tblinfo[i].oid, oid) == 0)
+ return i;
+ }
+ return -1;
+}
+
+
+/*
+ * findFuncByName
+ * finds the index (in finfo) of the function with the given name
+ * returns -1 if not found
+ *
+ * NOTE: should hash this, but just do linear search for now
+ */
+
+int
+findFuncByName(FuncInfo* finfo, int numFuncs, char* name)
+{
+ int i;
+ for (i=0;i
+ if (strcmp(finfo[i].proname, name) == 0)
+ return i;
+ }
+ return -1;
+}
+
+/*
+ * isArchiveName
+ *
+ * returns true if the relation name is an archive name, false otherwise
+ */
+int
+isArchiveName(char* relname)
+{
+ return (strlen(relname) > 1 && relname[1] == ',');
+}
+
+
+
+
+
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * pg4_dump.c--
+ * pg4_dump is an utility for dumping out a postgres database
+ * into a script file.
+ *
+ * pg4_dump will read the system catalogs from a postgresV4r2 database and
+ * dump out a script that reproduces the schema of the database in terms of
+ * user-defined types
+ * user-defined functions
+ * tables
+ * indices
+ * aggregates
+ * operators
+ *
+ * the output script is either POSTQUEL or SQL
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * /usr/local/devel/pglite/cvs/src/bin/pg_dump/pg4_dump.c,v 1.1 1995/05/18 19:23:53 jolly Exp
+ *
+ *-------------------------------------------------------------------------
+ */
+
+
+#include
+#include
+#include /* for MAXHOSTNAMELEN on most */
+#ifdef PORTNAME_sparc_solaris
+#include /* for MAXHOSTNAMELEN on some */
+#endif
+
+#include "tmp/postgres.h"
+#include "tmp/libpq-fe.h"
+#include "libpq/auth.h"
+
+#include "pg_dump.h"
+
+extern char *optarg;
+extern int optind, opterr;
+
+/* these are used in libpq */
+extern char *PQhost; /* machine on which the backend is running */
+extern char *PQport; /* comm. port with the postgres backend. */
+extern char *PQtty; /* the tty where postgres msgs are displayed */
+extern char *PQdatabase; /* the postgres db to access. */
+
+/* global decls */
+int g_verbose; /* verbose flag */
+int g_last_builtin_oid; /* value of the last builtin oid */
+FILE *g_fout; /* the script file */
+
+char g_opaque_type[10]; /* name for the opaque type */
+
+/* placeholders for the delimiters for comments */
+char g_comment_start[10];
+char g_comment_end[10];
+
+int g_outputSQL; /* if 1, output SQL, otherwise , output Postquel */
+
+static
+usage(char* progname)
+{
+ fprintf(stderr, "usage: %s [options] [dbname]\n",progname);
+ fprintf(stderr, "\t -f filename \t\t script output filename\n");
+ fprintf(stderr, "\t -H hostname \t\t server host name\n");
+ fprintf(stderr, "\t -o [SQL|POSTQUEL} \t\t output format\n");
+ fprintf(stderr, "\t -p port \t\t server port number\n");
+ fprintf(stderr, "\t -v \t\t verbose\n");
+ fprintf(stderr, "\t -S \t\t dump out only the schema, no data\n");
+ fprintf(stderr, "\n if dbname is not supplied, then the DATABASE environment name is used\n");
+ fprintf(stderr, "\n");
+
+ fprintf(stderr, "\tpg4_dump dumps out postgres databases and produces a script file\n");
+ fprintf(stderr, "\tof query commands to regenerate the schema\n");
+ fprintf(stderr, "\tThe output format is either POSTQUEL or SQL. The default is SQL\n");
+ exit(1);
+}
+
+void
+main(int argc, char** argv)
+{
+ int c;
+ char* progname;
+ char* filename;
+ char* dbname;
+ char *username, usernamebuf[NAMEDATALEN + 1];
+ char hostbuf[MAXHOSTNAMELEN];
+ int schemaOnly;
+
+ TableInfo *tblinfo;
+ int numTables;
+
+
+ dbname = NULL;
+ filename = NULL;
+ g_verbose = 0;
+ g_outputSQL = 1;
+ schemaOnly = 0;
+
+ progname = *argv;
+
+ while ((c = getopt(argc, argv,"f:H:o:p:vSD")) != EOF) {
+ switch(c) {
+ case 'f': /* output file name */
+ filename = optarg;
+ break;
+ case 'H' : /* server host */
+ PQhost = optarg;
+ break;
+ case 'o':
+ {
+ char *lang = optarg;
+ if (lang) {
+ if (strcmp(lang,"SQL") != 0)
+ g_outputSQL = 0;
+ }
+ }
+ break;
+ case 'p' : /* server port */
+ PQport = optarg;
+ break;
+ case 'v': /* verbose */
+ g_verbose = 1;
+ break;
+ case 'S': /* dump schema only */
+ schemaOnly = 1;
+ break;
+ default:
+ usage(progname);
+ break;
+ }
+ }
+
+ /* open the output file */
+ if (filename == NULL) {
+ g_fout = stdout;
+ } else {
+ g_fout = fopen(filename, "w");
+ if (g_fout == NULL) {
+ fprintf(stderr,"%s: could not open output file named %s for writing\n",
+ progname, filename);
+ exit(2);
+ }
+ }
+
+ /* Determine our username (according to the authentication system, if
+ * there is one).
+ */
+ if ((username = fe_getauthname()) == (char *) NULL) {
+ fprintf(stderr, "%s: could not find a valid user name\n",progname);
+ exit(2);
+ }
+ memset(usernamebuf, 0, sizeof(usernamebuf));
+ (void) strncpy(usernamebuf, username, NAMEDATALEN);
+ username = usernamebuf;
+
+ /*
+ * Determine the hostname of the database server. Try to avoid using
+ * "localhost" if at all possible.
+ */
+ if (!PQhost && !(PQhost = getenv("PGHOST")))
+ PQhost = "localhost";
+ if (!strcmp(PQhost, "localhost")) {
+ if (gethostname(hostbuf, MAXHOSTNAMELEN) != -1)
+ PQhost = hostbuf;
+ }
+
+
+ /* find database */
+ if (!(dbname = argv[optind]) &&
+ !(dbname = getenv("DATABASE")) &&
+ !(dbname = username)) {
+ fprintf(stderr, "%s: no database name specified\n",progname);
+ exit (2);
+ }
+
+ PQsetdb(dbname);
+
+ /* make sure things are ok before giving users a warm welcome! */
+ check_conn_and_db();
+
+ if (g_outputSQL) {
+ strcpy(g_comment_start,"-- ");
+ g_comment_end[0] = '\0';
+ strcpy(g_opaque_type, "opaque");
+ } else {
+ strcpy(g_comment_start,"/* ");
+ strcpy(g_comment_end,"*/ ");
+ strcpy(g_opaque_type, "any");
+ }
+
+ g_last_builtin_oid = findLastBuiltinOid();
+
+
+if (g_verbose)
+ fprintf(stderr, "%s last builtin oid is %d %s\n",
+ g_comment_start, g_last_builtin_oid, g_comment_end);
+
+ tblinfo = dumpSchema(g_fout, &numTables);
+
+ if (!schemaOnly) {
+
+if (g_verbose) {
+ fprintf(stderr, "%s dumping out the contents of each table %s\n",
+ g_comment_start, g_comment_end );
+ fprintf(stderr, "%s the output language is %s %s\n",
+ g_comment_start,
+ (g_outputSQL) ? "SQL" : "POSTQUEL",
+ g_comment_end);
+}
+
+ dumpClasses(tblinfo, numTables, g_fout);
+ }
+
+ fflush(g_fout);
+ fclose(g_fout);
+ exit(0);
+}
+
+/*
+ * getTypes:
+ * read all base types in the system catalogs and return them in the
+ * TypeInfo* structure
+ *
+ * numTypes is set to the number of types read in
+ *
+ */
+TypeInfo*
+getTypes(int *numTypes)
+{
+ char* res;
+ PortalBuffer* pbuf;
+ int ntups;
+ int i;
+ char query[MAXQUERYLEN];
+ TypeInfo *tinfo;
+
+ int i_oid;
+ int i_typowner;
+ int i_typname;
+ int i_typlen;
+ int i_typprtlen;
+ int i_typinput;
+ int i_typoutput;
+ int i_typreceive;
+ int i_typsend;
+ int i_typelem;
+ int i_typdelim;
+ int i_typdefault;
+ int i_typrelid;
+ int i_typbyval;
+
+ PQexec("begin");
+
+ /* find all base types */
+ /* we include even the built-in types
+ because those may be used as array elements by user-defined types */
+ /* we filter out the built-in types when
+ we dump out the types */
+
+/*
+ sprintf(query, "SELECT oid, typowner,typname, typlen, typprtlen, typinput, typoutput, typreceive, typsend, typelem, typdelim, typdefault, typrelid,typbyval from pg_type");
+*/
+ sprintf(query, "retrieve (t.oid, t.typowner, t.typname, t.typlen, t.typprtlen, t.typinput, t.typoutput, t.typreceive, t.typsend, t.typelem, t.typdelim, t.typdefault, t.typrelid, t.typbyval) from t in pg_type");
+
+
+ res = PQexec(query);
+ pbuf = PQparray(res+1);
+ ntups = PQntuplesGroup(pbuf,0);
+
+ tinfo = (TypeInfo*)malloc(ntups * sizeof(TypeInfo));
+
+ i_oid = PQfnumberGroup(pbuf,0,"oid");
+ i_typowner = PQfnumberGroup(pbuf,0,"typowner");
+ i_typname = PQfnumberGroup(pbuf,0,"typname");
+ i_typlen = PQfnumberGroup(pbuf,0,"typlen");
+ i_typprtlen = PQfnumberGroup(pbuf,0,"typprtlen");
+ i_typinput = PQfnumberGroup(pbuf,0,"typinput");
+ i_typoutput = PQfnumberGroup(pbuf,0,"typoutput");
+ i_typreceive = PQfnumberGroup(pbuf,0,"typreceive");
+ i_typsend = PQfnumberGroup(pbuf,0,"typsend");
+ i_typelem = PQfnumberGroup(pbuf,0,"typelem");
+ i_typdelim = PQfnumberGroup(pbuf,0,"typdelim");
+ i_typdefault = PQfnumberGroup(pbuf,0,"typdefault");
+ i_typrelid = PQfnumberGroup(pbuf,0,"typrelid");
+ i_typbyval = PQfnumberGroup(pbuf,0,"typbyval");
+
+ for (i=0;i
+ tinfo[i].oid = dupstr(PQgetvalue(pbuf,i,i_oid));
+ tinfo[i].typowner = dupstr(PQgetvalue(pbuf,i,i_typowner));
+ tinfo[i].typname = dupstr(PQgetvalue(pbuf,i,i_typname));
+ tinfo[i].typlen = dupstr(PQgetvalue(pbuf,i,i_typlen));
+ tinfo[i].typprtlen = dupstr(PQgetvalue(pbuf,i,i_typprtlen));
+ tinfo[i].typinput = dupstr(PQgetvalue(pbuf,i,i_typinput));
+ tinfo[i].typoutput = dupstr(PQgetvalue(pbuf,i,i_typoutput));
+ tinfo[i].typreceive = dupstr(PQgetvalue(pbuf,i,i_typreceive));
+ tinfo[i].typsend = dupstr(PQgetvalue(pbuf,i,i_typsend));
+ tinfo[i].typelem = dupstr(PQgetvalue(pbuf,i,i_typelem));
+ tinfo[i].typdelim = dupstr(PQgetvalue(pbuf,i,i_typdelim));
+ tinfo[i].typdefault = dupstr(PQgetvalue(pbuf,i,i_typdefault));
+ tinfo[i].typrelid = dupstr(PQgetvalue(pbuf,i,i_typrelid));
+
+ if (strcmp(PQgetvalue(pbuf,i,i_typbyval), "f") == 0)
+ tinfo[i].passedbyvalue = 0;
+ else
+ tinfo[i].passedbyvalue = 1;
+
+ /* check for user-defined array types,
+ omit system generated ones */
+ if ( (strcmp(tinfo[i].typelem, "0") != 0) &&
+ tinfo[i].typname[0] != '_')
+ tinfo[i].isArray = 1;
+ else
+ tinfo[i].isArray = 0;
+ }
+
+ *numTypes = ntups;
+
+ PQexec("end");
+ PQclear(res+1);
+ return tinfo;
+}
+
+/*
+ * getOperators:
+ * read all operators in the system catalogs and return them in the
+ * OprInfo* structure
+ *
+ * numOprs is set to the number of operators read in
+ *
+ *
+ */
+
+OprInfo*
+getOperators(int *numOprs)
+{
+ char *res;
+ PortalBuffer *pbuf;
+ int ntups;
+ int i;
+ char query[MAXQUERYLEN];
+
+ OprInfo* oprinfo;
+
+ int i_oid;
+ int i_oprname;
+ int i_oprkind;
+ int i_oprcode;
+ int i_oprleft;
+ int i_oprright;
+ int i_oprcom;
+ int i_oprnegate;
+ int i_oprrest;
+ int i_oprjoin;
+ int i_oprcanhash;
+ int i_oprlsortop;
+ int i_oprrsortop;
+
+ /* find all operators, including builtin operators,
+ filter out system-defined operators at dump-out time */
+ PQexec("begin");
+/*
+ sprintf(query, "SELECT oid, oprname, oprkind, oprcode, oprleft, oprright, oprcom, oprnegate, oprrest, oprjoin, oprcanhash, oprlsortop, oprrsortop from pg_operator");
+*/
+ sprintf(query, "retrieve (o.oid, o.oprname, o.oprkind, o.oprcode, o.oprleft, o.oprright, o.oprcom, o.oprnegate, o.oprrest, o.oprjoin, o.oprcanhash, o.oprlsortop, o.oprrsortop) from o in pg_operator");
+
+
+ res = PQexec(query);
+ pbuf = PQparray(res+1);
+ ntups = PQntuplesGroup(pbuf,0);
+ *numOprs = ntups;
+
+ oprinfo = (OprInfo*)malloc(ntups * sizeof(OprInfo));
+
+ i_oid = PQfnumberGroup(pbuf,0,"oid");
+ i_oprname = PQfnumberGroup(pbuf,0,"oprname");
+ i_oprkind = PQfnumberGroup(pbuf,0,"oprkind");
+ i_oprcode = PQfnumberGroup(pbuf,0,"oprcode");
+ i_oprleft = PQfnumberGroup(pbuf,0,"oprleft");
+ i_oprright = PQfnumberGroup(pbuf,0,"oprright");
+ i_oprcom = PQfnumberGroup(pbuf,0,"oprcom");
+ i_oprnegate = PQfnumberGroup(pbuf,0,"oprnegate");
+ i_oprrest = PQfnumberGroup(pbuf,0,"oprrest");
+ i_oprjoin = PQfnumberGroup(pbuf,0,"oprjoin");
+ i_oprcanhash = PQfnumberGroup(pbuf,0,"oprcanhash");
+ i_oprlsortop = PQfnumberGroup(pbuf,0,"oprlsortop");
+ i_oprrsortop = PQfnumberGroup(pbuf,0,"oprrsortop");
+
+ for (i=0;i
+ oprinfo[i].oid = dupstr(PQgetvalue(pbuf,i,i_oid));
+ oprinfo[i].oprname = dupstr(PQgetvalue(pbuf,i,i_oprname));
+ oprinfo[i].oprkind = dupstr(PQgetvalue(pbuf,i,i_oprkind));
+ oprinfo[i].oprcode = dupstr(PQgetvalue(pbuf,i,i_oprcode));
+ oprinfo[i].oprleft = dupstr(PQgetvalue(pbuf,i,i_oprleft));
+ oprinfo[i].oprright = dupstr(PQgetvalue(pbuf,i,i_oprright));
+ oprinfo[i].oprcom = dupstr(PQgetvalue(pbuf,i,i_oprcom));
+ oprinfo[i].oprnegate = dupstr(PQgetvalue(pbuf,i,i_oprnegate));
+ oprinfo[i].oprrest = dupstr(PQgetvalue(pbuf,i,i_oprrest));
+ oprinfo[i].oprjoin = dupstr(PQgetvalue(pbuf,i,i_oprjoin));
+ oprinfo[i].oprcanhash = dupstr(PQgetvalue(pbuf,i,i_oprcanhash));
+ oprinfo[i].oprlsortop = dupstr(PQgetvalue(pbuf,i,i_oprlsortop));
+ oprinfo[i].oprrsortop = dupstr(PQgetvalue(pbuf,i,i_oprrsortop));
+ }
+
+ PQclear(res+1);
+ PQexec("end");
+
+ return oprinfo;
+}
+
+
+/*
+ * getAggregates:
+ * read all the user-defined aggregates in the system catalogs and
+ * return them in the AggInfo* structure
+ *
+ * numAggs is set to the number of aggregates read in
+ *
+ *
+ */
+AggInfo*
+getAggregates(int *numAggs)
+{
+ char* res;
+ PortalBuffer *pbuf;
+ int ntups;
+ int i;
+ char query[MAXQUERYLEN];
+ AggInfo *agginfo;
+
+ int i_oid;
+ int i_aggname;
+ int i_aggtransfn1;
+ int i_aggtransfn2;
+ int i_aggfinalfn;
+ int i_aggtranstype1;
+ int i_aggbasetype;
+ int i_aggtranstype2;
+ int i_agginitval1;
+ int i_agginitval2;
+
+ /* find all user-defined aggregates */
+
+ PQexec("begin");
+/*
+ sprintf(query,
+ "SELECT oid, aggname, aggtransfn1, aggtransfn2, aggfinalfn, aggtranstype1, aggbasetype, aggtranstype2, agginitval1, agginitval2 from pg_aggregate;");
+*/
+ sprintf(query,
+ "retrieve (a.oid, a.aggname, a.aggtransfn1, a.aggtransfn2, a.aggfinalfn, a.aggtranstype1, a.aggbasetype, a.aggtranstype2, a.agginitval1, a.agginitval2) from a in pg_aggregate");
+
+ res = PQexec(query);
+ pbuf = PQparray(res+1);
+ ntups = PQntuplesGroup(pbuf,0);
+ *numAggs = ntups;
+
+ agginfo = (AggInfo*)malloc(ntups * sizeof(AggInfo));
+
+ i_oid = PQfnumberGroup(pbuf,0,"oid");
+ i_aggname = PQfnumberGroup(pbuf,0,"aggname");
+ i_aggtransfn1 = PQfnumberGroup(pbuf,0,"aggtransfn1");
+ i_aggtransfn2 = PQfnumberGroup(pbuf,0,"aggtransfn2");
+ i_aggfinalfn = PQfnumberGroup(pbuf,0,"aggfinalfn");
+ i_aggtranstype1 = PQfnumberGroup(pbuf,0,"aggtranstype1");
+ i_aggbasetype = PQfnumberGroup(pbuf,0,"aggbasetype");
+ i_aggtranstype2 = PQfnumberGroup(pbuf,0,"aggtranstype2");
+ i_agginitval1 = PQfnumberGroup(pbuf,0,"agginitval1");
+ i_agginitval2 = PQfnumberGroup(pbuf,0,"agginitval2");
+
+ for (i=0;i
+ agginfo[i].oid = dupstr(PQgetvalue(pbuf,i,i_oid));
+ agginfo[i].aggname = dupstr(PQgetvalue(pbuf,i,i_aggname));
+ agginfo[i].aggtransfn1 = dupstr(PQgetvalue(pbuf,i,i_aggtransfn1));
+ agginfo[i].aggtransfn2 = dupstr(PQgetvalue(pbuf,i,i_aggtransfn2));
+ agginfo[i].aggfinalfn = dupstr(PQgetvalue(pbuf,i,i_aggfinalfn));
+ agginfo[i].aggtranstype1 = dupstr(PQgetvalue(pbuf,i,i_aggtranstype1));
+ agginfo[i].aggbasetype = dupstr(PQgetvalue(pbuf,i,i_aggbasetype));
+ agginfo[i].aggtranstype2 = dupstr(PQgetvalue(pbuf,i,i_aggtranstype2));
+ agginfo[i].agginitval1 = dupstr(PQgetvalue(pbuf,i,i_agginitval1));
+ agginfo[i].agginitval2 = dupstr(PQgetvalue(pbuf,i,i_agginitval2));
+ }
+
+ PQclear(res+1);
+ PQexec("end");
+
+ return agginfo;
+}
+
+/*
+ * getFuncs:
+ * read all the user-defined functions in the system catalogs and
+ * return them in the FuncInfo* structure
+ *
+ * numFuncs is set to the number of functions read in
+ *
+ *
+ */
+FuncInfo*
+getFuncs(int *numFuncs)
+{
+ char* res;
+ PortalBuffer *pbuf;
+ int ntups;
+ int i, j;
+ char query[MAXQUERYLEN];
+ FuncInfo *finfo;
+ char *proargtypes;
+
+ int i_oid;
+ int i_proname;
+ int i_proowner;
+ int i_prolang;
+ int i_pronargs;
+ int i_proargtypes;
+ int i_prorettype;
+ int i_proretset;
+ int i_prosrc;
+ int i_probin;
+
+ /* find all user-defined funcs */
+
+ PQexec("begin");
+
+/*
+ sprintf(query,
+ "SELECT oid, proname, proowner, prolang, pronargs, prorettype, proretset, proargtypes, prosrc, probin from pg_proc where oid > '%d'::oid",
+ g_last_builtin_oid);
+*/
+ sprintf(query,
+ "retrieve (f.oid, f.proname, f.proowner, f.prolang, f.pronargs, f.prorettype, f.proretset, f.proargtypes, f.prosrc, f.probin) from f in pg_proc where f.oid > \"%d\"::oid",
+ g_last_builtin_oid);
+
+ res = PQexec(query);
+ pbuf = PQparray(res+1);
+ ntups = PQntuplesGroup(pbuf,0);
+
+ *numFuncs = ntups;
+
+ finfo = (FuncInfo*)malloc(ntups * sizeof(FuncInfo));
+
+ i_oid = PQfnumberGroup(pbuf,0,"oid");
+ i_proname = PQfnumberGroup(pbuf,0,"proname");
+ i_proowner = PQfnumberGroup(pbuf,0,"proowner");
+ i_prolang = PQfnumberGroup(pbuf,0,"prolang");
+ i_pronargs = PQfnumberGroup(pbuf,0,"pronargs");
+ i_proargtypes = PQfnumberGroup(pbuf,0,"proargtypes");
+ i_prorettype = PQfnumberGroup(pbuf,0,"prorettype");
+ i_proretset = PQfnumberGroup(pbuf,0,"proretset");
+ i_prosrc = PQfnumberGroup(pbuf,0,"prosrc");
+ i_probin = PQfnumberGroup(pbuf,0,"probin");
+
+ for (i=0;i
+ finfo[i].oid = dupstr(PQgetvalue(pbuf,i,i_oid));
+ finfo[i].proname = dupstr(PQgetvalue(pbuf,i,i_proname));
+ finfo[i].proowner = dupstr(PQgetvalue(pbuf,i,i_proowner));
+
+ finfo[i].prosrc = checkForQuote(PQgetvalue(pbuf,i,i_prosrc));
+ finfo[i].probin = dupstr(PQgetvalue(pbuf,i,i_probin));
+
+ finfo[i].prorettype = dupstr(PQgetvalue(pbuf,i,i_prorettype));
+ finfo[i].retset = (strcmp(PQgetvalue(pbuf,i,i_proretset),"t") == 0);
+ finfo[i].nargs = atoi(PQgetvalue(pbuf,i,i_pronargs));
+ finfo[i].lang = (atoi(PQgetvalue(pbuf,i,i_prolang)) == C_PROLANG_OID);
+
+ parseArgTypes(finfo[i].argtypes, PQgetvalue(pbuf,i,i_proargtypes));
+
+ finfo[i].dumped = 0;
+ }
+
+ PQclear(res+1);
+ PQexec("end");
+
+ return finfo;
+
+}
+
+/*
+ * getTables
+ * read all the user-defined tables (no indices, no catalogs)
+ * in the system catalogs return them in the TableInfo* structure
+ *
+ * numTables is set to the number of tables read in
+ *
+ *
+ */
+TableInfo*
+getTables(int *numTables)
+{
+ char* res;
+ PortalBuffer* pbuf;
+ int ntups;
+ int i, j;
+ char query[MAXQUERYLEN];
+ TableInfo *tblinfo;
+
+ int i_oid;
+ int i_relname;
+ int i_relarch;
+
+ /* find all the user-defined tables (no indices and no catalogs),
+ ordering by oid is important so that we always process the parent
+ tables before the child tables when traversing the tblinfo* */
+ PQexec("begin");
+/*
+ sprintf(query,
+ "SELECT oid, relname, relarch from pg_class where relkind = 'r' and relname !~ '^pg_' order by oid;");
+*/
+ sprintf(query,
+ "retrieve (r.oid, r.relname, r.relarch) from r in pg_class where r.relkind = \"r\" and r.relname !~ \"^pg_\" and r.relname !~ \"^Xinv\" sort by oid");
+
+ res = PQexec(query);
+ pbuf = PQparray(res+1);
+ ntups = PQntuplesGroup(pbuf,0);
+
+ *numTables = ntups;
+
+ tblinfo = (TableInfo*)malloc(ntups * sizeof(TableInfo));
+
+ i_oid = PQfnumberGroup(pbuf,0,"oid");
+ i_relname = PQfnumberGroup(pbuf,0,"relname");
+ i_relarch = PQfnumberGroup(pbuf,0,"relarch");
+
+ for (i=0;i
+ tblinfo[i].oid = dupstr(PQgetvalue(pbuf,i,i_oid));
+ tblinfo[i].relname = dupstr(PQgetvalue(pbuf,i,i_relname));
+ tblinfo[i].relarch = dupstr(PQgetvalue(pbuf,i,i_relarch));
+ }
+
+ PQclear(res+1);
+ PQexec("end");
+
+ return tblinfo;
+
+}
+
+/*
+ * getInherits
+ * read all the inheritance information
+ * from the system catalogs return them in the InhInfo* structure
+ *
+ * numInherits is set to the number of tables read in
+ *
+ *
+ */
+InhInfo*
+getInherits(int *numInherits)
+{
+ char* res;
+ PortalBuffer* pbuf;
+ int ntups;
+ int i;
+ char query[MAXQUERYLEN];
+ InhInfo *inhinfo;
+
+ int i_inhrel;
+ int i_inhparent;
+
+ /* find all the inheritance information */
+ PQexec("begin");
+/*
+ sprintf(query, "SELECT inhrel, inhparent from pg_inherits");
+*/
+ sprintf(query, "retrieve (i.inhrel, i.inhparent) from i in pg_inherits");
+
+ res = PQexec(query);
+ pbuf = PQparray(res+1);
+ ntups = PQntuplesGroup(pbuf,0);
+
+ *numInherits = ntups;
+
+ inhinfo = (InhInfo*)malloc(ntups * sizeof(InhInfo));
+
+ i_inhrel = PQfnumberGroup(pbuf,0,"inhrel");
+ i_inhparent = PQfnumberGroup(pbuf,0,"inhparent");
+
+ for (i=0;i
+ inhinfo[i].inhrel = dupstr(PQgetvalue(pbuf,i,i_inhrel));
+ inhinfo[i].inhparent = dupstr(PQgetvalue(pbuf,i,i_inhparent));
+ }
+
+ PQclear(res+1);
+ PQexec("end");
+ return inhinfo;
+}
+
+/*
+ * getTableAttrs -
+ * for each table in tblinfo, read its attributes types and names
+ *
+ * this is implemented in a very inefficient way right now, looping
+ * through the tblinfo and doing a join per table to find the attrs and their
+ * types
+ *
+ * modifies tblinfo
+ */
+void
+getTableAttrs(TableInfo* tblinfo, int numTables)
+{
+ int i,j;
+ char q[MAXQUERYLEN];
+ int i_attname;
+ int i_typname;
+ char *res;
+ PortalBuffer *pbuf;
+ int ntups;
+
+ for (i=0;i
+
+ /* find all the user attributes and their types*/
+ /* we must read the attribute names in attribute number order! */
+ /* because we will use the attnum to index into the attnames array
+ later */
+/*
+ sprintf(q,"SELECT a.attnum, a.attname, t.typname from pg_attribute a, pg_type t where a.attrelid = '%s' and a.atttypid = t.oid and a.attnum > 0 order by attnum",tblinfo[i].oid);
+*/
+if (g_verbose)
+ fprintf(stderr,"%s finding the attrs and types for table: %s %s\n",
+ g_comment_start,
+ tblinfo[i].relname,
+ g_comment_end);
+
+
+ sprintf(q,"retrieve (a.attnum, a.attname, t.typname) from a in pg_attribute, t in pg_type where a.attrelid = \"%s\" and a.atttypid = t.oid and a.attnum > 0 sort by attnum",tblinfo[i].oid);
+
+ res = PQexec(q);
+ pbuf = PQparray(res+1);
+ ntups = PQntuplesGroup(pbuf,0);
+
+ i_attname = PQfnumberGroup(pbuf,0,"attname");
+ i_typname = PQfnumberGroup(pbuf,0,"typname");
+
+ tblinfo[i].numatts = ntups;
+ tblinfo[i].attnames = (char**) malloc( ntups * sizeof(char*));
+ tblinfo[i].out_attnames = (char**) malloc( ntups * sizeof(char*));
+ tblinfo[i].typnames = (char**) malloc( ntups * sizeof(char*));
+ tblinfo[i].inhAttrs = (int*) malloc (ntups * sizeof(int));
+ tblinfo[i].parentRels = NULL;
+ tblinfo[i].numParents = 0;
+ for (j=0;j
+ tblinfo[i].attnames[j] = dupstr(PQgetvalue(pbuf,j,i_attname));
+ tblinfo[i].typnames[j] = dupstr(PQgetvalue(pbuf,j,i_typname));
+ tblinfo[i].inhAttrs[j] = 0; /* this flag is set in flagInhAttrs()*/
+ }
+ PQclear(res+1);
+ }
+}
+
+
+/*
+ * getIndices
+ * read all the user-defined indices information
+ * from the system catalogs return them in the InhInfo* structure
+ *
+ * numIndices is set to the number of indices read in
+ *
+ *
+ */
+IndInfo*
+getIndices(int *numIndices)
+{
+ int i;
+ char query[MAXQUERYLEN];
+ char *res;
+ PortalBuffer *pbuf;
+ int ntups;
+ IndInfo *indinfo;
+
+ int i_indexrelname;
+ int i_indrelname;
+ int i_indamname;
+ int i_indproc;
+ int i_indkey;
+ int i_indclassname;
+
+ /* find all the user-define indices.
+ We do not handle partial indices.
+ We also assume that only single key indices
+
+ this is a 5-way join !!
+ */
+
+ PQexec("begin");
+/*
+ sprintf(query,
+ "SELECT t1.relname as indexrelname, t2.relname as indrelname, i.indproc, i.indkey[0], o.opcname as indclassname, a.amname as indamname from pg_index i, pg_class t1, pg_class t2, pg_opclass o, pg_am a where t1.oid = i.indexrelid and t2.oid = i.indrelid and o.oid = i.indclass[0] and t1.relam = a.oid and i.indexrelid > '%d'::oid and t2.relname !~ '^pg_';",
+ g_last_builtin_oid);
+*/
+
+ sprintf(query,
+ "retrieve (indexrelname = t1.relname, indrelname = t2.relname, i.indproc, i.indkey[0], indclassname = o.opcname, indamname = a.amname) from i in pg_index, t1 in pg_class, t2 in pg_class, o in pg_opclass, a in pg_am where t1.oid = i.indexrelid and t2.oid = i.indrelid and o.oid = i.indclass[0] and t1.relam = a.oid and i.indexrelid > \"%d\"::oid and t2.relname !~ \"^pg_\" and t1.relname !~ \"^Xinx\"",
+ g_last_builtin_oid);
+
+ res = PQexec(query);
+ pbuf = PQparray(res+1);
+ ntups = PQntuplesGroup(pbuf,0);
+
+ *numIndices = ntups;
+
+ indinfo = (IndInfo*)malloc(ntups * sizeof (IndInfo));
+
+ i_indexrelname = PQfnumberGroup(pbuf,0,"indexrelname");
+ i_indrelname = PQfnumberGroup(pbuf,0,"indrelname");
+ i_indamname = PQfnumberGroup(pbuf,0,"indamname");
+ i_indproc = PQfnumberGroup(pbuf,0,"indproc");
+ i_indkey = PQfnumberGroup(pbuf,0,"indkey");
+ i_indclassname = PQfnumberGroup(pbuf,0,"indclassname");
+
+ for (i=0;i
+ indinfo[i].indexrelname = dupstr(PQgetvalue(pbuf,i,i_indexrelname));
+ indinfo[i].indrelname = dupstr(PQgetvalue(pbuf,i,i_indrelname));
+ indinfo[i].indamname = dupstr(PQgetvalue(pbuf,i,i_indamname));
+ indinfo[i].indproc = dupstr(PQgetvalue(pbuf,i,i_indproc));
+ indinfo[i].indkey = dupstr(PQgetvalue(pbuf,i,i_indkey));
+ indinfo[i].indclassname = dupstr(PQgetvalue(pbuf,i,i_indclassname));
+ }
+ PQclear(res+1);
+ PQexec("end");
+
+ return indinfo;
+}
+
+/*
+ * dumpTypes
+ * writes out to fout queries to recreate all the user-defined types
+ *
+ */
+
+void
+dumpTypes(FILE* fout, FuncInfo* finfo, int numFuncs,
+ TypeInfo* tinfo, int numTypes)
+{
+ int i;
+ char q[MAXQUERYLEN];
+ int funcInd;
+
+ for (i=0;i
+
+ /* skip all the builtin types */
+ if (atoi(tinfo[i].oid) < g_last_builtin_oid)
+ continue;
+
+ /* skip relation types */
+ if (atoi(tinfo[i].typrelid) != 0)
+ continue;
+
+ /* skip all array types that start w/ underscore */
+ if ( (tinfo[i].typname[0] == '_') &&
+ (strcmp(tinfo[i].typinput, "array_in") == 0))
+ continue;
+
+ /* before we create a type, we need to create the input and
+ output functions for it, if they haven't been created already */
+ funcInd = findFuncByName(finfo, numFuncs, tinfo[i].typinput);
+ if (funcInd != -1)
+ dumpOneFunc(fout,finfo,funcInd,tinfo,numTypes);
+
+ funcInd = findFuncByName(finfo, numFuncs, tinfo[i].typoutput);
+ if (funcInd != -1)
+ dumpOneFunc(fout,finfo,funcInd,tinfo,numTypes);
+
+ if (g_outputSQL) {
+ sprintf(q,
+ "CREATE TYPE %s ( internallength = %s, externallength = %s, input = %s, output = %s, send = %s, receive = %s, default = '%s'",
+ tinfo[i].typname,
+ tinfo[i].typlen,
+ tinfo[i].typprtlen,
+ tinfo[i].typinput,
+ tinfo[i].typoutput,
+ tinfo[i].typsend,
+ tinfo[i].typreceive,
+ tinfo[i].typdefault);
+ } else {
+ sprintf(q,
+ "define type %s ( internallength = %s, externallength = %s, input = %s, output = %s, send = %s, receive = %s, default = \"%s\"",
+ tinfo[i].typname,
+ (strcmp(tinfo[i].typlen, "-1") == 0) ? "variable" : tinfo[i].typlen,
+ (strcmp(tinfo[i].typprtlen, "-1") == 0) ? "variable " :tinfo[i].typprtlen,
+ tinfo[i].typinput,
+ tinfo[i].typoutput,
+ tinfo[i].typsend,
+ tinfo[i].typreceive,
+ tinfo[i].typdefault);
+ }
+
+ if (tinfo[i].isArray) {
+ char* elemType;
+
+ elemType = findTypeByOid(tinfo, numTypes, tinfo[i].typelem);
+
+ if (g_outputSQL)
+ sprintf(q,"%s, element = %s, delimiter = '%s'",
+ q, elemType,tinfo[i].typdelim);
+ else
+ sprintf(q,"%s, element = %s, delimiter = \"%s\"",
+ q, elemType,tinfo[i].typdelim);
+ }
+ if (tinfo[i].passedbyvalue)
+ strcat(q,",passedbyvalue");
+ else
+ strcat(q,")");
+
+ if (g_outputSQL)
+ strcat(q,";\n");
+ else
+ strcat(q,"\\g\n");
+
+ fputs(q,fout);
+ }
+ fflush(fout);
+}
+
+/*
+ * dumpFuncs
+ * writes out to fout the queries to recreate all the user-defined functions
+ *
+ */
+void
+dumpFuncs(FILE* fout, FuncInfo* finfo, int numFuncs,
+ TypeInfo *tinfo, int numTypes)
+{
+ int i;
+ char q[MAXQUERYLEN];
+ for (i=0;i
+ dumpOneFunc(fout,finfo,i,tinfo,numTypes);
+ }
+}
+
+/*
+ * dumpOneFunc:
+ * dump out only one function, the index of which is given in the third
+ * argument
+ *
+ */
+
+void
+dumpOneFunc(FILE* fout, FuncInfo* finfo, int i,
+ TypeInfo *tinfo, int numTypes)
+{
+ char q[MAXQUERYLEN];
+ int j;
+
+ if (finfo[i].dumped)
+ return;
+ else
+ finfo[i].dumped = 1;
+
+ if (g_outputSQL) {
+ sprintf(q,"CREATE FUNCTION %s (",finfo[i].proname);
+
+ for (j=0;j
+ char* typname;
+ typname = findTypeByOid(tinfo, numTypes, finfo[i].argtypes[j]);
+ sprintf(q, "%s%s%s",
+ q,
+ (j > 0) ? "," : "",
+ typname);
+ }
+ sprintf(q,"%s ) RETURNS %s%s AS '%s' LANGUAGE '%s';\n",
+ q,
+ finfo[i].retset ? " SETOF " : "",
+ findTypeByOid(tinfo, numTypes, finfo[i].prorettype),
+ (finfo[i].lang) ? finfo[i].probin : finfo[i].prosrc,
+ (finfo[i].lang) ? "C" : "SQL");
+if (finfo[i].lang != 1) {
+ fprintf(stderr,
+ "%s WARNING: text of function named %s is in POSTQUEL %s\n",
+ g_comment_start,
+ finfo[i].proname,
+ g_comment_end);
+}
+
+ } else {
+ sprintf(q,"define function %s ( language = \"%s\", returntype = %s%s) arg is (",
+ finfo[i].proname,
+ (finfo[i].lang) ? "c" : "postquel",
+ finfo[i].retset ? " setof " : "",
+ findTypeByOid(tinfo, numTypes, finfo[i].prorettype)
+ );
+
+ for (j=0;j
+ char* typname;
+ typname = findTypeByOid(tinfo, numTypes, finfo[i].argtypes[j]);
+ sprintf(q, "%s%s%s",
+ q,
+ (j > 0) ? "," : "",
+ typname);
+ }
+ sprintf(q,"%s ) as \"%s\"\\g\n",
+ q,
+ (finfo[i].lang) ? finfo[i].probin : finfo[i].prosrc);
+ }
+
+ fputs(q,fout);
+ fflush(fout);
+
+}
+
+/*
+ * dumpOprs
+ * writes out to fout the queries to recreate all the user-defined operators
+ *
+ */
+void
+dumpOprs(FILE* fout, OprInfo* oprinfo, int numOperators,
+ TypeInfo *tinfo, int numTypes)
+{
+ int i;
+ char q[MAXQUERYLEN];
+ char leftarg[MAXQUERYLEN];
+ char rightarg[MAXQUERYLEN];
+ char commutator[MAXQUERYLEN];
+ char negator[MAXQUERYLEN];
+ char restrict[MAXQUERYLEN];
+ char join[MAXQUERYLEN];
+ char sortop[MAXQUERYLEN];
+ char comma[2];
+
+ for (i=0;i
+
+ /* skip all the builtin oids */
+ if (atoi(oprinfo[i].oid) < g_last_builtin_oid)
+ continue;
+
+ /* some operator are invalid because they were the result
+ of user defining operators before commutators exist */
+ if (strcmp(oprinfo[i].oprcode, "-") == 0)
+ continue;
+
+ leftarg[0] = '\0';
+ rightarg[0] = '\0';
+ /* right unary means there's a left arg
+ and left unary means there's a right arg */
+ if (strcmp(oprinfo[i].oprkind, "r") == 0 ||
+ strcmp(oprinfo[i].oprkind, "b") == 0 ) {
+ sprintf(leftarg, ", %s = %s ",
+ (g_outputSQL) ? "LEFTARG" : "arg1",
+ findTypeByOid(tinfo, numTypes, oprinfo[i].oprleft));
+ }
+ if (strcmp(oprinfo[i].oprkind, "l") == 0 ||
+ strcmp(oprinfo[i].oprkind, "b") == 0 ) {
+ sprintf(rightarg, ", %s = %s ",
+ (g_outputSQL) ? "RIGHTARG" : "arg2",
+ findTypeByOid(tinfo, numTypes, oprinfo[i].oprright));
+ }
+ if (strcmp(oprinfo[i].oprcom, "0") == 0)
+ commutator[0] = '\0';
+ else
+ sprintf(commutator,", commutator = %s ",
+ findOprByOid(oprinfo, numOperators, oprinfo[i].oprcom));
+
+ if (strcmp(oprinfo[i].oprnegate, "0") == 0)
+ negator[0] = '\0';
+ else
+ sprintf(negator,", negator = %s ",
+ findOprByOid(oprinfo, numOperators, oprinfo[i].oprnegate));
+
+ if (strcmp(oprinfo[i].oprrest, "-") == 0)
+ restrict[0] = '\0';
+ else
+ sprintf(restrict,", restrict = %s ", oprinfo[i].oprrest);
+
+ if (strcmp(oprinfo[i].oprjoin,"-") == 0)
+ join[0] = '\0';
+ else
+ sprintf(join,", join = %s ", oprinfo[i].oprjoin);
+
+ if (strcmp(oprinfo[i].oprlsortop, "0") == 0)
+ sortop[0] = '\0';
+ else
+ {
+ sprintf(sortop,", SORT = %s ",
+ findOprByOid(oprinfo, numOperators,
+ oprinfo[i].oprlsortop));
+ if (strcmp(oprinfo[i].oprrsortop, "0") != 0)
+ sprintf(sortop, "%s , %s", sortop,
+ findOprByOid(oprinfo, numOperators,
+ oprinfo[i].oprlsortop));
+ }
+
+ if (g_outputSQL) {
+ sprintf(q,
+ "CREATE OPERATOR %s (PROCEDURE = %s %s %s %s %s %s %s %s %s);\n ",
+ oprinfo[i].oprname,
+ oprinfo[i].oprcode,
+ leftarg,
+ rightarg,
+ commutator,
+ negator,
+ restrict,
+ (strcmp(oprinfo[i].oprcanhash, "t")) ? ", HASHES" : "",
+ join,
+ sortop);
+ } else
+ sprintf(q,
+ "define operator %s (procedure = %s %s %s %s %s %s %s %s %s)\\g\n ",
+ oprinfo[i].oprname,
+ oprinfo[i].oprcode,
+ leftarg,
+ rightarg,
+ commutator,
+ negator,
+ restrict,
+ (strcmp(oprinfo[i].oprcanhash, "t")) ? ", hashes" : "",
+ join,
+ sortop);
+
+ fputs(q,fout);
+ }
+ fflush(fout);
+
+}
+
+/*
+ * dumpAggs
+ * writes out to fout the queries to create all the user-defined aggregates
+ *
+ */
+void
+dumpAggs(FILE* fout, AggInfo* agginfo, int numAggs,
+ TypeInfo *tinfo, int numTypes)
+{
+ int i;
+ char q[MAXQUERYLEN];
+ char sfunc1[MAXQUERYLEN];
+ char sfunc2[MAXQUERYLEN];
+ char finalfunc[MAXQUERYLEN];
+ char *basetype;
+ char *stype1;
+ char *stype2;
+ char comma1[2], comma2[2];
+
+ for (i=0;i
+ /* skip all the builtin oids */
+ if (atoi(agginfo[i].oid) < g_last_builtin_oid)
+ continue;
+
+ if ( strcmp(agginfo[i].aggtransfn1, "-") == 0)
+ sfunc1[0] = '\0';
+ else {
+ sprintf(sfunc1,
+ "sfunc1 = %s, basetype = %s, stype1 = %s",
+ agginfo[i].aggtransfn1,
+ findTypeByOid(tinfo,numTypes,agginfo[i].aggbasetype),
+ findTypeByOid(tinfo,numTypes,agginfo[i].aggtranstype1));
+ if (agginfo[i].agginitval1) {
+ if (g_outputSQL)
+ sprintf(sfunc1, "%s ,INITCOND1 = '%s'",
+ sfunc1, agginfo[i].agginitval1);
+ else
+ sprintf(sfunc1, "%s ,initcond1 = \"%s\"",
+ sfunc1, agginfo[i].agginitval1);
+
+ }
+
+ }
+
+ if ( strcmp(agginfo[i].aggtransfn2, "-") == 0)
+ sfunc2[0] = '\0';
+ else {
+ sprintf(sfunc2,
+ "sfunc2 = %s, stype2 = %s",
+ agginfo[i].aggtransfn2,
+ findTypeByOid(tinfo,numTypes,agginfo[i].aggtranstype2));
+ if (agginfo[i].agginitval2) {
+ if (g_outputSQL)
+ sprintf(sfunc2,"%s ,initcond2 = '%s'",
+ sfunc2, agginfo[i].agginitval2);
+ else
+ sprintf(sfunc2,"%s ,initcond2 = \"%s\"",
+ sfunc2, agginfo[i].agginitval2);
+
+ }
+ }
+
+ if ( strcmp(agginfo[i].aggfinalfn, "-") == 0)
+ finalfunc[0] = '\0';
+ else {
+ sprintf(finalfunc, "finalfunc = %s", agginfo[i].aggfinalfn);
+ }
+ if (sfunc1[0] != '\0' && sfunc2[0] != '\0') {
+ comma1[0] = ','; comma1[1] = '\0';
+ } else
+ comma1[0] = '\0';
+
+ if (finalfunc[0] != '\0' && (sfunc1[0] != '\0' || sfunc2[0] != '\0')) {
+ comma2[0] = ',';comma2[1] = '\0';
+ } else
+ comma2[0] = '\0';
+
+ if (g_outputSQL) {
+ sprintf(q,"CREATE AGGREGATE %s ( %s %s %s %s %s );\n",
+ agginfo[i].aggname,
+ sfunc1,
+ comma1,
+ sfunc2,
+ comma2,
+ finalfunc);
+ } else {
+ sprintf(q,"define aggregate %s ( %s %s %s %s %s )\\g\n",
+ agginfo[i].aggname,
+ sfunc1,
+ comma1,
+ sfunc2,
+ comma2,
+ finalfunc);
+ }
+
+ fputs(q,fout);
+ }
+ fflush(fout);
+}
+
+/*
+ * dumpTables:
+ * write out to fout all the user-define tables
+ */
+
+void
+dumpTables(FILE* fout, TableInfo *tblinfo, int numTables,
+ InhInfo *inhinfo, int numInherits,
+ TypeInfo *tinfo, int numTypes)
+{
+ int i,j,k;
+ char q[MAXQUERYLEN];
+ char **parentRels; /* list of names of parent relations */
+ int numParents;
+ char *res;
+ PortalBuffer *pbuf;
+ int ntups;
+ int actual_atts; /* number of attrs in this CREATE statment */
+ char *archiveMode;
+
+ for (i=0;i
projects / postgresql.git / commitdiff