seqname = DirectFunctionCall1(textin,
CStringGetDatum(args[i]));
newvals[chnattrs] = DirectFunctionCall1(nextval, seqname);
+ /* nextval now returns int64; coerce down to int32 */
+ newvals[chnattrs] = Int32GetDatum((int32) DatumGetInt64(newvals[chnattrs]));
if (DatumGetInt32(newvals[chnattrs]) == 0)
+ {
newvals[chnattrs] = DirectFunctionCall1(nextval, seqname);
+ newvals[chnattrs] = Int32GetDatum((int32) DatumGetInt64(newvals[chnattrs]));
+ }
pfree(DatumGetTextP(seqname));
chnattrs++;
i++;
<!--
-$Header: /cvsroot/pgsql/doc/src/sgml/datatype.sgml,v 1.57 2001/08/07 22:41:49 petere Exp $
+$Header: /cvsroot/pgsql/doc/src/sgml/datatype.sgml,v 1.58 2001/08/16 20:38:53 tgl Exp $
-->
<chapter id="datatype">
<row>
<entry><type>serial</type></entry>
- <entry></entry>
+ <entry><type>serial4</type></entry>
<entry>autoincrementing four-byte integer</entry>
</row>
<row>
+ <entry><type>serial8</type></entry>
+ <entry></entry>
+ <entry>autoincrementing eight-byte integer</entry>
+ </row>
+
+ <row>
<entry><type>text</type></entry>
<entry></entry>
<entry>variable-length character string</entry>
</row>
<row>
- <entry>serial</entry>
+ <entry>serial4</entry>
<entry>4 bytes</entry>
<entry>Identifier or cross-reference</entry>
- <entry>0 to +2147483647</entry>
+ <entry>1 to 2147483647</entry>
+ </row>
+
+ <row>
+ <entry>serial8</entry>
+ <entry>8 bytes</entry>
+ <entry>Identifier or cross-reference</entry>
+ <entry>1 to 9223372036854775807</entry>
</row>
</tbody>
</tgroup>
</para>
<para>
- The <type>bigint</type> type may not be available on all platforms since
- it relies on compiler support for eight-byte integers.
+ The <type>bigint</type> type may not function correctly on all platforms,
+ since it relies on compiler support for eight-byte integers. On a machine
+ without such support, <type>bigint</type> acts the same
+ as <type>integer</type> (but still takes up eight bytes of storage).
</para>
<sect2 id="datatype-serial">
- <title>The Serial Type</title>
+ <title>The Serial Types</title>
<indexterm zone="datatype-serial">
<primary>serial</primary>
</indexterm>
+ <indexterm zone="datatype-serial">
+ <primary>serial4</primary>
+ </indexterm>
+
+ <indexterm zone="datatype-serial">
+ <primary>serial8</primary>
+ </indexterm>
+
<indexterm>
<primary>auto-increment</primary>
<see>serial</see>
</indexterm>
<para>
- The <type>serial</type> type is a special-case type constructed by
- <productname>Postgres</productname> from other existing components.
- It is typically used to create unique identifiers for table entries.
+ The <type>serial</type> datatypes are not truly types, but are a
+ notational convenience for setting up unique identifier columns
+ in tables.
In the current implementation, specifying
<programlisting>
<programlisting>
CREATE SEQUENCE <replaceable class="parameter">tablename</replaceable>_<replaceable class="parameter">colname</replaceable>_seq;
CREATE TABLE <replaceable class="parameter">tablename</replaceable>
- (<replaceable class="parameter">colname</replaceable> integer DEFAULT nextval('<replaceable class="parameter">tablename</replaceable>_<replaceable class="parameter">colname</replaceable>_seq');
-CREATE UNIQUE INDEX <replaceable class="parameter">tablename</replaceable>_<replaceable class="parameter">colname</replaceable>_key on <replaceable class="parameter">tablename</replaceable> (<replaceable class="parameter">colname</replaceable>);
+ (<replaceable class="parameter">colname</replaceable> integer DEFAULT nextval('<replaceable class="parameter">tablename</replaceable>_<replaceable class="parameter">colname</replaceable>_seq') UNIQUE NOT NULL;
</programlisting>
+ Thus, we have created an integer column and arranged for its default
+ values to be assigned from a sequence generator. UNIQUE and NOT NULL
+ constraints are applied to ensure that explicitly-inserted values
+ will never be duplicates, either.
+
<caution>
<para>
The implicit sequence created for the <type>serial</type> type will
table is dropped.
</para>
</caution>
+ </para>
+ <para>
+ The type names <type>serial</type> and <type>serial4</type> are
+ equivalent: both create <type>integer</type> columns. The type
+ name <type>serial8</type> works just the same way, except that it
+ creates a <type>bigint</type> column. <type>serial8</type> should
+ be used if you anticipate use of more than 2^31 identifiers over
+ the lifetime of the table.
+ </para>
+
+ <para>
Implicit sequences supporting the <type>serial</type> are
not automatically dropped when a table containing a serial type
is dropped. So, the following commands executed in order will likely fail:
<!--
-$Header: /cvsroot/pgsql/doc/src/sgml/ref/create_sequence.sgml,v 1.17 2001/06/30 22:01:17 petere Exp $
+$Header: /cvsroot/pgsql/doc/src/sgml/ref/create_sequence.sgml,v 1.18 2001/08/16 20:38:53 tgl Exp $
Postgres documentation
-->
The optional clause <option>MINVALUE
<replaceable class="parameter">minvalue</replaceable></option>
determines the minimum value
- a sequence can generate. The defaults are 1 and -2147483647 for
+ a sequence can generate. The defaults are 1 and -2^63-1 for
ascending and descending sequences, respectively.
</para>
</listitem>
The optional clause <option>MAXVALUE
<replaceable class="parameter">maxvalue</replaceable></option>
determines the maximum
- value for the sequence. The defaults are 2147483647 and -1 for
+ value for the sequence. The defaults are 2^63-1 and -1 for
ascending and descending sequences, respectively.
</para>
</listitem>
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/creatinh.c,v 1.79 2001/08/10 18:57:34 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/creatinh.c,v 1.80 2001/08/16 20:38:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
typename->typmod = attribute->atttypmod;
def->typename = typename;
def->is_not_null = attribute->attnotnull;
- def->is_sequence = false;
def->raw_default = NULL;
def->cooked_default = NULL;
def->constraints = NIL;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/sequence.c,v 1.62 2001/08/10 18:57:34 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/sequence.c,v 1.63 2001/08/16 20:38:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "miscadmin.h"
#include "utils/acl.h"
#include "utils/builtins.h"
+#include "utils/int8.h"
#ifdef MULTIBYTE
#include "mb/pg_wchar.h"
#endif
#define SEQ_MAGIC 0x1717
-#define SEQ_MAXVALUE ((int4)0x7FFFFFFF)
-#define SEQ_MINVALUE -(SEQ_MAXVALUE)
+#ifndef INT64_IS_BUSTED
+#ifdef HAVE_LL_CONSTANTS
+#define SEQ_MAXVALUE ((int64) 0x7FFFFFFFFFFFFFFFLL)
+#else
+#define SEQ_MAXVALUE ((int64) 0x7FFFFFFFFFFFFFFF)
+#endif
+#else /* INT64_IS_BUSTED */
+#define SEQ_MAXVALUE ((int64) 0x7FFFFFFF)
+#endif /* INT64_IS_BUSTED */
+
+#define SEQ_MINVALUE (-SEQ_MAXVALUE)
/*
* We don't want to log each fetching values from sequences,
{
char *name;
Oid relid;
- Relation rel;
- int4 cached;
- int4 last;
- int4 increment;
+ Relation rel; /* NULL if rel is not open in cur xact */
+ int64 cached;
+ int64 last;
+ int64 increment;
struct SeqTableData *next;
} SeqTableData;
static SeqTable init_sequence(char *caller, char *name);
static Form_pg_sequence read_info(char *caller, SeqTable elm, Buffer *buf);
static void init_params(CreateSeqStmt *seq, Form_pg_sequence new);
-static int get_param(DefElem *def);
-static void do_setval(char *seqname, int32 next, bool iscalled);
+static int64 get_param(DefElem *def);
+static void do_setval(char *seqname, int64 next, bool iscalled);
/*
* DefineSequence
value[i - 1] = NameGetDatum(&name);
break;
case SEQ_COL_LASTVAL:
- typnam->name = "int4";
+ typnam->name = "int8";
coldef->colname = "last_value";
- value[i - 1] = Int32GetDatum(new.last_value);
+ value[i - 1] = Int64GetDatumFast(new.last_value);
break;
case SEQ_COL_INCBY:
- typnam->name = "int4";
+ typnam->name = "int8";
coldef->colname = "increment_by";
- value[i - 1] = Int32GetDatum(new.increment_by);
+ value[i - 1] = Int64GetDatumFast(new.increment_by);
break;
case SEQ_COL_MAXVALUE:
- typnam->name = "int4";
+ typnam->name = "int8";
coldef->colname = "max_value";
- value[i - 1] = Int32GetDatum(new.max_value);
+ value[i - 1] = Int64GetDatumFast(new.max_value);
break;
case SEQ_COL_MINVALUE:
- typnam->name = "int4";
+ typnam->name = "int8";
coldef->colname = "min_value";
- value[i - 1] = Int32GetDatum(new.min_value);
+ value[i - 1] = Int64GetDatumFast(new.min_value);
break;
case SEQ_COL_CACHE:
- typnam->name = "int4";
+ typnam->name = "int8";
coldef->colname = "cache_value";
- value[i - 1] = Int32GetDatum(new.cache_value);
+ value[i - 1] = Int64GetDatumFast(new.cache_value);
break;
case SEQ_COL_LOG:
- typnam->name = "int4";
+ typnam->name = "int8";
coldef->colname = "log_cnt";
- value[i - 1] = Int32GetDatum((int32) 1);
+ value[i - 1] = Int64GetDatum((int64) 1);
break;
case SEQ_COL_CYCLE:
- typnam->name = "char";
+ typnam->name = "bool";
coldef->colname = "is_cycled";
- value[i - 1] = CharGetDatum(new.is_cycled);
+ value[i - 1] = BoolGetDatum(new.is_cycled);
break;
case SEQ_COL_CALLED:
- typnam->name = "char";
+ typnam->name = "bool";
coldef->colname = "is_called";
- value[i - 1] = CharGetDatum('f');
+ value[i - 1] = BoolGetDatum(false);
break;
}
stmt->tableElts = lappend(stmt->tableElts, coldef);
Form_pg_sequence newseq = (Form_pg_sequence) GETSTRUCT(tuple);
/* We do not log first nextval call, so "advance" sequence here */
- newseq->is_called = 't';
+ newseq->is_called = true;
newseq->log_cnt = 0;
xlrec.node = rel->rd_node;
rdata[0].next = &(rdata[1]);
rdata[1].buffer = InvalidBuffer;
- rdata[1].data = (char*) tuple->t_data;
+ rdata[1].data = (char *) tuple->t_data;
rdata[1].len = tuple->t_len;
rdata[1].next = NULL;
SeqTable elm;
Buffer buf;
Form_pg_sequence seq;
- int32 incby,
+ int64 incby,
maxv,
minv,
cache,
log,
fetch,
last;
- int32 result,
+ int64 result,
next,
rescnt = 0;
bool logit = false;
if (elm->last != elm->cached) /* some numbers were cached */
{
elm->last += elm->increment;
- PG_RETURN_INT32(elm->last);
+ PG_RETURN_INT64(elm->last);
}
seq = read_info("nextval", elm, &buf); /* lock page' buffer and
fetch = cache = seq->cache_value;
log = seq->log_cnt;
- if (seq->is_called != 't')
+ if (!seq->is_called)
{
rescnt++; /* last_value if not called */
fetch--;
while (fetch) /* try to fetch cache [+ log ] numbers */
{
-
/*
* Check MAXVALUE for ascending sequences and MINVALUE for
* descending sequences
{
if (rescnt > 0)
break; /* stop fetching */
- if (seq->is_cycled != 't')
- elog(ERROR, "%s.nextval: reached MAXVALUE (%d)",
+ if (!seq->is_cycled)
+ elog(ERROR, "%s.nextval: reached MAXVALUE (" INT64_FORMAT ")",
elm->name, maxv);
next = minv;
}
{
if (rescnt > 0)
break; /* stop fetching */
- if (seq->is_cycled != 't')
- elog(ERROR, "%s.nextval: reached MINVALUE (%d)",
+ if (!seq->is_cycled)
+ elog(ERROR, "%s.nextval: reached MINVALUE (" INT64_FORMAT ")",
elm->name, minv);
next = maxv;
}
rdata[0].next = &(rdata[1]);
seq->last_value = next;
- seq->is_called = 't';
+ seq->is_called = true;
seq->log_cnt = 0;
rdata[1].buffer = InvalidBuffer;
rdata[1].data = (char *) page + ((PageHeader) page)->pd_upper;
/* update on-disk data */
seq->last_value = last; /* last fetched number */
- seq->is_called = 't';
+ seq->is_called = true;
Assert(log >= 0);
seq->log_cnt = log; /* how much is logged */
END_CRIT_SECTION();
if (WriteBuffer(buf) == STATUS_ERROR)
elog(ERROR, "%s.nextval: WriteBuffer failed", elm->name);
- PG_RETURN_INT32(result);
+ PG_RETURN_INT64(result);
}
Datum
text *seqin = PG_GETARG_TEXT_P(0);
char *seqname = get_seq_name(seqin);
SeqTable elm;
- int32 result;
+ int64 result;
if (pg_aclcheck(seqname, GetUserId(), ACL_SELECT) != ACLCHECK_OK)
elog(ERROR, "%s.currval: you don't have permissions to read sequence %s",
pfree(seqname);
- PG_RETURN_INT32(result);
+ PG_RETURN_INT64(result);
}
/*
* sequence.
*/
static void
-do_setval(char *seqname, int32 next, bool iscalled)
+do_setval(char *seqname, int64 next, bool iscalled)
{
SeqTable elm;
Buffer buf;
* read tuple */
if ((next < seq->min_value) || (next > seq->max_value))
- elog(ERROR, "%s.setval: value %d is out of bounds (%d,%d)",
+ elog(ERROR, "%s.setval: value " INT64_FORMAT " is out of bounds (" INT64_FORMAT "," INT64_FORMAT ")",
seqname, next, seq->min_value, seq->max_value);
/* save info in local cache */
rdata[0].next = &(rdata[1]);
seq->last_value = next;
- seq->is_called = 't';
+ seq->is_called = true;
seq->log_cnt = 0;
rdata[1].buffer = InvalidBuffer;
rdata[1].data = (char *) page + ((PageHeader) page)->pd_upper;
}
/* save info in sequence relation */
seq->last_value = next; /* last fetched number */
- seq->is_called = iscalled ? 't' : 'f';
+ seq->is_called = iscalled;
seq->log_cnt = (iscalled) ? 0 : 1;
END_CRIT_SECTION();
elog(ERROR, "%s.setval: WriteBuffer failed", seqname);
pfree(seqname);
-
}
/*
setval(PG_FUNCTION_ARGS)
{
text *seqin = PG_GETARG_TEXT_P(0);
- int32 next = PG_GETARG_INT32(1);
+ int64 next = PG_GETARG_INT64(1);
char *seqname = get_seq_name(seqin);
do_setval(seqname, next, true);
- PG_RETURN_INT32(next);
+ PG_RETURN_INT64(next);
}
/*
setval_and_iscalled(PG_FUNCTION_ARGS)
{
text *seqin = PG_GETARG_TEXT_P(0);
- int32 next = PG_GETARG_INT32(1);
+ int64 next = PG_GETARG_INT64(1);
bool iscalled = PG_GETARG_BOOL(2);
char *seqname = get_seq_name(seqin);
do_setval(seqname, next, iscalled);
- PG_RETURN_INT32(next);
+ PG_RETURN_INT64(next);
}
/*
/*
* CloseSequences
- * is calling by xact mgr at commit/abort.
+ * is called by xact mgr at commit/abort.
*/
void
CloseSequences(void)
for (elm = seqtab; elm != (SeqTable) NULL; elm = elm->next)
{
- if (elm->rel != (Relation) NULL) /* opened in current xact */
+ rel = elm->rel;
+ if (rel != (Relation) NULL) /* opened in current xact */
{
- rel = elm->rel;
elm->rel = (Relation) NULL;
heap_close(rel, AccessShareLock);
}
DefElem *cache_value = NULL;
List *option;
- new->is_cycled = 'f';
+ new->is_cycled = false;
foreach(option, seq->options)
{
DefElem *defel = (DefElem *) lfirst(option);
{
if (defel->arg != (Node *) NULL)
elog(ERROR, "DefineSequence: CYCLE ??");
- new->is_cycled = 't';
+ new->is_cycled = true;
}
else
elog(ERROR, "DefineSequence: option \"%s\" not recognized",
if (new->increment_by > 0)
new->max_value = SEQ_MAXVALUE; /* ascending seq */
else
- new->max_value = -1;/* descending seq */
+ new->max_value = -1; /* descending seq */
}
else
new->max_value = get_param(max_value);
new->min_value = get_param(min_value);
if (new->min_value >= new->max_value)
- elog(ERROR, "DefineSequence: MINVALUE (%d) can't be >= MAXVALUE (%d)",
+ elog(ERROR, "DefineSequence: MINVALUE (" INT64_FORMAT ") can't be >= MAXVALUE (" INT64_FORMAT ")",
new->min_value, new->max_value);
if (last_value == (DefElem *) NULL) /* START WITH */
new->last_value = get_param(last_value);
if (new->last_value < new->min_value)
- elog(ERROR, "DefineSequence: START value (%d) can't be < MINVALUE (%d)",
+ elog(ERROR, "DefineSequence: START value (" INT64_FORMAT ") can't be < MINVALUE (" INT64_FORMAT ")",
new->last_value, new->min_value);
if (new->last_value > new->max_value)
- elog(ERROR, "DefineSequence: START value (%d) can't be > MAXVALUE (%d)",
+ elog(ERROR, "DefineSequence: START value (" INT64_FORMAT ") can't be > MAXVALUE (" INT64_FORMAT ")",
new->last_value, new->max_value);
if (cache_value == (DefElem *) NULL) /* CACHE */
new->cache_value = 1;
else if ((new->cache_value = get_param(cache_value)) <= 0)
- elog(ERROR, "DefineSequence: CACHE (%d) can't be <= 0",
+ elog(ERROR, "DefineSequence: CACHE (" INT64_FORMAT ") can't be <= 0",
new->cache_value);
}
-static int
+static int64
get_param(DefElem *def)
{
if (def->arg == (Node *) NULL)
elog(ERROR, "DefineSequence: \"%s\" value unspecified", def->defname);
- if (nodeTag(def->arg) == T_Integer)
- return intVal(def->arg);
+ if (IsA(def->arg, Integer))
+ return (int64) intVal(def->arg);
+ /*
+ * Values too large for int4 will be represented as Float constants
+ * by the lexer. Accept these if they are valid int8 strings.
+ */
+ if (IsA(def->arg, Float))
+ return DatumGetInt64(DirectFunctionCall1(int8in,
+ CStringGetDatum(strVal(def->arg))));
+
+ /* Shouldn't get here unless parser messed up */
elog(ERROR, "DefineSequence: \"%s\" value must be integer", def->defname);
- return -1;
+ return 0; /* not reached; keep compiler quiet */
}
void
PageSetLSN(page, lsn);
PageSetSUI(page, ThisStartUpID);
UnlockAndWriteBuffer(buffer);
-
- return;
}
void
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: view.c,v 1.56 2001/08/12 21:35:18 tgl Exp $
+ * $Id: view.c,v 1.57 2001/08/16 20:38:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
def->typename = typename;
def->is_not_null = false;
- def->is_sequence = false;
def->raw_default = NULL;
def->cooked_default = NULL;
def->constraints = NIL;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.152 2001/08/10 18:57:36 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.153 2001/08/16 20:38:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
newnode->colname = pstrdup(from->colname);
Node_Copy(from, newnode, typename);
newnode->is_not_null = from->is_not_null;
- newnode->is_sequence = from->is_sequence;
Node_Copy(from, newnode, raw_default);
if (from->cooked_default)
newnode->cooked_default = pstrdup(from->cooked_default);
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.100 2001/08/10 18:57:36 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.101 2001/08/16 20:38:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
return false;
if (a->is_not_null != b->is_not_null)
return false;
- if (a->is_sequence != b->is_sequence)
- return false;
if (!equal(a->raw_default, b->raw_default))
return false;
if (!equalstr(a->cooked_default, b->cooked_default))
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.143 2001/08/10 18:57:36 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.144 2001/08/16 20:38:53 tgl Exp $
*
* NOTES
* Every (plan) node in POSTGRES has an associated "out" routine which
_outToken(str, node->colname);
appendStringInfo(str, " :typename ");
_outNode(str, node->typename);
- appendStringInfo(str, " :is_not_null %s :is_sequence %s :raw_default ",
- booltostr(node->is_not_null),
- booltostr(node->is_sequence));
+ appendStringInfo(str, " :is_not_null %s :raw_default ",
+ booltostr(node->is_not_null));
_outNode(str, node->raw_default);
appendStringInfo(str, " :cooked_default ");
_outToken(str, node->cooked_default);
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.194 2001/08/11 00:02:13 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.195 2001/08/16 20:38:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*pkey = NULL;
IndexElem *iparam;
bool saw_nullable;
+ bool is_serial;
q = makeNode(Query);
q->commandType = CMD_UTILITY;
column = (ColumnDef *) element;
columns = lappend(columns, column);
+ /* Check for SERIAL pseudo-types */
+ is_serial = false;
+ if (strcmp(column->typename->name, "serial") == 0 ||
+ strcmp(column->typename->name, "serial4") == 0)
+ {
+ is_serial = true;
+ column->typename->name = pstrdup("int4");
+ }
+ else if (strcmp(column->typename->name, "serial8") == 0)
+ {
+ is_serial = true;
+ column->typename->name = pstrdup("int8");
+ }
+
+ /* Do necessary work on the column type declaration */
transformColumnType(pstate, column);
- /* Special case SERIAL type? */
- if (column->is_sequence)
+ /* Special actions for SERIAL pseudo-types */
+ if (is_serial)
{
char *sname;
char *qstring;
column->constraints = lappend(column->constraints,
constraint);
+ /*
+ * Build a CREATE SEQUENCE command to create the
+ * sequence object, and add it to the list of things
+ * to be done before this CREATE TABLE.
+ */
sequence = makeNode(CreateSeqStmt);
sequence->seqname = pstrdup(sname);
sequence->istemp = stmt->istemp;
sequence->options = NIL;
elog(NOTICE, "CREATE TABLE will create implicit sequence '%s' for SERIAL column '%s.%s'",
- sequence->seqname, stmt->relname, column->colname);
+ sequence->seqname, stmt->relname, column->colname);
blist = lappend(blist, sequence);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.245 2001/08/15 18:42:15 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.246 2001/08/16 20:38:53 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
NEW, NOCREATEDB, NOCREATEUSER, NONE, NOTHING, NOTIFY, NOTNULL,
OFFSET, OIDS, OPERATOR, OWNER, PASSWORD, PROCEDURAL,
REINDEX, RENAME, RESET, RETURNS, ROW, RULE,
- SEQUENCE, SERIAL, SETOF, SHARE, SHOW, START, STATEMENT,
+ SEQUENCE, SETOF, SHARE, SHOW, START, STATEMENT,
STATISTICS, STDIN, STDOUT, SYSID,
TEMP, TEMPLATE, TOAST, TRUNCATE, TRUSTED,
UNLISTEN, UNTIL, VACUUM, VALID, VERBOSE, VERSION
$$ = (Node *)n;
}
- | ColId SERIAL ColQualList opt_collate
- {
- ColumnDef *n = makeNode(ColumnDef);
- n->colname = $1;
- n->typename = makeNode(TypeName);
- n->typename->name = xlateSqlType("integer");
- n->typename->typmod = -1;
- n->is_sequence = TRUE;
- n->constraints = $3;
-
- if ($4 != NULL)
- elog(NOTICE,"CREATE TABLE/COLLATE %s not yet implemented"
- "; clause ignored", $4);
-
- $$ = (Node *)n;
- }
;
ColQualList: ColQualList ColConstraint { $$ = lappend($1, $2); }
| { $$ = NIL; }
;
-OptSeqElem: CACHE IntegerOnly
+OptSeqElem: CACHE NumericOnly
{
$$ = makeNode(DefElem);
$$->defname = "cache";
$$->defname = "cycle";
$$->arg = (Node *)NULL;
}
- | INCREMENT IntegerOnly
+ | INCREMENT NumericOnly
{
$$ = makeNode(DefElem);
$$->defname = "increment";
$$->arg = (Node *)$2;
}
- | MAXVALUE IntegerOnly
+ | MAXVALUE NumericOnly
{
$$ = makeNode(DefElem);
$$->defname = "maxvalue";
$$->arg = (Node *)$2;
}
- | MINVALUE IntegerOnly
+ | MINVALUE NumericOnly
{
$$ = makeNode(DefElem);
$$->defname = "minvalue";
$$->arg = (Node *)$2;
}
- | START IntegerOnly
+ | START NumericOnly
{
$$ = makeNode(DefElem);
$$->defname = "start";
| NATIONAL { $$ = "national"; }
| NONE { $$ = "none"; }
| PATH_P { $$ = "path"; }
- | SERIAL { $$ = "serial"; }
| TIME { $$ = "time"; }
| TIMESTAMP { $$ = "timestamp"; }
;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/keywords.c,v 1.95 2001/08/15 18:42:15 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/keywords.c,v 1.96 2001/08/16 20:38:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{"second", SECOND_P},
{"select", SELECT},
{"sequence", SEQUENCE},
- {"serial", SERIAL},
{"serializable", SERIALIZABLE},
{"session", SESSION},
{"session_user", SESSION_USER},
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_dump.c,v 1.221 2001/08/12 19:02:39 petere Exp $
+ * $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_dump.c,v 1.222 2001/08/16 20:38:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/* First - dump SEQUENCEs */
if (tablename && strlen(tablename) > 0)
{
+ /* XXX this code only works for serial columns named "id" */
+ /* We really need dependency analysis! */
serialSeq = malloc(strlen(tablename) + strlen(serialSeqSuffix) + 1);
strcpy(serialSeq, tablename);
strcat(serialSeq, serialSeqSuffix);
dumpACL(fout, tblinfo[i]);
}
}
- if (tablename)
+ if (serialSeq)
free(serialSeq);
for (i = 0; i < numTables; i++)
dumpSequence(Archive *fout, TableInfo tbinfo, const bool schemaOnly, const bool dataOnly)
{
PGresult *res;
- int4 last,
- incby,
- maxv,
- minv,
- cache;
- char cycled,
+ char *last,
+ *incby,
+ *maxv,
+ *minv,
+ *cache;
+ bool cycled,
called;
- const char *t;
PQExpBuffer query = createPQExpBuffer();
PQExpBuffer delqry = createPQExpBuffer();
exit_nicely();
}
- last = atoi(PQgetvalue(res, 0, 1));
- incby = atoi(PQgetvalue(res, 0, 2));
- maxv = atoi(PQgetvalue(res, 0, 3));
- minv = atoi(PQgetvalue(res, 0, 4));
- cache = atoi(PQgetvalue(res, 0, 5));
- t = PQgetvalue(res, 0, 6);
- cycled = *t;
- t = PQgetvalue(res, 0, 7);
- called = *t;
+ last = PQgetvalue(res, 0, 1);
+ incby = PQgetvalue(res, 0, 2);
+ maxv = PQgetvalue(res, 0, 3);
+ minv = PQgetvalue(res, 0, 4);
+ cache = PQgetvalue(res, 0, 5);
+ cycled = (strcmp(PQgetvalue(res, 0, 6), "t") == 0);
+ called = (strcmp(PQgetvalue(res, 0, 7), "t") == 0);
/*
* The logic we use for restoring sequences is as follows: - Add a
* basic CREATE SEQUENCE statement (use last_val for start if called
- * with 'f', else use min_val for start_val).
+ * is false, else use min_val for start_val).
*
* Add a 'SETVAL(seq, last_val, iscalled)' at restore-time iff
* we load data
if (!dataOnly)
{
- PQclear(res);
-
resetPQExpBuffer(delqry);
- appendPQExpBuffer(delqry, "DROP SEQUENCE %s;\n", fmtId(tbinfo.relname, force_quotes));
+ appendPQExpBuffer(delqry, "DROP SEQUENCE %s;\n",
+ fmtId(tbinfo.relname, force_quotes));
resetPQExpBuffer(query);
appendPQExpBuffer(query,
- "CREATE SEQUENCE %s start %d increment %d maxvalue %d "
- "minvalue %d cache %d %s;\n",
+ "CREATE SEQUENCE %s start %s increment %s "
+ "maxvalue %s minvalue %s cache %s%s;\n",
fmtId(tbinfo.relname, force_quotes),
- (called == 't') ? minv : last,
+ (called ? minv : last),
incby, maxv, minv, cache,
- (cycled == 't') ? "cycle" : "");
+ (cycled ? " cycle" : ""));
ArchiveEntry(fout, tbinfo.oid, tbinfo.relname, "SEQUENCE", NULL,
- query->data, delqry->data, "", tbinfo.usename, NULL, NULL);
+ query->data, delqry->data, "", tbinfo.usename,
+ NULL, NULL);
}
if (!schemaOnly)
resetPQExpBuffer(query);
appendPQExpBuffer(query, "SELECT setval (");
formatStringLiteral(query, fmtId(tbinfo.relname, force_quotes), CONV_ALL);
- appendPQExpBuffer(query, ", %d, '%c');\n", last, called);
+ appendPQExpBuffer(query, ", %s, %s);\n",
+ last, (called ? "true" : "false"));
ArchiveEntry(fout, tbinfo.oid, tbinfo.relname, "SEQUENCE SET", NULL,
query->data, "" /* Del */ , "", "", NULL, NULL);
"pg_class", 0, NULL);
}
+ PQclear(res);
+
destroyPQExpBuffer(query);
destroyPQExpBuffer(delqry);
}
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: catversion.h,v 1.89 2001/08/14 22:21:58 tgl Exp $
+ * $Id: catversion.h,v 1.90 2001/08/16 20:38:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*/
/* yyyymmddN */
-#define CATALOG_VERSION_NO 200108132
+#define CATALOG_VERSION_NO 200108151
#endif
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_proc.h,v 1.205 2001/08/15 07:07:40 ishii Exp $
+ * $Id: pg_proc.h,v 1.206 2001/08/16 20:38:54 tgl Exp $
*
* NOTES
* The script catalog/genbki.sh reads this file and generates .bki
/* SEQUENCEs nextval & currval functions */
-DATA(insert OID = 1574 ( nextval PGUID 12 f t f t 1 f 23 "25" 100 0 0 100 nextval - ));
+DATA(insert OID = 1574 ( nextval PGUID 12 f t f t 1 f 20 "25" 100 0 0 100 nextval - ));
DESCR("sequence next value");
-DATA(insert OID = 1575 ( currval PGUID 12 f t f t 1 f 23 "25" 100 0 0 100 currval - ));
+DATA(insert OID = 1575 ( currval PGUID 12 f t f t 1 f 20 "25" 100 0 0 100 currval - ));
DESCR("sequence current value");
-DATA(insert OID = 1576 ( setval PGUID 12 f t f t 2 f 23 "25 23" 100 0 0 100 setval - ));
+DATA(insert OID = 1576 ( setval PGUID 12 f t f t 2 f 20 "25 20" 100 0 0 100 setval - ));
DESCR("set sequence value");
-DATA(insert OID = 1765 ( setval PGUID 12 f t f t 3 f 23 "25 23 16" 100 0 0 100 setval_and_iscalled - ));
+DATA(insert OID = 1765 ( setval PGUID 12 f t f t 3 f 20 "25 20 16" 100 0 0 100 setval_and_iscalled - ));
DESCR("set sequence value and iscalled status");
DATA(insert OID = 1579 ( varbit_in PGUID 12 f t t t 1 f 1562 "0" 100 0 0 100 varbit_in - ));
* sequence.h
* prototypes for sequence.c.
*
+ * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: sequence.h,v 1.16 2001/08/16 20:38:55 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/parsenodes.h"
#include "access/xlog.h"
+/*
+ * On a machine with no 64-bit-int C datatype, sizeof(int64) will not be 8,
+ * but we need this struct type to line up with the way that a sequence
+ * table is defined --- and pg_type will say that int8 is 8 bytes anyway.
+ * So, we need padding. Ugly but necessary.
+ */
typedef struct FormData_pg_sequence
{
NameData sequence_name;
+#ifndef INT64_IS_BUSTED
+ int64 last_value;
+ int64 increment_by;
+ int64 max_value;
+ int64 min_value;
+ int64 cache_value;
+ int64 log_cnt;
+#else
int32 last_value;
+ int32 pad1;
int32 increment_by;
+ int32 pad2;
int32 max_value;
+ int32 pad3;
int32 min_value;
+ int32 pad4;
int32 cache_value;
+ int32 pad5;
int32 log_cnt;
- char is_cycled;
- char is_called;
+ int32 pad6;
+#endif
+ bool is_cycled;
+ bool is_called;
} FormData_pg_sequence;
typedef FormData_pg_sequence *Form_pg_sequence;
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parsenodes.h,v 1.140 2001/08/10 18:57:41 tgl Exp $
+ * $Id: parsenodes.h,v 1.141 2001/08/16 20:38:55 tgl Exp $
*
*-------------------------------------------------------------------------
*/
NodeTag type;
char *colname; /* name of column */
TypeName *typename; /* type of column */
- bool is_not_null; /* flag to NOT NULL constraint */
- bool is_sequence; /* is a sequence? */
+ bool is_not_null; /* NOT NULL constraint specified? */
Node *raw_default; /* default value (untransformed parse
* tree) */
char *cooked_default; /* nodeToString representation */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/ecpg/preproc/keywords.c,v 1.42 2001/07/16 05:07:00 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/ecpg/preproc/keywords.c,v 1.43 2001/08/16 20:38:55 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{"second", SECOND_P},
{"select", SELECT},
{"sequence", SEQUENCE},
- {"serial", SERIAL},
{"serializable", SERIALIZABLE},
{"session", SESSION},
{"session_user", SESSION_USER},
MINVALUE, MODE, MOVE, NEW, NOCREATEDB, NOCREATEUSER,
NONE, NOTHING, NOTIFY, NOTNULL, OFFSET, OIDS,
OPERATOR, OWNER, PASSWORD, PROCEDURAL, REINDEX, RENAME, RESET,
- RETURNS, ROW, RULE, SEQUENCE, SERIAL, SETOF, SHARE,
+ RETURNS, ROW, RULE, SEQUENCE, SETOF, SHARE,
SHOW, START, STATEMENT, STATISTICS, STDIN, STDOUT, SYSID TEMP,
TEMPLATE, TOAST, TRUNCATE, TRUSTED, UNLISTEN, UNTIL, VACUUM,
VALID, VERBOSE, VERSION
}
$$ = cat_str(4, $1, $2, $3, $4);
}
- | ColId SERIAL ColQualList opt_collate
- {
- if (strlen($4) > 0)
- {
- sprintf(errortext, "CREATE TABLE/COLLATE %s not yet implemented; clause ignored", $4);
- mmerror(ET_NOTICE, errortext);
- }
- $$ = cat_str(4, $1, make_str(" serial "), $3, $4);
- }
;
ColQualList: ColQualList ColConstraint { $$ = cat2_str($1,$2); }
| NATIONAL { $$ = make_str("national"); }
| NONE { $$ = make_str("none"); }
| PATH_P { $$ = make_str("path_p"); }
- | SERIAL { $$ = make_str("serial"); }
| TIME { $$ = make_str("time"); }
| TIMESTAMP { $$ = make_str("timestamp"); }
| ECPGKeywords { $$ = $1; }
rtest_nothn1 | rtest_nothn_r2 | CREATE RULE rtest_nothn_r2 AS ON INSERT TO rtest_nothn1 WHERE ((new.a >= 30) AND (new.a < 40)) DO INSTEAD NOTHING;
rtest_nothn2 | rtest_nothn_r3 | CREATE RULE rtest_nothn_r3 AS ON INSERT TO rtest_nothn2 WHERE (new.a >= 100) DO INSTEAD INSERT INTO rtest_nothn3 (a, b) VALUES (new.a, new.b);
rtest_nothn2 | rtest_nothn_r4 | CREATE RULE rtest_nothn_r4 AS ON INSERT TO rtest_nothn2 DO INSTEAD NOTHING;
- rtest_order1 | rtest_order_r1 | CREATE RULE rtest_order_r1 AS ON INSERT TO rtest_order1 DO INSTEAD INSERT INTO rtest_order2 (a, b, c) VALUES (new.a, nextval('rtest_seq'::text), 'rule 1 - this should run 3rd or 4th'::text);
- rtest_order1 | rtest_order_r2 | CREATE RULE rtest_order_r2 AS ON INSERT TO rtest_order1 DO INSERT INTO rtest_order2 (a, b, c) VALUES (new.a, nextval('rtest_seq'::text), 'rule 2 - this should run 1st'::text);
- rtest_order1 | rtest_order_r3 | CREATE RULE rtest_order_r3 AS ON INSERT TO rtest_order1 DO INSTEAD INSERT INTO rtest_order2 (a, b, c) VALUES (new.a, nextval('rtest_seq'::text), 'rule 3 - this should run 3rd or 4th'::text);
- rtest_order1 | rtest_order_r4 | CREATE RULE rtest_order_r4 AS ON INSERT TO rtest_order1 WHERE (new.a < 100) DO INSTEAD INSERT INTO rtest_order2 (a, b, c) VALUES (new.a, nextval('rtest_seq'::text), 'rule 4 - this should run 2nd'::text);
+ rtest_order1 | rtest_order_r1 | CREATE RULE rtest_order_r1 AS ON INSERT TO rtest_order1 DO INSTEAD INSERT INTO rtest_order2 (a, b, c) VALUES (new.a, int4(nextval('rtest_seq'::text)), 'rule 1 - this should run 3rd or 4th'::text);
+ rtest_order1 | rtest_order_r2 | CREATE RULE rtest_order_r2 AS ON INSERT TO rtest_order1 DO INSERT INTO rtest_order2 (a, b, c) VALUES (new.a, int4(nextval('rtest_seq'::text)), 'rule 2 - this should run 1st'::text);
+ rtest_order1 | rtest_order_r3 | CREATE RULE rtest_order_r3 AS ON INSERT TO rtest_order1 DO INSTEAD INSERT INTO rtest_order2 (a, b, c) VALUES (new.a, int4(nextval('rtest_seq'::text)), 'rule 3 - this should run 3rd or 4th'::text);
+ rtest_order1 | rtest_order_r4 | CREATE RULE rtest_order_r4 AS ON INSERT TO rtest_order1 WHERE (new.a < 100) DO INSTEAD INSERT INTO rtest_order2 (a, b, c) VALUES (new.a, int4(nextval('rtest_seq'::text)), 'rule 4 - this should run 2nd'::text);
rtest_person | rtest_pers_del | CREATE RULE rtest_pers_del AS ON DELETE TO rtest_person DO DELETE FROM rtest_admin WHERE (rtest_admin.pname = old.pname);
rtest_person | rtest_pers_upd | CREATE RULE rtest_pers_upd AS ON UPDATE TO rtest_person DO UPDATE rtest_admin SET pname = new.pname WHERE (rtest_admin.pname = old.pname);
rtest_system | rtest_sys_del | CREATE RULE rtest_sys_del AS ON DELETE TO rtest_system DO (DELETE FROM rtest_interface WHERE (rtest_interface.sysname = old.sysname); DELETE FROM rtest_admin WHERE (rtest_admin.sysname = old.sysname); );
/*
- * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.47 2001/03/22 04:01:44 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.48 2001/08/16 20:38:56 tgl Exp $
*/
#include "postgres.h"
newoff = DirectFunctionCall1(nextval,
PointerGetDatum(seqname));
+ /* nextval now returns int64; coerce down to int32 */
+ newoff = Int32GetDatum((int32) DatumGetInt64(newoff));
pfree(seqname);
}
OSDN Git Service
