int S_size;
int I_size;
int B_size;
- symbol **S;
+ symbol **S;
int *I;
symbol *B;
};
static struct among a_0[1] =
{
- /* 0 */ {5, s_0_0, -1, -1, 0}
+ /* 0 */ {5, s_0_0, -1, -1, 0}
};
static symbol s_1_0[3] = {'i', 'e', 'd'};
static struct among a_1[6] =
{
- /* 0 */ {3, s_1_0, -1, 2, 0},
- /* 1 */ {1, s_1_1, -1, 3, 0},
- /* 2 */ {3, s_1_2, 1, 2, 0},
- /* 3 */ {4, s_1_3, 1, 1, 0},
- /* 4 */ {2, s_1_4, 1, -1, 0},
- /* 5 */ {2, s_1_5, 1, -1, 0}
+ /* 0 */ {3, s_1_0, -1, 2, 0},
+ /* 1 */ {1, s_1_1, -1, 3, 0},
+ /* 2 */ {3, s_1_2, 1, 2, 0},
+ /* 3 */ {4, s_1_3, 1, 1, 0},
+ /* 4 */ {2, s_1_4, 1, -1, 0},
+ /* 5 */ {2, s_1_5, 1, -1, 0}
};
static symbol s_2_1[2] = {'b', 'b'};
static struct among a_2[13] =
{
- /* 0 */ {0, 0, -1, 3, 0},
- /* 1 */ {2, s_2_1, 0, 2, 0},
- /* 2 */ {2, s_2_2, 0, 2, 0},
- /* 3 */ {2, s_2_3, 0, 2, 0},
- /* 4 */ {2, s_2_4, 0, 2, 0},
- /* 5 */ {2, s_2_5, 0, 1, 0},
- /* 6 */ {2, s_2_6, 0, 2, 0},
- /* 7 */ {2, s_2_7, 0, 2, 0},
- /* 8 */ {2, s_2_8, 0, 2, 0},
- /* 9 */ {2, s_2_9, 0, 2, 0},
+ /* 0 */ {0, 0, -1, 3, 0},
+ /* 1 */ {2, s_2_1, 0, 2, 0},
+ /* 2 */ {2, s_2_2, 0, 2, 0},
+ /* 3 */ {2, s_2_3, 0, 2, 0},
+ /* 4 */ {2, s_2_4, 0, 2, 0},
+ /* 5 */ {2, s_2_5, 0, 1, 0},
+ /* 6 */ {2, s_2_6, 0, 2, 0},
+ /* 7 */ {2, s_2_7, 0, 2, 0},
+ /* 8 */ {2, s_2_8, 0, 2, 0},
+ /* 9 */ {2, s_2_9, 0, 2, 0},
/* 10 */ {2, s_2_10, 0, 1, 0},
/* 11 */ {2, s_2_11, 0, 2, 0},
/* 12 */ {2, s_2_12, 0, 1, 0}
static struct among a_3[6] =
{
- /* 0 */ {2, s_3_0, -1, 2, 0},
- /* 1 */ {3, s_3_1, 0, 1, 0},
- /* 2 */ {3, s_3_2, -1, 2, 0},
- /* 3 */ {4, s_3_3, -1, 2, 0},
- /* 4 */ {5, s_3_4, 3, 1, 0},
- /* 5 */ {5, s_3_5, -1, 2, 0}
+ /* 0 */ {2, s_3_0, -1, 2, 0},
+ /* 1 */ {3, s_3_1, 0, 1, 0},
+ /* 2 */ {3, s_3_2, -1, 2, 0},
+ /* 3 */ {4, s_3_3, -1, 2, 0},
+ /* 4 */ {5, s_3_4, 3, 1, 0},
+ /* 5 */ {5, s_3_5, -1, 2, 0}
};
static symbol s_4_0[4] = {'a', 'n', 'c', 'i'};
static struct among a_4[24] =
{
- /* 0 */ {4, s_4_0, -1, 3, 0},
- /* 1 */ {4, s_4_1, -1, 2, 0},
- /* 2 */ {3, s_4_2, -1, 13, 0},
- /* 3 */ {2, s_4_3, -1, 16, 0},
- /* 4 */ {3, s_4_4, 3, 12, 0},
- /* 5 */ {4, s_4_5, 4, 4, 0},
- /* 6 */ {4, s_4_6, 3, 8, 0},
- /* 7 */ {5, s_4_7, 3, 14, 0},
- /* 8 */ {6, s_4_8, 3, 15, 0},
- /* 9 */ {5, s_4_9, 3, 10, 0},
+ /* 0 */ {4, s_4_0, -1, 3, 0},
+ /* 1 */ {4, s_4_1, -1, 2, 0},
+ /* 2 */ {3, s_4_2, -1, 13, 0},
+ /* 3 */ {2, s_4_3, -1, 16, 0},
+ /* 4 */ {3, s_4_4, 3, 12, 0},
+ /* 5 */ {4, s_4_5, 4, 4, 0},
+ /* 6 */ {4, s_4_6, 3, 8, 0},
+ /* 7 */ {5, s_4_7, 3, 14, 0},
+ /* 8 */ {6, s_4_8, 3, 15, 0},
+ /* 9 */ {5, s_4_9, 3, 10, 0},
/* 10 */ {5, s_4_10, 3, 5, 0},
/* 11 */ {5, s_4_11, -1, 8, 0},
/* 12 */ {6, s_4_12, -1, 12, 0},
static struct among a_5[9] =
{
- /* 0 */ {5, s_5_0, -1, 4, 0},
- /* 1 */ {5, s_5_1, -1, 6, 0},
- /* 2 */ {5, s_5_2, -1, 3, 0},
- /* 3 */ {5, s_5_3, -1, 4, 0},
- /* 4 */ {4, s_5_4, -1, 4, 0},
- /* 5 */ {6, s_5_5, -1, 1, 0},
- /* 6 */ {7, s_5_6, 5, 2, 0},
- /* 7 */ {3, s_5_7, -1, 5, 0},
- /* 8 */ {4, s_5_8, -1, 5, 0}
+ /* 0 */ {5, s_5_0, -1, 4, 0},
+ /* 1 */ {5, s_5_1, -1, 6, 0},
+ /* 2 */ {5, s_5_2, -1, 3, 0},
+ /* 3 */ {5, s_5_3, -1, 4, 0},
+ /* 4 */ {4, s_5_4, -1, 4, 0},
+ /* 5 */ {6, s_5_5, -1, 1, 0},
+ /* 6 */ {7, s_5_6, 5, 2, 0},
+ /* 7 */ {3, s_5_7, -1, 5, 0},
+ /* 8 */ {4, s_5_8, -1, 5, 0}
};
static symbol s_6_0[2] = {'i', 'c'};
static struct among a_6[18] =
{
- /* 0 */ {2, s_6_0, -1, 1, 0},
- /* 1 */ {4, s_6_1, -1, 1, 0},
- /* 2 */ {4, s_6_2, -1, 1, 0},
- /* 3 */ {4, s_6_3, -1, 1, 0},
- /* 4 */ {4, s_6_4, -1, 1, 0},
- /* 5 */ {3, s_6_5, -1, 1, 0},
- /* 6 */ {3, s_6_6, -1, 1, 0},
- /* 7 */ {3, s_6_7, -1, 1, 0},
- /* 8 */ {3, s_6_8, -1, 1, 0},
- /* 9 */ {2, s_6_9, -1, 1, 0},
+ /* 0 */ {2, s_6_0, -1, 1, 0},
+ /* 1 */ {4, s_6_1, -1, 1, 0},
+ /* 2 */ {4, s_6_2, -1, 1, 0},
+ /* 3 */ {4, s_6_3, -1, 1, 0},
+ /* 4 */ {4, s_6_4, -1, 1, 0},
+ /* 5 */ {3, s_6_5, -1, 1, 0},
+ /* 6 */ {3, s_6_6, -1, 1, 0},
+ /* 7 */ {3, s_6_7, -1, 1, 0},
+ /* 8 */ {3, s_6_8, -1, 1, 0},
+ /* 9 */ {2, s_6_9, -1, 1, 0},
/* 10 */ {3, s_6_10, -1, 1, 0},
/* 11 */ {3, s_6_11, -1, 2, 0},
/* 12 */ {2, s_6_12, -1, 1, 0},
static struct among a_7[2] =
{
- /* 0 */ {1, s_7_0, -1, 1, 0},
- /* 1 */ {1, s_7_1, -1, 2, 0}
+ /* 0 */ {1, s_7_0, -1, 1, 0},
+ /* 1 */ {1, s_7_1, -1, 2, 0}
};
static symbol s_8_0[7] = {'s', 'u', 'c', 'c', 'e', 'e', 'd'};
static struct among a_8[8] =
{
- /* 0 */ {7, s_8_0, -1, -1, 0},
- /* 1 */ {7, s_8_1, -1, -1, 0},
- /* 2 */ {6, s_8_2, -1, -1, 0},
- /* 3 */ {7, s_8_3, -1, -1, 0},
- /* 4 */ {6, s_8_4, -1, -1, 0},
- /* 5 */ {7, s_8_5, -1, -1, 0},
- /* 6 */ {7, s_8_6, -1, -1, 0},
- /* 7 */ {6, s_8_7, -1, -1, 0}
+ /* 0 */ {7, s_8_0, -1, -1, 0},
+ /* 1 */ {7, s_8_1, -1, -1, 0},
+ /* 2 */ {6, s_8_2, -1, -1, 0},
+ /* 3 */ {7, s_8_3, -1, -1, 0},
+ /* 4 */ {6, s_8_4, -1, -1, 0},
+ /* 5 */ {7, s_8_5, -1, -1, 0},
+ /* 6 */ {7, s_8_6, -1, -1, 0},
+ /* 7 */ {6, s_8_7, -1, -1, 0}
};
static symbol s_9_0[5] = {'a', 'n', 'd', 'e', 's'};
static struct among a_9[18] =
{
- /* 0 */ {5, s_9_0, -1, -1, 0},
- /* 1 */ {5, s_9_1, -1, -1, 0},
- /* 2 */ {4, s_9_2, -1, -1, 0},
- /* 3 */ {6, s_9_3, -1, -1, 0},
- /* 4 */ {5, s_9_4, -1, 3, 0},
- /* 5 */ {5, s_9_5, -1, 9, 0},
- /* 6 */ {6, s_9_6, -1, 7, 0},
- /* 7 */ {4, s_9_7, -1, -1, 0},
- /* 8 */ {4, s_9_8, -1, 6, 0},
- /* 9 */ {5, s_9_9, -1, 4, 0},
+ /* 0 */ {5, s_9_0, -1, -1, 0},
+ /* 1 */ {5, s_9_1, -1, -1, 0},
+ /* 2 */ {4, s_9_2, -1, -1, 0},
+ /* 3 */ {6, s_9_3, -1, -1, 0},
+ /* 4 */ {5, s_9_4, -1, 3, 0},
+ /* 5 */ {5, s_9_5, -1, 9, 0},
+ /* 6 */ {6, s_9_6, -1, 7, 0},
+ /* 7 */ {4, s_9_7, -1, -1, 0},
+ /* 8 */ {4, s_9_8, -1, 6, 0},
+ /* 9 */ {5, s_9_9, -1, 4, 0},
/* 10 */ {4, s_9_10, -1, -1, 0},
/* 11 */ {4, s_9_11, -1, 10, 0},
/* 12 */ {6, s_9_12, -1, 11, 0},
return 1;
}
-extern struct SN_env *english_create_env(void)
+extern struct SN_env *
+english_create_env(void)
{
return SN_create_env(0, 2, 1);
}
-extern void english_close_env(struct SN_env * z)
+extern void
+english_close_env(struct SN_env * z)
{
SN_close_env(z);
}
static struct among a_0[9] =
{
- /* 0 */ {3, s_0_0, -1, 1, 0},
- /* 1 */ {4, s_0_1, 0, 2, 0},
- /* 2 */ {4, s_0_2, 0, 2, 0},
- /* 3 */ {1, s_0_3, -1, 1, 0},
- /* 4 */ {2, s_0_4, 3, 2, 0},
- /* 5 */ {2, s_0_5, 3, 2, 0},
- /* 6 */ {5, s_0_6, -1, 1, 0},
- /* 7 */ {6, s_0_7, 6, 2, 0},
- /* 8 */ {6, s_0_8, 6, 2, 0}
+ /* 0 */ {3, s_0_0, -1, 1, 0},
+ /* 1 */ {4, s_0_1, 0, 2, 0},
+ /* 2 */ {4, s_0_2, 0, 2, 0},
+ /* 3 */ {1, s_0_3, -1, 1, 0},
+ /* 4 */ {2, s_0_4, 3, 2, 0},
+ /* 5 */ {2, s_0_5, 3, 2, 0},
+ /* 6 */ {5, s_0_6, -1, 1, 0},
+ /* 7 */ {6, s_0_7, 6, 2, 0},
+ /* 8 */ {6, s_0_8, 6, 2, 0}
};
static symbol s_1_0[2] = {192, 192};
static struct among a_1[26] =
{
- /* 0 */ {2, s_1_0, -1, 1, 0},
- /* 1 */ {2, s_1_1, -1, 1, 0},
- /* 2 */ {2, s_1_2, -1, 1, 0},
- /* 3 */ {2, s_1_3, -1, 1, 0},
- /* 4 */ {2, s_1_4, -1, 1, 0},
- /* 5 */ {2, s_1_5, -1, 1, 0},
- /* 6 */ {2, s_1_6, -1, 1, 0},
- /* 7 */ {2, s_1_7, -1, 1, 0},
- /* 8 */ {2, s_1_8, -1, 1, 0},
- /* 9 */ {2, s_1_9, -1, 1, 0},
+ /* 0 */ {2, s_1_0, -1, 1, 0},
+ /* 1 */ {2, s_1_1, -1, 1, 0},
+ /* 2 */ {2, s_1_2, -1, 1, 0},
+ /* 3 */ {2, s_1_3, -1, 1, 0},
+ /* 4 */ {2, s_1_4, -1, 1, 0},
+ /* 5 */ {2, s_1_5, -1, 1, 0},
+ /* 6 */ {2, s_1_6, -1, 1, 0},
+ /* 7 */ {2, s_1_7, -1, 1, 0},
+ /* 8 */ {2, s_1_8, -1, 1, 0},
+ /* 9 */ {2, s_1_9, -1, 1, 0},
/* 10 */ {3, s_1_10, -1, 1, 0},
/* 11 */ {3, s_1_11, -1, 1, 0},
/* 12 */ {2, s_1_12, -1, 1, 0},
static struct among a_2[8] =
{
- /* 0 */ {2, s_2_0, -1, 1, 0},
- /* 1 */ {2, s_2_1, -1, 1, 0},
- /* 2 */ {2, s_2_2, -1, 1, 0},
- /* 3 */ {3, s_2_3, 2, 2, 0},
- /* 4 */ {3, s_2_4, 2, 2, 0},
- /* 5 */ {1, s_2_5, -1, 1, 0},
- /* 6 */ {2, s_2_6, 5, 1, 0},
- /* 7 */ {3, s_2_7, 6, 2, 0}
+ /* 0 */ {2, s_2_0, -1, 1, 0},
+ /* 1 */ {2, s_2_1, -1, 1, 0},
+ /* 2 */ {2, s_2_2, -1, 1, 0},
+ /* 3 */ {3, s_2_3, 2, 2, 0},
+ /* 4 */ {3, s_2_4, 2, 2, 0},
+ /* 5 */ {1, s_2_5, -1, 1, 0},
+ /* 6 */ {2, s_2_6, 5, 1, 0},
+ /* 7 */ {3, s_2_7, 6, 2, 0}
};
static symbol s_3_0[2] = {211, 209};
static struct among a_3[2] =
{
- /* 0 */ {2, s_3_0, -1, 1, 0},
- /* 1 */ {2, s_3_1, -1, 1, 0}
+ /* 0 */ {2, s_3_0, -1, 1, 0},
+ /* 1 */ {2, s_3_1, -1, 1, 0}
};
static symbol s_4_0[1] = {192};
static struct among a_4[46] =
{
- /* 0 */ {1, s_4_0, -1, 2, 0},
- /* 1 */ {2, s_4_1, 0, 2, 0},
- /* 2 */ {2, s_4_2, -1, 1, 0},
- /* 3 */ {3, s_4_3, 2, 2, 0},
- /* 4 */ {3, s_4_4, 2, 2, 0},
- /* 5 */ {2, s_4_5, -1, 1, 0},
- /* 6 */ {3, s_4_6, 5, 2, 0},
- /* 7 */ {3, s_4_7, -1, 1, 0},
- /* 8 */ {3, s_4_8, -1, 2, 0},
- /* 9 */ {3, s_4_9, -1, 1, 0},
+ /* 0 */ {1, s_4_0, -1, 2, 0},
+ /* 1 */ {2, s_4_1, 0, 2, 0},
+ /* 2 */ {2, s_4_2, -1, 1, 0},
+ /* 3 */ {3, s_4_3, 2, 2, 0},
+ /* 4 */ {3, s_4_4, 2, 2, 0},
+ /* 5 */ {2, s_4_5, -1, 1, 0},
+ /* 6 */ {3, s_4_6, 5, 2, 0},
+ /* 7 */ {3, s_4_7, -1, 1, 0},
+ /* 8 */ {3, s_4_8, -1, 2, 0},
+ /* 9 */ {3, s_4_9, -1, 1, 0},
/* 10 */ {4, s_4_10, 9, 2, 0},
/* 11 */ {4, s_4_11, 9, 2, 0},
/* 12 */ {2, s_4_12, -1, 1, 0},
static struct among a_5[36] =
{
- /* 0 */ {1, s_5_0, -1, 1, 0},
- /* 1 */ {2, s_5_1, 0, 1, 0},
- /* 2 */ {2, s_5_2, 0, 1, 0},
- /* 3 */ {1, s_5_3, -1, 1, 0},
- /* 4 */ {1, s_5_4, -1, 1, 0},
- /* 5 */ {2, s_5_5, 4, 1, 0},
- /* 6 */ {2, s_5_6, 4, 1, 0},
- /* 7 */ {2, s_5_7, -1, 1, 0},
- /* 8 */ {2, s_5_8, -1, 1, 0},
- /* 9 */ {3, s_5_9, 8, 1, 0},
+ /* 0 */ {1, s_5_0, -1, 1, 0},
+ /* 1 */ {2, s_5_1, 0, 1, 0},
+ /* 2 */ {2, s_5_2, 0, 1, 0},
+ /* 3 */ {1, s_5_3, -1, 1, 0},
+ /* 4 */ {1, s_5_4, -1, 1, 0},
+ /* 5 */ {2, s_5_5, 4, 1, 0},
+ /* 6 */ {2, s_5_6, 4, 1, 0},
+ /* 7 */ {2, s_5_7, -1, 1, 0},
+ /* 8 */ {2, s_5_8, -1, 1, 0},
+ /* 9 */ {3, s_5_9, 8, 1, 0},
/* 10 */ {1, s_5_10, -1, 1, 0},
/* 11 */ {2, s_5_11, 10, 1, 0},
/* 12 */ {2, s_5_12, 10, 1, 0},
static struct among a_6[2] =
{
- /* 0 */ {3, s_6_0, -1, 1, 0},
- /* 1 */ {4, s_6_1, -1, 1, 0}
+ /* 0 */ {3, s_6_0, -1, 1, 0},
+ /* 1 */ {4, s_6_1, -1, 1, 0}
};
static symbol s_7_0[4] = {197, 202, 219, 197};
static struct among a_7[4] =
{
- /* 0 */ {4, s_7_0, -1, 1, 0},
- /* 1 */ {1, s_7_1, -1, 2, 0},
- /* 2 */ {1, s_7_2, -1, 3, 0},
- /* 3 */ {3, s_7_3, -1, 1, 0}
+ /* 0 */ {4, s_7_0, -1, 1, 0},
+ /* 1 */ {1, s_7_1, -1, 2, 0},
+ /* 2 */ {1, s_7_2, -1, 3, 0},
+ /* 3 */ {3, s_7_3, -1, 1, 0}
};
static unsigned char g_v[] = {35, 130, 34, 18};
return 1;
}
-extern struct SN_env *russian_create_env(void)
+extern struct SN_env *
+russian_create_env(void)
{
return SN_create_env(0, 2, 0);
}
-extern void russian_close_env(struct SN_env * z)
+extern void
+russian_close_env(struct SN_env * z)
{
SN_close_env(z);
}
return p;
}
-extern void lose_s(symbol * p)
+extern void
+lose_s(symbol * p)
{
free((char *) p - HEAD);
}
STATSTRPTR(stat) + a->pos,
STRPTR(txt) + b->pos,
a->len
- );
+ );
return (a->len > b->len) ? 1 : -1;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/contrib/vacuumlo/vacuumlo.c,v 1.23 2003/08/08 20:20:49 momjian Exp $
+ * $Header: /cvsroot/pgsql/contrib/vacuumlo/vacuumlo.c,v 1.24 2003/08/08 21:41:25 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*
* NOTE: we ignore system tables and temp tables by the expedient of
* rejecting tables in schemas named 'pg_*'. In particular, the temp
- * table formed above is ignored, and pg_largeobject will be too.
- * If either of these were scanned, obviously we'd end up with nothing
- * to delete...
+ * table formed above is ignored, and pg_largeobject will be too. If
+ * either of these were scanned, obviously we'd end up with nothing to
+ * delete...
*
* NOTE: the system oid column is ignored, as it has attnum < 1. This
* shouldn't matter for correctness, but it saves time.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.69 2003/08/04 02:39:57 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.70 2003/08/08 21:41:25 momjian Exp $
*
* INTERFACE ROUTINES
* index_open - open an index relation by relation OID
*/
IndexBulkDeleteResult *
index_vacuum_cleanup(Relation indexRelation,
- IndexVacuumCleanupInfo * info,
+ IndexVacuumCleanupInfo *info,
IndexBulkDeleteResult *stats)
{
RegProcedure procedure;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.68 2003/08/04 02:39:57 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.69 2003/08/08 21:41:27 momjian Exp $
*
* NOTES
* Postgres btree pages look like ordinary relation pages. The opaque
_bt_wrtbuf(rel, lbuf);
/*
- * If parent became half dead, recurse to try to delete it.
- * Otherwise, if right sibling is empty and is now the last child of
- * the parent, recurse to try to delete it. (These cases cannot apply
- * at the same time, though the second case might itself recurse to
- * the first.)
+ * If parent became half dead, recurse to try to delete it. Otherwise,
+ * if right sibling is empty and is now the last child of the parent,
+ * recurse to try to delete it. (These cases cannot apply at the same
+ * time, though the second case might itself recurse to the first.)
*/
if (parent_half_dead)
{
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.79 2003/08/04 02:39:57 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.80 2003/08/08 21:41:27 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* If this isn't the page we want, walk right till we find what we
- * want --- but go no more than four hops (an arbitrary limit).
- * If we don't find the correct page by then, the most likely bet
- * is that the original page got deleted and isn't in the sibling
+ * want --- but go no more than four hops (an arbitrary limit). If
+ * we don't find the correct page by then, the most likely bet is
+ * that the original page got deleted and isn't in the sibling
* chain at all anymore, not that its left sibling got split more
* than four times.
*
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtxlog.c,v 1.5 2003/08/04 02:39:57 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtxlog.c,v 1.6 2003/08/08 21:41:27 momjian Exp $
*
*-------------------------------------------------------------------------
*/
BlockNumber leftblk; /* left half of split */
BlockNumber rightblk; /* right half of split */
bool is_root; /* we split the root */
-} bt_incomplete_split;
+} bt_incomplete_split;
static List *incomplete_splits;
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/access/transam/slru.c,v 1.5 2003/08/08 14:39:45 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/slru.c,v 1.6 2003/08/08 21:41:27 momjian Exp $
*
*-------------------------------------------------------------------------
*/
SLRU_PAGE_CLEAN, /* page is valid and not dirty */
SLRU_PAGE_DIRTY, /* page is valid but needs write */
SLRU_PAGE_WRITE_IN_PROGRESS /* page is being written out */
-} SlruPageStatus;
+} SlruPageStatus;
/*
* Shared-memory state
* swapping out the latest page.
*/
int latest_page_number;
-} SlruSharedData;
+} SlruSharedData;
typedef SlruSharedData *SlruShared;
SLRU_SEEK_FAILED,
SLRU_READ_FAILED,
SLRU_WRITE_FAILED
-} SlruErrorCause;
+} SlruErrorCause;
static SlruErrorCause slru_errcause;
static int slru_errno;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.151 2003/08/04 02:39:57 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.152 2003/08/08 21:41:28 momjian Exp $
*
* NOTES
* Transaction aborts can now occur two ways:
*
* The ordering of operations is not entirely random. The idea is:
* release resources visible to other backends (eg, files, buffer
- * pins); then release locks; then release backend-local resources.
- * We want to release locks at the point where any backend waiting for
- * us will see our transaction as being fully cleaned up.
+ * pins); then release locks; then release backend-local resources. We
+ * want to release locks at the point where any backend waiting for us
+ * will see our transaction as being fully cleaned up.
*/
smgrDoPendingDeletes(true);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.114 2003/08/04 02:39:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.115 2003/08/08 21:41:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
Oid tableOid;
Oid indexOid;
-} RelToCluster;
+} RelToCluster;
-static void cluster_rel(RelToCluster * rv, bool recheck);
+static void cluster_rel(RelToCluster *rv, bool recheck);
static Oid make_new_heap(Oid OIDOldHeap, const char *NewName);
static void copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex);
static List *get_indexattr_list(Relation OldHeap, Oid OldIndex);
* them incrementally while we load the table.
*/
static void
-cluster_rel(RelToCluster * rvtc, bool recheck)
+cluster_rel(RelToCluster *rvtc, bool recheck)
{
Relation OldHeap,
OldIndex;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.207 2003/08/04 02:39:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.208 2003/08/08 21:41:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
COPY_FILE, /* to/from file */
COPY_OLD_FE, /* to/from frontend (old protocol) */
COPY_NEW_FE /* to/from frontend (new protocol) */
-} CopyDest;
+} CopyDest;
/*
* Represents the type of data returned by CopyReadAttribute()
EOL_NL,
EOL_CR,
EOL_CRNL
-} EolType;
+} EolType;
/* non-export function prototypes */
* Portions Copyright (c) 1994-5, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.113 2003/08/04 02:39:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.114 2003/08/08 21:41:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
TupOutputState *tstate);
static double elapsed_time(struct timeval * starttime);
static void explain_outNode(StringInfo str,
- Plan *plan, PlanState * planstate,
+ Plan *plan, PlanState *planstate,
Plan *outer_plan,
int indent, ExplainState *es);
static void show_scan_qual(List *qual, bool is_or_qual, const char *qlabel,
*/
static void
explain_outNode(StringInfo str,
- Plan *plan, PlanState * planstate,
+ Plan *plan, PlanState *planstate,
Plan *outer_plan,
int indent, ExplainState *es)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/portalcmds.c,v 1.22 2003/08/06 17:46:45 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/portalcmds.c,v 1.23 2003/08/08 21:41:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* Execute SQL DECLARE CURSOR command.
*/
void
-PerformCursorOpen(DeclareCursorStmt * stmt)
+PerformCursorOpen(DeclareCursorStmt *stmt)
{
List *rewritten;
Query *query;
* Copyright (c) 2002-2003, PostgreSQL Global Development Group
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/prepare.c,v 1.22 2003/08/04 00:43:16 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/prepare.c,v 1.23 2003/08/08 21:41:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* Note: the result is created or copied into current memory context.
*/
TupleDesc
-FetchPreparedStatementResultDesc(PreparedStatement * stmt)
+FetchPreparedStatementResultDesc(PreparedStatement *stmt)
{
Query *query;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/sequence.c,v 1.101 2003/08/04 02:39:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/sequence.c,v 1.102 2003/08/08 21:41:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* Modify the defition of a sequence relation
*/
void
-AlterSequence(AlterSeqStmt * stmt)
+AlterSequence(AlterSeqStmt *stmt)
{
SeqTable elm;
Relation seqrel;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/tablecmds.c,v 1.78 2003/08/04 02:39:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/tablecmds.c,v 1.79 2003/08/08 21:41:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
bool created_in_cur_xact;
bool deleted_in_cur_xact;
-} OnCommitItem;
+} OnCommitItem;
static List *on_commits = NIL;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/trigger.c,v 1.155 2003/08/04 02:39:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/trigger.c,v 1.156 2003/08/08 21:41:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
DeferredTriggerEvent deftrig_events;
DeferredTriggerEvent deftrig_events_imm;
DeferredTriggerEvent deftrig_event_tail;
-} DeferredTriggersData;
+} DeferredTriggersData;
/* ----------
* deftrig_events, deftrig_event_tail:
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/typecmds.c,v 1.42 2003/08/04 02:39:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/typecmds.c,v 1.43 2003/08/08 21:41:32 momjian Exp $
*
* DESCRIPTION
* The "DefineFoo" routines take the parse tree and pick out the
int natts; /* number of attributes of interest */
int *atts; /* attribute numbers */
/* atts[] is of allocated length RelationGetNumberOfAttributes(rel) */
-} RelToCheck;
+} RelToCheck;
static Oid findTypeInputFunction(List *procname, Oid typeOid);
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/executor/execAmi.c,v 1.74 2003/08/04 02:39:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execAmi.c,v 1.75 2003/08/08 21:41:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* ----------------------------------------------------------------
*/
void
-ExecReScan(PlanState * node, ExprContext *exprCtxt)
+ExecReScan(PlanState *node, ExprContext *exprCtxt)
{
/* If collecting timing stats, update them */
if (node->instrument)
* Marks the current scan position.
*/
void
-ExecMarkPos(PlanState * node)
+ExecMarkPos(PlanState *node)
{
switch (nodeTag(node))
{
* restores the scan position previously saved with ExecMarkPos()
*/
void
-ExecRestrPos(PlanState * node)
+ExecRestrPos(PlanState *node)
{
switch (nodeTag(node))
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execGrouping.c,v 1.6 2003/08/04 02:39:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execGrouping.c,v 1.7 2003/08/08 21:41:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
Assert(entrysize >= sizeof(TupleHashEntryData));
tabsize = sizeof(TupleHashTableData) +
- (nbuckets - 1) * sizeof(TupleHashEntry);
+ (nbuckets - 1) *sizeof(TupleHashEntry);
hashtable = (TupleHashTable) MemoryContextAllocZero(tablecxt, tabsize);
hashtable->numCols = numCols;
* Iterator state must be initialized with ResetTupleHashIterator() macro.
*/
TupleHashEntry
-ScanTupleHashTable(TupleHashTable hashtable, TupleHashIterator * state)
+ScanTupleHashTable(TupleHashTable hashtable, TupleHashIterator *state)
{
TupleHashEntry entry;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.215 2003/08/06 17:46:45 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.216 2003/08/08 21:41:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
Index resultRelationIndex,
List *rangeTable,
CmdType operation);
-static TupleTableSlot *ExecutePlan(EState *estate, PlanState * planstate,
+static TupleTableSlot *ExecutePlan(EState *estate, PlanState *planstate,
CmdType operation,
long numberTuples,
ScanDirection direction,
* ----------------------------------------------------------------
*/
void
-ExecEndPlan(PlanState * planstate, EState *estate)
+ExecEndPlan(PlanState *planstate, EState *estate)
{
ResultRelInfo *resultRelInfo;
int i;
*/
static TupleTableSlot *
ExecutePlan(EState *estate,
- PlanState * planstate,
+ PlanState *planstate,
CmdType operation,
long numberTuples,
ScanDirection direction,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execProcnode.c,v 1.39 2003/08/04 02:39:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execProcnode.c,v 1.40 2003/08/08 21:41:39 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* ----------------------------------------------------------------
*/
TupleTableSlot *
-ExecProcNode(PlanState * node)
+ExecProcNode(PlanState *node)
{
TupleTableSlot *result;
* ----------------------------------------------------------------
*/
void
-ExecEndNode(PlanState * node)
+ExecEndNode(PlanState *node)
{
List *subp;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.140 2003/08/04 02:39:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.141 2003/08/08 21:41:39 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* static function decls */
-static Datum ExecEvalAggref(AggrefExprState * aggref,
+static Datum ExecEvalAggref(AggrefExprState *aggref,
ExprContext *econtext,
bool *isNull);
-static Datum ExecEvalArrayRef(ArrayRefExprState * astate,
+static Datum ExecEvalArrayRef(ArrayRefExprState *astate,
ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
static Datum ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull);
static Datum ExecEvalParam(Param *expression, ExprContext *econtext,
bool *isNull);
-static Datum ExecEvalFunc(FuncExprState * fcache, ExprContext *econtext,
+static Datum ExecEvalFunc(FuncExprState *fcache, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
-static Datum ExecEvalOper(FuncExprState * fcache, ExprContext *econtext,
+static Datum ExecEvalOper(FuncExprState *fcache, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
-static Datum ExecEvalDistinct(FuncExprState * fcache, ExprContext *econtext,
+static Datum ExecEvalDistinct(FuncExprState *fcache, ExprContext *econtext,
bool *isNull);
-static Datum ExecEvalScalarArrayOp(ScalarArrayOpExprState * sstate,
+static Datum ExecEvalScalarArrayOp(ScalarArrayOpExprState *sstate,
ExprContext *econtext, bool *isNull);
static ExprDoneCond ExecEvalFuncArgs(FunctionCallInfo fcinfo,
List *argList, ExprContext *econtext);
-static Datum ExecEvalNot(BoolExprState * notclause, ExprContext *econtext,
+static Datum ExecEvalNot(BoolExprState *notclause, ExprContext *econtext,
bool *isNull);
-static Datum ExecEvalOr(BoolExprState * orExpr, ExprContext *econtext,
+static Datum ExecEvalOr(BoolExprState *orExpr, ExprContext *econtext,
bool *isNull);
-static Datum ExecEvalAnd(BoolExprState * andExpr, ExprContext *econtext,
+static Datum ExecEvalAnd(BoolExprState *andExpr, ExprContext *econtext,
bool *isNull);
-static Datum ExecEvalCase(CaseExprState * caseExpr, ExprContext *econtext,
+static Datum ExecEvalCase(CaseExprState *caseExpr, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
-static Datum ExecEvalArray(ArrayExprState * astate,
+static Datum ExecEvalArray(ArrayExprState *astate,
ExprContext *econtext,
bool *isNull);
-static Datum ExecEvalCoalesce(CoalesceExprState * coalesceExpr,
+static Datum ExecEvalCoalesce(CoalesceExprState *coalesceExpr,
ExprContext *econtext,
bool *isNull);
-static Datum ExecEvalNullIf(FuncExprState * nullIfExpr, ExprContext *econtext,
+static Datum ExecEvalNullIf(FuncExprState *nullIfExpr, ExprContext *econtext,
bool *isNull);
-static Datum ExecEvalNullTest(GenericExprState * nstate,
+static Datum ExecEvalNullTest(GenericExprState *nstate,
ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
-static Datum ExecEvalBooleanTest(GenericExprState * bstate,
+static Datum ExecEvalBooleanTest(GenericExprState *bstate,
ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
-static Datum ExecEvalCoerceToDomain(CoerceToDomainState * cstate,
+static Datum ExecEvalCoerceToDomain(CoerceToDomainState *cstate,
ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
-static Datum ExecEvalCoerceToDomainValue(CoerceToDomainValue * conVal,
+static Datum ExecEvalCoerceToDomainValue(CoerceToDomainValue *conVal,
ExprContext *econtext, bool *isNull);
-static Datum ExecEvalFieldSelect(GenericExprState * fstate,
+static Datum ExecEvalFieldSelect(GenericExprState *fstate,
ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
*----------
*/
static Datum
-ExecEvalArrayRef(ArrayRefExprState * astate,
+ExecEvalArrayRef(ArrayRefExprState *astate,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
* ----------------------------------------------------------------
*/
static Datum
-ExecEvalAggref(AggrefExprState * aggref, ExprContext *econtext, bool *isNull)
+ExecEvalAggref(AggrefExprState *aggref, ExprContext *econtext, bool *isNull)
{
if (econtext->ecxt_aggvalues == NULL) /* safety check */
elog(ERROR, "no aggregates in this expression context");
* init_fcache - initialize a FuncExprState node during first use
*/
void
-init_fcache(Oid foid, FuncExprState * fcache, MemoryContext fcacheCxt)
+init_fcache(Oid foid, FuncExprState *fcache, MemoryContext fcacheCxt)
{
AclResult aclresult;
* Evaluate the arguments to a function and then the function itself.
*/
Datum
-ExecMakeFunctionResult(FuncExprState * fcache,
+ExecMakeFunctionResult(FuncExprState *fcache,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
* object. (If function returns an empty set, we just return NULL instead.)
*/
Tuplestorestate *
-ExecMakeTableFunctionResult(ExprState * funcexpr,
+ExecMakeTableFunctionResult(ExprState *funcexpr,
ExprContext *econtext,
TupleDesc expectedDesc,
TupleDesc *returnDesc)
* ----------------------------------------------------------------
*/
static Datum
-ExecEvalFunc(FuncExprState * fcache,
+ExecEvalFunc(FuncExprState *fcache,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
* ----------------------------------------------------------------
*/
static Datum
-ExecEvalOper(FuncExprState * fcache,
+ExecEvalOper(FuncExprState *fcache,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
* ----------------------------------------------------------------
*/
static Datum
-ExecEvalDistinct(FuncExprState * fcache,
+ExecEvalDistinct(FuncExprState *fcache,
ExprContext *econtext,
bool *isNull)
{
* the result is known.
*/
static Datum
-ExecEvalScalarArrayOp(ScalarArrayOpExprState * sstate,
+ExecEvalScalarArrayOp(ScalarArrayOpExprState *sstate,
ExprContext *econtext, bool *isNull)
{
ScalarArrayOpExpr *opexpr = (ScalarArrayOpExpr *) sstate->fxprstate.xprstate.expr;
* ----------------------------------------------------------------
*/
static Datum
-ExecEvalNot(BoolExprState * notclause, ExprContext *econtext, bool *isNull)
+ExecEvalNot(BoolExprState *notclause, ExprContext *econtext, bool *isNull)
{
ExprState *clause;
Datum expr_value;
* ----------------------------------------------------------------
*/
static Datum
-ExecEvalOr(BoolExprState * orExpr, ExprContext *econtext, bool *isNull)
+ExecEvalOr(BoolExprState *orExpr, ExprContext *econtext, bool *isNull)
{
List *clauses;
List *clause;
* ----------------------------------------------------------------
*/
static Datum
-ExecEvalAnd(BoolExprState * andExpr, ExprContext *econtext, bool *isNull)
+ExecEvalAnd(BoolExprState *andExpr, ExprContext *econtext, bool *isNull)
{
List *clauses;
List *clause;
* ----------------------------------------------------------------
*/
static Datum
-ExecEvalCase(CaseExprState * caseExpr, ExprContext *econtext,
+ExecEvalCase(CaseExprState *caseExpr, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone)
{
List *clauses;
* ----------------------------------------------------------------
*/
static Datum
-ExecEvalArray(ArrayExprState * astate, ExprContext *econtext,
+ExecEvalArray(ArrayExprState *astate, ExprContext *econtext,
bool *isNull)
{
ArrayExpr *arrayExpr = (ArrayExpr *) astate->xprstate.expr;
* ----------------------------------------------------------------
*/
static Datum
-ExecEvalCoalesce(CoalesceExprState * coalesceExpr, ExprContext *econtext,
+ExecEvalCoalesce(CoalesceExprState *coalesceExpr, ExprContext *econtext,
bool *isNull)
{
List *arg;
* ----------------------------------------------------------------
*/
static Datum
-ExecEvalNullIf(FuncExprState * fcache, ExprContext *econtext,
+ExecEvalNullIf(FuncExprState *fcache, ExprContext *econtext,
bool *isNull)
{
Datum result;
* ----------------------------------------------------------------
*/
static Datum
-ExecEvalNullTest(GenericExprState * nstate,
+ExecEvalNullTest(GenericExprState *nstate,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
* ----------------------------------------------------------------
*/
static Datum
-ExecEvalBooleanTest(GenericExprState * bstate,
+ExecEvalBooleanTest(GenericExprState *bstate,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
* datum) otherwise throw an error.
*/
static Datum
-ExecEvalCoerceToDomain(CoerceToDomainState * cstate, ExprContext *econtext,
+ExecEvalCoerceToDomain(CoerceToDomainState *cstate, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone)
{
CoerceToDomain *ctest = (CoerceToDomain *) cstate->xprstate.expr;
* Return the value stored by CoerceToDomain.
*/
static Datum
-ExecEvalCoerceToDomainValue(CoerceToDomainValue * conVal,
+ExecEvalCoerceToDomainValue(CoerceToDomainValue *conVal,
ExprContext *econtext, bool *isNull)
{
*isNull = econtext->domainValue_isNull;
* ----------------------------------------------------------------
*/
static Datum
-ExecEvalFieldSelect(GenericExprState * fstate,
+ExecEvalFieldSelect(GenericExprState *fstate,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
* ----------------------------------------------------------------
*/
Datum
-ExecEvalExpr(ExprState * expression,
+ExecEvalExpr(ExprState *expression,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
* Same as above, but get into the right allocation context explicitly.
*/
Datum
-ExecEvalExprSwitchContext(ExprState * expression,
+ExecEvalExprSwitchContext(ExprState *expression,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone)
* This case should usually come through ExecPrepareExpr, not directly here.
*/
ExprState *
-ExecInitExpr(Expr *node, PlanState * parent)
+ExecInitExpr(Expr *node, PlanState *parent)
{
ExprState *state;
* subplan list.
*/
SubPlanState *
-ExecInitExprInitPlan(SubPlan *node, PlanState * parent)
+ExecInitExprInitPlan(SubPlan *node, PlanState *parent)
{
SubPlanState *sstate = makeNode(SubPlanState);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execScan.c,v 1.26 2003/08/08 14:39:45 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execScan.c,v 1.27 2003/08/08 21:41:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* ----------------------------------------------------------------
*/
TupleTableSlot *
-ExecScan(ScanState * node,
+ExecScan(ScanState *node,
ExecScanAccessMtd accessMtd) /* function returning a tuple */
{
EState *estate;
* ExecAssignScanType must have been called already.
*/
void
-ExecAssignScanProjectionInfo(ScanState * node)
+ExecAssignScanProjectionInfo(ScanState *node)
{
Scan *scan = (Scan *) node->ps.plan;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execTuples.c,v 1.70 2003/08/06 17:46:45 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execTuples.c,v 1.71 2003/08/08 21:41:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* ----------------
*/
void
-ExecInitResultTupleSlot(EState *estate, PlanState * planstate)
+ExecInitResultTupleSlot(EState *estate, PlanState *planstate)
{
INIT_SLOT_DEFS;
INIT_SLOT_ALLOC;
* ----------------
*/
void
-ExecInitScanTupleSlot(EState *estate, ScanState * scanstate)
+ExecInitScanTupleSlot(EState *estate, ScanState *scanstate)
{
INIT_SLOT_DEFS;
INIT_SLOT_ALLOC;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.102 2003/08/04 02:39:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.103 2003/08/08 21:41:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* ----------------
*/
void
-ExecAssignExprContext(EState *estate, PlanState * planstate)
+ExecAssignExprContext(EState *estate, PlanState *planstate)
{
planstate->ps_ExprContext = CreateExprContext(estate);
}
* ----------------
*/
void
-ExecAssignResultType(PlanState * planstate,
+ExecAssignResultType(PlanState *planstate,
TupleDesc tupDesc, bool shouldFree)
{
TupleTableSlot *slot = planstate->ps_ResultTupleSlot;
* ----------------
*/
void
-ExecAssignResultTypeFromOuterPlan(PlanState * planstate)
+ExecAssignResultTypeFromOuterPlan(PlanState *planstate)
{
PlanState *outerPlan;
TupleDesc tupDesc;
* ----------------
*/
void
-ExecAssignResultTypeFromTL(PlanState * planstate)
+ExecAssignResultTypeFromTL(PlanState *planstate)
{
bool hasoid = false;
TupleDesc tupDesc;
* ----------------
*/
TupleDesc
-ExecGetResultType(PlanState * planstate)
+ExecGetResultType(PlanState *planstate)
{
TupleTableSlot *slot = planstate->ps_ResultTupleSlot;
* ----------------
*/
void
-ExecAssignProjectionInfo(PlanState * planstate)
+ExecAssignProjectionInfo(PlanState *planstate)
{
planstate->ps_ProjInfo =
ExecBuildProjectionInfo(planstate->targetlist,
* ----------------
*/
void
-ExecFreeExprContext(PlanState * planstate)
+ExecFreeExprContext(PlanState *planstate)
{
ExprContext *econtext;
* ----------------
*/
TupleDesc
-ExecGetScanType(ScanState * scanstate)
+ExecGetScanType(ScanState *scanstate)
{
TupleTableSlot *slot = scanstate->ss_ScanTupleSlot;
* ----------------
*/
void
-ExecAssignScanType(ScanState * scanstate,
+ExecAssignScanType(ScanState *scanstate,
TupleDesc tupDesc, bool shouldFree)
{
TupleTableSlot *slot = scanstate->ss_ScanTupleSlot;
* ----------------
*/
void
-ExecAssignScanTypeFromOuterPlan(ScanState * scanstate)
+ExecAssignScanTypeFromOuterPlan(ScanState *scanstate)
{
PlanState *outerPlan;
TupleDesc tupDesc;
* Add changed parameters to a plan node's chgParam set
*/
void
-UpdateChangedParamSet(PlanState * node, Bitmapset * newchg)
+UpdateChangedParamSet(PlanState *node, Bitmapset *newchg)
{
Bitmapset *parmset;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeAgg.c,v 1.114 2003/08/04 02:39:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeAgg.c,v 1.115 2003/08/08 21:41:41 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* later input value. Only the first non-NULL input will be
* auto-substituted.
*/
-} AggStatePerGroupData;
+} AggStatePerGroupData;
/*
* To implement hashed aggregation, we need a hashtable that stores a
TupleHashEntryData shared; /* common header for hash table entries */
/* per-aggregate transition status array - must be last! */
AggStatePerGroupData pergroup[1]; /* VARIABLE LENGTH ARRAY */
-} AggHashEntryData; /* VARIABLE LENGTH STRUCT */
+} AggHashEntryData; /* VARIABLE LENGTH STRUCT */
static void initialize_aggregates(AggState *aggstate,
Assert(node->numGroups > 0);
entrysize = sizeof(AggHashEntryData) +
- (aggstate->numaggs - 1) * sizeof(AggStatePerGroupData);
+ (aggstate->numaggs - 1) *sizeof(AggStatePerGroupData);
aggstate->hashtable = BuildTupleHashTable(node->numCols,
node->grpColIdx,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeHashjoin.c,v 1.55 2003/08/04 02:39:59 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeHashjoin.c,v 1.56 2003/08/08 21:41:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/memutils.h"
-static TupleTableSlot *ExecHashJoinOuterGetTuple(PlanState * node,
+static TupleTableSlot *ExecHashJoinOuterGetTuple(PlanState *node,
HashJoinState *hjstate);
static TupleTableSlot *ExecHashJoinGetSavedTuple(HashJoinState *hjstate,
BufFile *file,
*/
static TupleTableSlot *
-ExecHashJoinOuterGetTuple(PlanState * node, HashJoinState *hjstate)
+ExecHashJoinOuterGetTuple(PlanState *node, HashJoinState *hjstate)
{
HashJoinTable hashtable = hjstate->hj_HashTable;
int curbatch = hashtable->curbatch;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.60 2003/08/04 02:39:59 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.61 2003/08/08 21:41:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
static void
MJFormSkipQuals(List *qualList, List **ltQuals, List **gtQuals,
- PlanState * parent)
+ PlanState *parent)
{
List *ltexprs,
*gtexprs,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeSeqscan.c,v 1.45 2003/08/04 02:39:59 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeSeqscan.c,v 1.46 2003/08/08 21:41:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "executor/nodeSeqscan.h"
#include "parser/parsetree.h"
-static void InitScanRelation(SeqScanState * node, EState *estate);
-static TupleTableSlot *SeqNext(SeqScanState * node);
+static void InitScanRelation(SeqScanState *node, EState *estate);
+static TupleTableSlot *SeqNext(SeqScanState *node);
/* ----------------------------------------------------------------
* Scan Support
* ----------------------------------------------------------------
*/
static TupleTableSlot *
-SeqNext(SeqScanState * node)
+SeqNext(SeqScanState *node)
{
HeapTuple tuple;
HeapScanDesc scandesc;
*/
TupleTableSlot *
-ExecSeqScan(SeqScanState * node)
+ExecSeqScan(SeqScanState *node)
{
/*
* use SeqNext as access method
* ----------------------------------------------------------------
*/
static void
-InitScanRelation(SeqScanState * node, EState *estate)
+InitScanRelation(SeqScanState *node, EState *estate)
{
Index relid;
List *rangeTable;
* ----------------------------------------------------------------
*/
void
-ExecEndSeqScan(SeqScanState * node)
+ExecEndSeqScan(SeqScanState *node)
{
Relation relation;
HeapScanDesc scanDesc;
* ----------------------------------------------------------------
*/
void
-ExecSeqReScan(SeqScanState * node, ExprContext *exprCtxt)
+ExecSeqReScan(SeqScanState *node, ExprContext *exprCtxt)
{
EState *estate;
Index scanrelid;
* ----------------------------------------------------------------
*/
void
-ExecSeqMarkPos(SeqScanState * node)
+ExecSeqMarkPos(SeqScanState *node)
{
HeapScanDesc scan;
* ----------------------------------------------------------------
*/
void
-ExecSeqRestrPos(SeqScanState * node)
+ExecSeqRestrPos(SeqScanState *node)
{
HeapScanDesc scan;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeSubplan.c,v 1.53 2003/08/04 02:39:59 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeSubplan.c,v 1.54 2003/08/08 21:41:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/lsyscache.h"
-static Datum ExecHashSubPlan(SubPlanState * node,
+static Datum ExecHashSubPlan(SubPlanState *node,
ExprContext *econtext,
bool *isNull);
-static Datum ExecScanSubPlan(SubPlanState * node,
+static Datum ExecScanSubPlan(SubPlanState *node,
ExprContext *econtext,
bool *isNull);
-static void buildSubPlanHash(SubPlanState * node);
+static void buildSubPlanHash(SubPlanState *node);
static bool findPartialMatch(TupleHashTable hashtable, TupleTableSlot *slot);
static bool tupleAllNulls(HeapTuple tuple);
* ----------------------------------------------------------------
*/
Datum
-ExecSubPlan(SubPlanState * node,
+ExecSubPlan(SubPlanState *node,
ExprContext *econtext,
bool *isNull)
{
* ExecHashSubPlan: store subselect result in an in-memory hash table
*/
static Datum
-ExecHashSubPlan(SubPlanState * node,
+ExecHashSubPlan(SubPlanState *node,
ExprContext *econtext,
bool *isNull)
{
* ExecScanSubPlan: default case where we have to rescan subplan each time
*/
static Datum
-ExecScanSubPlan(SubPlanState * node,
+ExecScanSubPlan(SubPlanState *node,
ExprContext *econtext,
bool *isNull)
{
* buildSubPlanHash: load hash table by scanning subplan output.
*/
static void
-buildSubPlanHash(SubPlanState * node)
+buildSubPlanHash(SubPlanState *node)
{
SubPlan *subplan = (SubPlan *) node->xprstate.expr;
PlanState *planstate = node->planstate;
* ----------------------------------------------------------------
*/
void
-ExecInitSubPlan(SubPlanState * node, EState *estate)
+ExecInitSubPlan(SubPlanState *node, EState *estate)
{
SubPlan *subplan = (SubPlan *) node->xprstate.expr;
EState *sp_estate;
* ----------------------------------------------------------------
*/
void
-ExecSetParamPlan(SubPlanState * node, ExprContext *econtext)
+ExecSetParamPlan(SubPlanState *node, ExprContext *econtext)
{
SubPlan *subplan = (SubPlan *) node->xprstate.expr;
PlanState *planstate = node->planstate;
* ----------------------------------------------------------------
*/
void
-ExecEndSubPlan(SubPlanState * node)
+ExecEndSubPlan(SubPlanState *node)
{
if (node->needShutdown)
{
* Mark an initplan as needing recalculation
*/
void
-ExecReScanSetParamPlan(SubPlanState * node, PlanState * parent)
+ExecReScanSetParamPlan(SubPlanState *node, PlanState *parent)
{
PlanState *planstate = node->planstate;
SubPlan *subplan = (SubPlan *) node->xprstate.expr;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/spi.c,v 1.102 2003/08/08 19:18:21 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/spi.c,v 1.103 2003/08/08 21:41:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
_SPI_cursor_operation(Portal portal, bool forward, int count,
DestReceiver *dest)
{
- long nfetched;
+ long nfetched;
/* Check that the portal is valid */
if (!PortalIsValid(portal))
* Think not to combine this store with the preceding function call.
* If the portal contains calls to functions that use SPI, then
* SPI_stack is likely to move around while the portal runs. When
- * control returns, _SPI_current will point to the correct stack entry...
- * but the pointer may be different than it was beforehand. So we must
- * be sure to re-fetch the pointer after the function call completes.
+ * control returns, _SPI_current will point to the correct stack
+ * entry... but the pointer may be different than it was beforehand.
+ * So we must be sure to re-fetch the pointer after the function call
+ * completes.
*/
_SPI_current->processed = nfetched;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/tstoreReceiver.c,v 1.9 2003/08/06 17:46:45 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/tstoreReceiver.c,v 1.10 2003/08/08 21:41:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
DestReceiver pub;
Tuplestorestate *tstore;
MemoryContext cxt;
-} TStoreState;
+} TStoreState;
/*
* Copyright (c) 2003, PostgreSQL Global Development Group
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/bitmapset.c,v 1.4 2003/08/04 00:43:18 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/bitmapset.c,v 1.5 2003/08/08 21:41:43 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* bms_copy - make a palloc'd copy of a bitmapset
*/
Bitmapset *
-bms_copy(const Bitmapset * a)
+bms_copy(const Bitmapset *a)
{
Bitmapset *result;
size_t size;
* be reported as equal to a palloc'd value containing no members.
*/
bool
-bms_equal(const Bitmapset * a, const Bitmapset * b)
+bms_equal(const Bitmapset *a, const Bitmapset *b)
{
const Bitmapset *shorter;
const Bitmapset *longer;
* Same as pfree except for allowing NULL input
*/
void
-bms_free(Bitmapset * a)
+bms_free(Bitmapset *a)
{
if (a)
pfree(a);
* bms_union - set union
*/
Bitmapset *
-bms_union(const Bitmapset * a, const Bitmapset * b)
+bms_union(const Bitmapset *a, const Bitmapset *b)
{
Bitmapset *result;
const Bitmapset *other;
* bms_intersect - set intersection
*/
Bitmapset *
-bms_intersect(const Bitmapset * a, const Bitmapset * b)
+bms_intersect(const Bitmapset *a, const Bitmapset *b)
{
Bitmapset *result;
const Bitmapset *other;
* bms_difference - set difference (ie, A without members of B)
*/
Bitmapset *
-bms_difference(const Bitmapset * a, const Bitmapset * b)
+bms_difference(const Bitmapset *a, const Bitmapset *b)
{
Bitmapset *result;
int shortlen;
* bms_is_subset - is A a subset of B?
*/
bool
-bms_is_subset(const Bitmapset * a, const Bitmapset * b)
+bms_is_subset(const Bitmapset *a, const Bitmapset *b)
{
int shortlen;
int longlen;
* bms_is_member - is X a member of A?
*/
bool
-bms_is_member(int x, const Bitmapset * a)
+bms_is_member(int x, const Bitmapset *a)
{
int wordnum,
bitnum;
* bms_overlap - do sets overlap (ie, have a nonempty intersection)?
*/
bool
-bms_overlap(const Bitmapset * a, const Bitmapset * b)
+bms_overlap(const Bitmapset *a, const Bitmapset *b)
{
int shortlen;
int i;
* bms_nonempty_difference - do sets have a nonempty difference?
*/
bool
-bms_nonempty_difference(const Bitmapset * a, const Bitmapset * b)
+bms_nonempty_difference(const Bitmapset *a, const Bitmapset *b)
{
int shortlen;
int i;
* Raises error if |a| is not 1.
*/
int
-bms_singleton_member(const Bitmapset * a)
+bms_singleton_member(const Bitmapset *a)
{
int result = -1;
int nwords;
* bms_num_members - count members of set
*/
int
-bms_num_members(const Bitmapset * a)
+bms_num_members(const Bitmapset *a)
{
int result = 0;
int nwords;
* This is faster than making an exact count with bms_num_members().
*/
BMS_Membership
-bms_membership(const Bitmapset * a)
+bms_membership(const Bitmapset *a)
{
BMS_Membership result = BMS_EMPTY_SET;
int nwords;
* This is even faster than bms_membership().
*/
bool
-bms_is_empty(const Bitmapset * a)
+bms_is_empty(const Bitmapset *a)
{
int nwords;
int wordnum;
* Input set is modified or recycled!
*/
Bitmapset *
-bms_add_member(Bitmapset * a, int x)
+bms_add_member(Bitmapset *a, int x)
{
int wordnum,
bitnum;
* Input set is modified in-place!
*/
Bitmapset *
-bms_del_member(Bitmapset * a, int x)
+bms_del_member(Bitmapset *a, int x)
{
int wordnum,
bitnum;
* bms_add_members - like bms_union, but left input is recycled
*/
Bitmapset *
-bms_add_members(Bitmapset * a, const Bitmapset * b)
+bms_add_members(Bitmapset *a, const Bitmapset *b)
{
Bitmapset *result;
const Bitmapset *other;
* bms_int_members - like bms_intersect, but left input is recycled
*/
Bitmapset *
-bms_int_members(Bitmapset * a, const Bitmapset * b)
+bms_int_members(Bitmapset *a, const Bitmapset *b)
{
int shortlen;
int i;
* bms_del_members - like bms_difference, but left input is recycled
*/
Bitmapset *
-bms_del_members(Bitmapset * a, const Bitmapset * b)
+bms_del_members(Bitmapset *a, const Bitmapset *b)
{
int shortlen;
int i;
* bms_join - like bms_union, but *both* inputs are recycled
*/
Bitmapset *
-bms_join(Bitmapset * a, Bitmapset * b)
+bms_join(Bitmapset *a, Bitmapset *b)
{
Bitmapset *result;
Bitmapset *other;
*----------
*/
int
-bms_first_member(Bitmapset * a)
+bms_first_member(Bitmapset *a)
{
int nwords;
int wordnum;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.262 2003/08/04 02:39:59 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.263 2003/08/08 21:41:43 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* _copyFuncExpr
*/
static FuncExpr *
-_copyFuncExpr(FuncExpr * from)
+_copyFuncExpr(FuncExpr *from)
{
FuncExpr *newnode = makeNode(FuncExpr);
* _copyOpExpr
*/
static OpExpr *
-_copyOpExpr(OpExpr * from)
+_copyOpExpr(OpExpr *from)
{
OpExpr *newnode = makeNode(OpExpr);
* _copyDistinctExpr (same as OpExpr)
*/
static DistinctExpr *
-_copyDistinctExpr(DistinctExpr * from)
+_copyDistinctExpr(DistinctExpr *from)
{
DistinctExpr *newnode = makeNode(DistinctExpr);
* _copyScalarArrayOpExpr
*/
static ScalarArrayOpExpr *
-_copyScalarArrayOpExpr(ScalarArrayOpExpr * from)
+_copyScalarArrayOpExpr(ScalarArrayOpExpr *from)
{
ScalarArrayOpExpr *newnode = makeNode(ScalarArrayOpExpr);
* _copyBoolExpr
*/
static BoolExpr *
-_copyBoolExpr(BoolExpr * from)
+_copyBoolExpr(BoolExpr *from)
{
BoolExpr *newnode = makeNode(BoolExpr);
* _copyArrayExpr
*/
static ArrayExpr *
-_copyArrayExpr(ArrayExpr * from)
+_copyArrayExpr(ArrayExpr *from)
{
ArrayExpr *newnode = makeNode(ArrayExpr);
* _copyCoalesceExpr
*/
static CoalesceExpr *
-_copyCoalesceExpr(CoalesceExpr * from)
+_copyCoalesceExpr(CoalesceExpr *from)
{
CoalesceExpr *newnode = makeNode(CoalesceExpr);
* _copyNullIfExpr (same as OpExpr)
*/
static NullIfExpr *
-_copyNullIfExpr(NullIfExpr * from)
+_copyNullIfExpr(NullIfExpr *from)
{
NullIfExpr *newnode = makeNode(NullIfExpr);
* _copyCoerceToDomain
*/
static CoerceToDomain *
-_copyCoerceToDomain(CoerceToDomain * from)
+_copyCoerceToDomain(CoerceToDomain *from)
{
CoerceToDomain *newnode = makeNode(CoerceToDomain);
* _copyCoerceToDomainValue
*/
static CoerceToDomainValue *
-_copyCoerceToDomainValue(CoerceToDomainValue * from)
+_copyCoerceToDomainValue(CoerceToDomainValue *from)
{
CoerceToDomainValue *newnode = makeNode(CoerceToDomainValue);
* _copySetToDefault
*/
static SetToDefault *
-_copySetToDefault(SetToDefault * from)
+_copySetToDefault(SetToDefault *from)
{
SetToDefault *newnode = makeNode(SetToDefault);
* _copyInClauseInfo
*/
static InClauseInfo *
-_copyInClauseInfo(InClauseInfo * from)
+_copyInClauseInfo(InClauseInfo *from)
{
InClauseInfo *newnode = makeNode(InClauseInfo);
}
static AlterDomainStmt *
-_copyAlterDomainStmt(AlterDomainStmt * from)
+_copyAlterDomainStmt(AlterDomainStmt *from)
{
AlterDomainStmt *newnode = makeNode(AlterDomainStmt);
}
static DeclareCursorStmt *
-_copyDeclareCursorStmt(DeclareCursorStmt * from)
+_copyDeclareCursorStmt(DeclareCursorStmt *from)
{
DeclareCursorStmt *newnode = makeNode(DeclareCursorStmt);
}
static InhRelation *
-_copyInhRelation(InhRelation * from)
+_copyInhRelation(InhRelation *from)
{
InhRelation *newnode = makeNode(InhRelation);
}
static AlterSeqStmt *
-_copyAlterSeqStmt(AlterSeqStmt * from)
+_copyAlterSeqStmt(AlterSeqStmt *from)
{
AlterSeqStmt *newnode = makeNode(AlterSeqStmt);
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.206 2003/08/04 02:39:59 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.207 2003/08/08 21:41:43 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
static bool
-_equalFuncExpr(FuncExpr * a, FuncExpr * b)
+_equalFuncExpr(FuncExpr *a, FuncExpr *b)
{
COMPARE_SCALAR_FIELD(funcid);
COMPARE_SCALAR_FIELD(funcresulttype);
}
static bool
-_equalOpExpr(OpExpr * a, OpExpr * b)
+_equalOpExpr(OpExpr *a, OpExpr *b)
{
COMPARE_SCALAR_FIELD(opno);
}
static bool
-_equalDistinctExpr(DistinctExpr * a, DistinctExpr * b)
+_equalDistinctExpr(DistinctExpr *a, DistinctExpr *b)
{
COMPARE_SCALAR_FIELD(opno);
}
static bool
-_equalScalarArrayOpExpr(ScalarArrayOpExpr * a, ScalarArrayOpExpr * b)
+_equalScalarArrayOpExpr(ScalarArrayOpExpr *a, ScalarArrayOpExpr *b)
{
COMPARE_SCALAR_FIELD(opno);
}
static bool
-_equalBoolExpr(BoolExpr * a, BoolExpr * b)
+_equalBoolExpr(BoolExpr *a, BoolExpr *b)
{
COMPARE_SCALAR_FIELD(boolop);
COMPARE_NODE_FIELD(args);
}
static bool
-_equalArrayExpr(ArrayExpr * a, ArrayExpr * b)
+_equalArrayExpr(ArrayExpr *a, ArrayExpr *b)
{
COMPARE_SCALAR_FIELD(array_typeid);
COMPARE_SCALAR_FIELD(element_typeid);
}
static bool
-_equalCoalesceExpr(CoalesceExpr * a, CoalesceExpr * b)
+_equalCoalesceExpr(CoalesceExpr *a, CoalesceExpr *b)
{
COMPARE_SCALAR_FIELD(coalescetype);
COMPARE_NODE_FIELD(args);
}
static bool
-_equalNullIfExpr(NullIfExpr * a, NullIfExpr * b)
+_equalNullIfExpr(NullIfExpr *a, NullIfExpr *b)
{
COMPARE_SCALAR_FIELD(opno);
}
static bool
-_equalCoerceToDomain(CoerceToDomain * a, CoerceToDomain * b)
+_equalCoerceToDomain(CoerceToDomain *a, CoerceToDomain *b)
{
COMPARE_NODE_FIELD(arg);
COMPARE_SCALAR_FIELD(resulttype);
}
static bool
-_equalCoerceToDomainValue(CoerceToDomainValue * a, CoerceToDomainValue * b)
+_equalCoerceToDomainValue(CoerceToDomainValue *a, CoerceToDomainValue *b)
{
COMPARE_SCALAR_FIELD(typeId);
COMPARE_SCALAR_FIELD(typeMod);
}
static bool
-_equalSetToDefault(SetToDefault * a, SetToDefault * b)
+_equalSetToDefault(SetToDefault *a, SetToDefault *b)
{
COMPARE_SCALAR_FIELD(typeId);
COMPARE_SCALAR_FIELD(typeMod);
}
static bool
-_equalInClauseInfo(InClauseInfo * a, InClauseInfo * b)
+_equalInClauseInfo(InClauseInfo *a, InClauseInfo *b)
{
COMPARE_BITMAPSET_FIELD(lefthand);
COMPARE_BITMAPSET_FIELD(righthand);
}
static bool
-_equalAlterDomainStmt(AlterDomainStmt * a, AlterDomainStmt * b)
+_equalAlterDomainStmt(AlterDomainStmt *a, AlterDomainStmt *b)
{
COMPARE_SCALAR_FIELD(subtype);
COMPARE_NODE_FIELD(typename);
}
static bool
-_equalDeclareCursorStmt(DeclareCursorStmt * a, DeclareCursorStmt * b)
+_equalDeclareCursorStmt(DeclareCursorStmt *a, DeclareCursorStmt *b)
{
COMPARE_STRING_FIELD(portalname);
COMPARE_SCALAR_FIELD(options);
}
static bool
-_equalInhRelation(InhRelation * a, InhRelation * b)
+_equalInhRelation(InhRelation *a, InhRelation *b)
{
COMPARE_NODE_FIELD(relation);
COMPARE_SCALAR_FIELD(including_defaults);
}
static bool
-_equalAlterSeqStmt(AlterSeqStmt * a, AlterSeqStmt * b)
+_equalAlterSeqStmt(AlterSeqStmt *a, AlterSeqStmt *b)
{
COMPARE_NODE_FIELD(sequence);
COMPARE_NODE_FIELD(options);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.53 2003/08/04 02:39:59 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.54 2003/08/08 21:41:44 momjian Exp $
*
* NOTES
* XXX a few of the following functions are duplicated to handle
* since we avoid having to chase down the list again each time.
*/
void
-FastAppend(FastList * fl, void *datum)
+FastAppend(FastList *fl, void *datum)
{
List *cell = makeList1(datum);
* FastAppendi - same for integers
*/
void
-FastAppendi(FastList * fl, int datum)
+FastAppendi(FastList *fl, int datum)
{
List *cell = makeListi1(datum);
* FastAppendo - same for Oids
*/
void
-FastAppendo(FastList * fl, Oid datum)
+FastAppendo(FastList *fl, Oid datum)
{
List *cell = makeListo1(datum);
* Note that the cells of the second argument are absorbed into the FastList.
*/
void
-FastConc(FastList * fl, List *cells)
+FastConc(FastList *fl, List *cells)
{
if (cells == NIL)
return; /* nothing to do */
* Note that the cells of the second argument are absorbed into the first.
*/
void
-FastConcFast(FastList * fl, FastList * fl2)
+FastConcFast(FastList *fl, FastList *fl2)
{
if (fl2->head == NIL)
return; /* nothing to do */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.216 2003/08/04 02:39:59 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.217 2003/08/08 21:41:44 momjian Exp $
*
* NOTES
* Every node type that can appear in stored rules' parsetrees *must*
* an integer List would be.
*/
static void
-_outBitmapset(StringInfo str, Bitmapset * bms)
+_outBitmapset(StringInfo str, Bitmapset *bms)
{
Bitmapset *tmpset;
int x;
}
static void
-_outFuncExpr(StringInfo str, FuncExpr * node)
+_outFuncExpr(StringInfo str, FuncExpr *node)
{
WRITE_NODE_TYPE("FUNCEXPR");
}
static void
-_outOpExpr(StringInfo str, OpExpr * node)
+_outOpExpr(StringInfo str, OpExpr *node)
{
WRITE_NODE_TYPE("OPEXPR");
}
static void
-_outDistinctExpr(StringInfo str, DistinctExpr * node)
+_outDistinctExpr(StringInfo str, DistinctExpr *node)
{
WRITE_NODE_TYPE("DISTINCTEXPR");
}
static void
-_outScalarArrayOpExpr(StringInfo str, ScalarArrayOpExpr * node)
+_outScalarArrayOpExpr(StringInfo str, ScalarArrayOpExpr *node)
{
WRITE_NODE_TYPE("SCALARARRAYOPEXPR");
}
static void
-_outBoolExpr(StringInfo str, BoolExpr * node)
+_outBoolExpr(StringInfo str, BoolExpr *node)
{
char *opstr = NULL;
}
static void
-_outArrayExpr(StringInfo str, ArrayExpr * node)
+_outArrayExpr(StringInfo str, ArrayExpr *node)
{
WRITE_NODE_TYPE("ARRAY");
}
static void
-_outCoalesceExpr(StringInfo str, CoalesceExpr * node)
+_outCoalesceExpr(StringInfo str, CoalesceExpr *node)
{
WRITE_NODE_TYPE("COALESCE");
}
static void
-_outNullIfExpr(StringInfo str, NullIfExpr * node)
+_outNullIfExpr(StringInfo str, NullIfExpr *node)
{
WRITE_NODE_TYPE("NULLIFEXPR");
}
static void
-_outCoerceToDomain(StringInfo str, CoerceToDomain * node)
+_outCoerceToDomain(StringInfo str, CoerceToDomain *node)
{
WRITE_NODE_TYPE("COERCETODOMAIN");
}
static void
-_outCoerceToDomainValue(StringInfo str, CoerceToDomainValue * node)
+_outCoerceToDomainValue(StringInfo str, CoerceToDomainValue *node)
{
WRITE_NODE_TYPE("COERCETODOMAINVALUE");
}
static void
-_outSetToDefault(StringInfo str, SetToDefault * node)
+_outSetToDefault(StringInfo str, SetToDefault *node)
{
WRITE_NODE_TYPE("SETTODEFAULT");
}
static void
-_outResultPath(StringInfo str, ResultPath * node)
+_outResultPath(StringInfo str, ResultPath *node)
{
WRITE_NODE_TYPE("RESULTPATH");
}
static void
-_outMaterialPath(StringInfo str, MaterialPath * node)
+_outMaterialPath(StringInfo str, MaterialPath *node)
{
WRITE_NODE_TYPE("MATERIALPATH");
}
static void
-_outUniquePath(StringInfo str, UniquePath * node)
+_outUniquePath(StringInfo str, UniquePath *node)
{
WRITE_NODE_TYPE("UNIQUEPATH");
}
static void
-_outInClauseInfo(StringInfo str, InClauseInfo * node)
+_outInClauseInfo(StringInfo str, InClauseInfo *node)
{
WRITE_NODE_TYPE("INCLAUSEINFO");
}
static void
-_outDeclareCursorStmt(StringInfo str, DeclareCursorStmt * node)
+_outDeclareCursorStmt(StringInfo str, DeclareCursorStmt *node)
{
WRITE_NODE_TYPE("DECLARECURSOR");
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.113 2003/08/04 02:40:00 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.114 2003/08/08 21:41:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static Selectivity estimate_hash_bucketsize(Query *root, Var *var,
int nbuckets);
-static bool cost_qual_eval_walker(Node *node, QualCost * total);
+static bool cost_qual_eval_walker(Node *node, QualCost *total);
static Selectivity approx_selectivity(Query *root, List *quals,
JoinType jointype);
static void set_rel_width(Query *root, RelOptInfo *rel);
* and a per-evaluation component.
*/
void
-cost_qual_eval(QualCost * cost, List *quals)
+cost_qual_eval(QualCost *cost, List *quals)
{
List *l;
}
static bool
-cost_qual_eval_walker(Node *node, QualCost * total)
+cost_qual_eval_walker(Node *node, QualCost *total)
{
if (node == NULL)
return false;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/tidpath.c,v 1.16 2003/08/04 02:40:00 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/tidpath.c,v 1.17 2003/08/08 21:41:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static List *TidqualFromRestrictinfo(Relids relids, List *restrictinfo);
static bool isEvaluable(int varno, Node *node);
-static Node *TidequalClause(int varno, OpExpr * node);
+static Node *TidequalClause(int varno, OpExpr *node);
static List *TidqualFromExpr(int varno, Expr *expr);
static bool
* or the left node if the opclause is ....=CTID
*/
static Node *
-TidequalClause(int varno, OpExpr * node)
+TidequalClause(int varno, OpExpr *node)
{
Node *rnode = NULL,
*arg1,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.152 2003/08/07 19:20:22 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.153 2003/08/08 21:41:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static void disuse_physical_tlist(Plan *plan, Path *path);
static Join *create_join_plan(Query *root, JoinPath *best_path);
static Append *create_append_plan(Query *root, AppendPath *best_path);
-static Result *create_result_plan(Query *root, ResultPath * best_path);
-static Material *create_material_plan(Query *root, MaterialPath * best_path);
-static Plan *create_unique_plan(Query *root, UniquePath * best_path);
+static Result *create_result_plan(Query *root, ResultPath *best_path);
+static Material *create_material_plan(Query *root, MaterialPath *best_path);
+static Plan *create_unique_plan(Query *root, UniquePath *best_path);
static SeqScan *create_seqscan_plan(Path *best_path, List *tlist,
List *scan_clauses);
static IndexScan *create_indexscan_plan(Query *root, IndexPath *best_path,
* Returns a Plan node.
*/
static Result *
-create_result_plan(Query *root, ResultPath * best_path)
+create_result_plan(Query *root, ResultPath *best_path)
{
Result *plan;
List *tlist;
* Returns a Plan node.
*/
static Material *
-create_material_plan(Query *root, MaterialPath * best_path)
+create_material_plan(Query *root, MaterialPath *best_path)
{
Material *plan;
Plan *subplan;
* Returns a Plan node.
*/
static Plan *
-create_unique_plan(Query *root, UniquePath * best_path)
+create_unique_plan(Query *root, UniquePath *best_path)
{
Plan *plan;
Plan *subplan;
* to unique-ify may be expressions in these variables. We have to
* add any such expressions to the subplan's tlist. We then build
* control information showing which subplan output columns are to be
- * examined by the grouping step. (Since we do not remove any existing
- * subplan outputs, not all the output columns may be used for grouping.)
+ * examined by the grouping step. (Since we do not remove any
+ * existing subplan outputs, not all the output columns may be used
+ * for grouping.)
*
- * Note: the reason we don't remove any subplan outputs is that there
- * are scenarios where a Var is needed at higher levels even though it
- * is not one of the nominal outputs of an IN clause. Consider
- * WHERE x IN (SELECT y FROM t1,t2 WHERE y = z)
- * Implied equality deduction will generate an "x = z" clause, which may
- * get used instead of "x = y" in the upper join step. Therefore the
- * sub-select had better deliver both y and z in its targetlist. It is
- * sufficient to unique-ify on y, however.
+ * Note: the reason we don't remove any subplan outputs is that there are
+ * scenarios where a Var is needed at higher levels even though it is
+ * not one of the nominal outputs of an IN clause. Consider WHERE x
+ * IN (SELECT y FROM t1,t2 WHERE y = z) Implied equality deduction
+ * will generate an "x = z" clause, which may get used instead of "x =
+ * y" in the upper join step. Therefore the sub-select had better
+ * deliver both y and z in its targetlist. It is sufficient to
+ * unique-ify on y, however.
*
* To find the correct list of values to unique-ify, we look in the
* information saved for IN expressions. If this code is ever used in
Relids leftvarnos;
Oid opclass;
- if (!IsA(clause, OpExpr) || length(clause->args) != 2)
+ if (!IsA(clause, OpExpr) ||length(clause->args) != 2)
elog(ERROR, "indexqual clause is not binary opclause");
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.96 2003/08/04 02:40:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.97 2003/08/08 21:41:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static Node *replace_vars_with_subplan_refs_mutator(Node *node,
replace_vars_with_subplan_refs_context *context);
static bool fix_opfuncids_walker(Node *node, void *context);
-static void set_sa_opfuncid(ScalarArrayOpExpr * opexpr);
+static void set_sa_opfuncid(ScalarArrayOpExpr *opexpr);
/*****************************************************************************
* DistinctExpr and NullIfExpr nodes.
*/
void
-set_opfuncid(OpExpr * opexpr)
+set_opfuncid(OpExpr *opexpr)
{
if (opexpr->opfuncid == InvalidOid)
opexpr->opfuncid = get_opcode(opexpr->opno);
* As above, for ScalarArrayOpExpr nodes.
*/
static void
-set_sa_opfuncid(ScalarArrayOpExpr * opexpr)
+set_sa_opfuncid(ScalarArrayOpExpr *opexpr)
{
if (opexpr->opfuncid == InvalidOid)
opexpr->opfuncid = get_opcode(opexpr->opno);
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.81 2003/08/04 02:40:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.82 2003/08/08 21:41:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
Node *item; /* the Var, Aggref, or Param */
Index abslevel; /* its absolute query level */
-} PlannerParamItem;
+} PlannerParamItem;
typedef struct finalize_primnode_context
{
Bitmapset *paramids; /* Set of PARAM_EXEC paramids found */
Bitmapset *outer_params; /* Set of accessible outer paramids */
-} finalize_primnode_context;
+} finalize_primnode_context;
static List *convert_sublink_opers(List *lefthand, List *operOids,
static Node *replace_correlation_vars_mutator(Node *node, void *context);
static Node *process_sublinks_mutator(Node *node, bool *isTopQual);
static Bitmapset *finalize_plan(Plan *plan, List *rtable,
- Bitmapset * outer_params,
- Bitmapset * valid_params);
-static bool finalize_primnode(Node *node, finalize_primnode_context * context);
+ Bitmapset *outer_params,
+ Bitmapset *valid_params);
+static bool finalize_primnode(Node *node, finalize_primnode_context *context);
/*
*/
static Bitmapset *
finalize_plan(Plan *plan, List *rtable,
- Bitmapset * outer_params, Bitmapset * valid_params)
+ Bitmapset *outer_params, Bitmapset *valid_params)
{
finalize_primnode_context context;
List *lst;
* expression tree to the result set.
*/
static bool
-finalize_primnode(Node *node, finalize_primnode_context * context)
+finalize_primnode(Node *node, finalize_primnode_context *context)
{
if (node == NULL)
return false;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepjointree.c,v 1.10 2003/08/04 02:40:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepjointree.c,v 1.11 2003/08/08 21:41:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
Relids relids; /* base relids within this subtree */
bool contains_outer; /* does subtree contain outer join(s)? */
List *sub_states; /* List of states for subtree components */
-} reduce_outer_joins_state;
+} reduce_outer_joins_state;
static bool is_simple_subquery(Query *subquery);
static bool has_nullable_targetlist(Query *subquery);
static void resolvenew_in_jointree(Node *jtnode, int varno, List *subtlist);
static reduce_outer_joins_state *reduce_outer_joins_pass1(Node *jtnode);
static void reduce_outer_joins_pass2(Node *jtnode,
- reduce_outer_joins_state * state,
+ reduce_outer_joins_state *state,
Query *parse,
Relids nonnullable_rels);
static Relids find_nonnullable_rels(Node *node, bool top_level);
*/
static void
reduce_outer_joins_pass2(Node *jtnode,
- reduce_outer_joins_state * state,
+ reduce_outer_joins_state *state,
Query *parse,
Relids nonnullable_rels)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepqual.c,v 1.37 2003/08/04 02:40:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepqual.c,v 1.38 2003/08/08 21:41:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/lsyscache.h"
static Expr *flatten_andors(Expr *qual);
-static void flatten_andors_and_walker(FastList * out_list, List *andlist);
-static void flatten_andors_or_walker(FastList * out_list, List *orlist);
+static void flatten_andors_and_walker(FastList *out_list, List *andlist);
+static void flatten_andors_or_walker(FastList *out_list, List *orlist);
static List *pull_ands(List *andlist);
-static void pull_ands_walker(FastList * out_list, List *andlist);
+static void pull_ands_walker(FastList *out_list, List *andlist);
static List *pull_ors(List *orlist);
-static void pull_ors_walker(FastList * out_list, List *orlist);
+static void pull_ors_walker(FastList *out_list, List *orlist);
static Expr *find_nots(Expr *qual);
static Expr *push_nots(Expr *qual);
static Expr *find_ors(Expr *qual);
}
static void
-flatten_andors_and_walker(FastList * out_list, List *andlist)
+flatten_andors_and_walker(FastList *out_list, List *andlist)
{
List *arg;
}
static void
-flatten_andors_or_walker(FastList * out_list, List *orlist)
+flatten_andors_or_walker(FastList *out_list, List *orlist)
{
List *arg;
}
static void
-pull_ands_walker(FastList * out_list, List *andlist)
+pull_ands_walker(FastList *out_list, List *andlist)
{
List *arg;
}
static void
-pull_ors_walker(FastList * out_list, List *orlist)
+pull_ors_walker(FastList *out_list, List *orlist)
{
List *arg;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.151 2003/08/04 02:40:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.152 2003/08/08 21:41:55 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
int nargs;
List *args;
int *usecounts;
-} substitute_actual_parameters_context;
+} substitute_actual_parameters_context;
static bool contain_agg_clause_walker(Node *node, void *context);
static bool contain_distinct_agg_clause_walker(Node *node, void *context);
static Node *substitute_actual_parameters(Node *expr, int nargs, List *args,
int *usecounts);
static Node *substitute_actual_parameters_mutator(Node *node,
- substitute_actual_parameters_context * context);
+ substitute_actual_parameters_context *context);
static void sql_inline_error_callback(void *arg);
static Expr *evaluate_expr(Expr *expr, Oid result_type);
* XXX the clause is destructively modified!
*/
void
-CommuteClause(OpExpr * clause)
+CommuteClause(OpExpr *clause)
{
Oid opoid;
Node *temp;
static Node *
substitute_actual_parameters_mutator(Node *node,
- substitute_actual_parameters_context * context)
+ substitute_actual_parameters_context *context)
{
if (node == NULL)
return NULL;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.53 2003/08/04 02:40:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/var.c,v 1.54 2003/08/08 21:41:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
int min_varlevel;
int sublevels_up;
-} find_minimum_var_level_context;
+} find_minimum_var_level_context;
typedef struct
{
static bool contain_vars_of_level_walker(Node *node, int *sublevels_up);
static bool contain_vars_above_level_walker(Node *node, int *sublevels_up);
static bool find_minimum_var_level_walker(Node *node,
- find_minimum_var_level_context * context);
+ find_minimum_var_level_context *context);
static bool pull_var_clause_walker(Node *node,
pull_var_clause_context *context);
static Node *flatten_join_alias_vars_mutator(Node *node,
static bool
find_minimum_var_level_walker(Node *node,
- find_minimum_var_level_context * context)
+ find_minimum_var_level_context *context)
{
if (node == NULL)
return false;
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.285 2003/08/04 02:40:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.286 2003/08/08 21:41:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
Oid *paramTypes;
int numParams;
-} check_parameter_resolution_context;
+} check_parameter_resolution_context;
static List *do_parse_analyze(Node *parseTree, ParseState *pstate);
static Node *transformSetOperationTree(ParseState *pstate, SelectStmt *stmt);
static Query *transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt);
static Query *transformDeclareCursorStmt(ParseState *pstate,
- DeclareCursorStmt * stmt);
+ DeclareCursorStmt *stmt);
static Query *transformPrepareStmt(ParseState *pstate, PrepareStmt *stmt);
static Query *transformExecuteStmt(ParseState *pstate, ExecuteStmt *stmt);
static Query *transformCreateStmt(ParseState *pstate, CreateStmt *stmt,
CreateStmtContext *cxt,
Constraint *constraint);
static void transformInhRelation(ParseState *pstate, CreateStmtContext *cxt,
- InhRelation * inhrelation);
+ InhRelation *inhrelation);
static void transformIndexConstraints(ParseState *pstate,
CreateStmtContext *cxt);
static void transformFKConstraints(ParseState *pstate,
static void release_pstate_resources(ParseState *pstate);
static FromExpr *makeFromExpr(List *fromlist, Node *quals);
static bool check_parameter_resolution_walker(Node *node,
- check_parameter_resolution_context * context);
+ check_parameter_resolution_context *context);
/*
*/
static void
transformInhRelation(ParseState *pstate, CreateStmtContext *cxt,
- InhRelation * inhRelation)
+ InhRelation *inhRelation)
{
AttrNumber parent_attno;
{
/*
* If sub_qry is a setop, manipulating its jointree will
- * do no good at all, because the jointree is dummy.
- * (This should be a can't-happen case because of prior
- * tests.)
+ * do no good at all, because the jointree is dummy. (This
+ * should be a can't-happen case because of prior tests.)
*/
if (sub_qry->setOperations != NULL)
ereport(ERROR,
}
static Query *
-transformDeclareCursorStmt(ParseState *pstate, DeclareCursorStmt * stmt)
+transformDeclareCursorStmt(ParseState *pstate, DeclareCursorStmt *stmt)
{
Query *result = makeNode(Query);
List *extras_before = NIL,
*/
static bool
check_parameter_resolution_walker(Node *node,
- check_parameter_resolution_context * context)
+ check_parameter_resolution_context *context)
{
if (node == NULL)
return false;
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
- * $Header: /cvsroot/pgsql/src/backend/regex/regc_color.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/regex/regc_color.c,v 1.3 2003/08/08 21:41:56 momjian Exp $
*
*
* Note that there are some incestuous relationships between this code and
/*
* setcolor - set the color of a character in a colormap
*/
-static color /* previous color */
+static color /* previous color */
setcolor(struct colormap * cm,
chr c,
pcolor co)
* newcolor - find a new color (must be subject of setcolor at once)
* Beware: may relocate the colordescs.
*/
-static color /* COLORLESS for error */
+static color /* COLORLESS for error */
newcolor(struct colormap * cm)
{
struct colordesc *cd;
/* first, align "from" on a tree-block boundary */
uf = (uchr) from;
- i = (int) (((uf + BYTTAB - 1) & (uchr) ~ BYTMASK) - uf);
+ i = (int) (((uf + BYTTAB - 1) & (uchr) ~BYTMASK) - uf);
for (; from <= to && i > 0; i--, from++)
newarc(v->nfa, PLAIN, subcolor(v->cm, from), lp, rp);
if (from > to) /* didn't reach a boundary */
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
- * $Header: /cvsroot/pgsql/src/backend/regex/regc_cvec.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/regex/regc_cvec.c,v 1.3 2003/08/08 21:41:56 momjian Exp $
*
*/
if (cv == NULL)
return NULL;
cv->chrspace = nchrs;
- cv->chrs = (chr *) & cv->mcces[nmcces]; /* chrs just after MCCE
+ cv->chrs = (chr *) &cv->mcces[nmcces]; /* chrs just after MCCE
* ptrs */
cv->mccespace = nmcces;
cv->ranges = cv->chrs + nchrs + nmcces * (MAXMCCE + 1);
assert(cv != NULL);
cv->nchrs = 0;
- assert(cv->chrs == (chr *) & cv->mcces[cv->mccespace]);
+ assert(cv->chrs == (chr *) &cv->mcces[cv->mccespace]);
cv->nmcces = 0;
cv->nmccechrs = 0;
cv->nranges = 0;
*/
static void
addmcce(struct cvec * cv, /* character vector */
- chr * startp, /* beginning of text */
- chr * endp) /* just past end of text */
+ chr *startp, /* beginning of text */
+ chr *endp) /* just past end of text */
{
int len;
int i;
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
- * $Header: /cvsroot/pgsql/src/backend/regex/regc_lex.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/regex/regc_lex.c,v 1.3 2003/08/08 21:41:56 momjian Exp $
*
*/
*/
static void
lexnest(struct vars * v,
- chr * beginp, /* start of interpolation */
- chr * endp) /* one past end of interpolation */
+ chr *beginp, /* start of interpolation */
+ chr *endp) /* one past end of interpolation */
{
assert(v->savenow == NULL); /* only one level of nesting */
v->savenow = v->now;
/*
* lexdigits - slurp up digits and return chr value
*/
-static chr /* chr value; errors signalled via ERR */
+static chr /* chr value; errors signalled via ERR */
lexdigits(struct vars * v,
int base,
int minlen,
*/
static chr
chrnamed(struct vars * v,
- chr * startp, /* start of name */
- chr * endp, /* just past end of name */
+ chr *startp, /* start of name */
+ chr *endp, /* just past end of name */
chr lastresort) /* what to return if name lookup fails */
{
celt c;
* permission to use and distribute the software in accordance with the
* terms specified in this license.
*
- * $Header: /cvsroot/pgsql/src/backend/regex/regc_locale.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/regex/regc_locale.c,v 1.3 2003/08/08 21:41:56 momjian Exp $
*/
/* ASCII character-name table */
*/
static celt
element(struct vars * v, /* context */
- chr * startp, /* points to start of name */
- chr * endp) /* points just past end of name */
+ chr *startp, /* points to start of name */
+ chr *endp) /* points just past end of name */
{
struct cname *cn;
size_t len;
*/
static struct cvec *
cclass(struct vars * v, /* context */
- chr * startp, /* where the name starts */
- chr * endp, /* just past the end of the name */
+ chr *startp, /* where the name starts */
+ chr *endp, /* just past the end of the name */
int cases) /* case-independent? */
{
size_t len;
* stop at embedded NULs!
*/
static int /* 0 for equal, nonzero for unequal */
-cmp(const chr * x, const chr * y, /* strings to compare */
+cmp(const chr *x, const chr *y, /* strings to compare */
size_t len) /* exact length of comparison */
{
return memcmp(VS(x), VS(y), len * sizeof(chr));
* stop at embedded NULs!
*/
static int /* 0 for equal, nonzero for unequal */
-casecmp(const chr * x, const chr * y, /* strings to compare */
+casecmp(const chr *x, const chr *y, /* strings to compare */
size_t len) /* exact length of comparison */
{
for (; len > 0; len--, x++, y++)
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
- * $Header: /cvsroot/pgsql/src/backend/regex/regcomp.c,v 1.37 2003/08/04 00:43:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/regex/regcomp.c,v 1.38 2003/08/08 21:41:56 momjian Exp $
*
*/
*/
int
pg_regcomp(regex_t *re,
- const chr * string,
+ const chr *string,
size_t len,
int flags)
{
/*
* prepare a general-purpose state skeleton
*
- * ---> [s] ---prefix---> [begin] ---atom---> [end] ----rest---> [rp] /
- * / [lp] ----> [s2] ----bypass---------------------
+ * ---> [s] ---prefix---> [begin] ---atom---> [end] ----rest---> [rp] / /
+ * [lp] ----> [s2] ----bypass---------------------
*
* where bypass is an empty, and prefix is some repetitions of atom
*/
/*
* nextleader - find next MCCE leader within range
*/
-static celt /* NOCELT means none */
+static celt /* NOCELT means none */
nextleader(struct vars * v,
chr from,
chr to)
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
- * $Header: /cvsroot/pgsql/src/backend/regex/rege_dfa.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/regex/rege_dfa.c,v 1.3 2003/08/08 21:41:56 momjian Exp $
*
*/
static chr * /* endpoint, or NULL */
longest(struct vars * v, /* used only for debug and exec flags */
struct dfa * d,
- chr * start, /* where the match should start */
- chr * stop, /* match must end at or before here */
+ chr *start, /* where the match should start */
+ chr *stop, /* match must end at or before here */
int *hitstopp) /* record whether hit v->stop, if non-NULL */
{
chr *cp;
static chr * /* endpoint, or NULL */
shortest(struct vars * v,
struct dfa * d,
- chr * start, /* where the match should start */
- chr * min, /* match must end at or after here */
- chr * max, /* match must end at or before here */
- chr ** coldp, /* store coldstart pointer here, if
+ chr *start, /* where the match should start */
+ chr *min, /* match must end at or after here */
+ chr *max, /* match must end at or before here */
+ chr **coldp, /* store coldstart pointer here, if
* nonNULL */
int *hitstopp) /* record whether hit v->stop, if non-NULL */
{
static struct sset *
initialize(struct vars * v, /* used only for debug flags */
struct dfa * d,
- chr * start)
+ chr *start)
{
struct sset *ss;
int i;
struct dfa * d,
struct sset * css,
pcolor co,
- chr * cp, /* next chr */
- chr * start) /* where the attempt got started */
+ chr *cp, /* next chr */
+ chr *start) /* where the attempt got started */
{
struct cnfa *cnfa = d->cnfa;
int i;
static int /* predicate: constraint satisfied? */
lacon(struct vars * v,
struct cnfa * pcnfa, /* parent cnfa */
- chr * cp,
+ chr *cp,
pcolor co) /* "color" of the lookahead constraint */
{
int n;
static struct sset *
getvacant(struct vars * v, /* used only for debug flags */
struct dfa * d,
- chr * cp,
- chr * start)
+ chr *cp,
+ chr *start)
{
int i;
struct sset *ss;
static struct sset *
pickss(struct vars * v, /* used only for debug flags */
struct dfa * d,
- chr * cp,
- chr * start)
+ chr *cp,
+ chr *start)
{
int i;
struct sset *ss;
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
- * $Header: /cvsroot/pgsql/src/backend/regex/regexec.c,v 1.22 2003/08/04 00:43:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/regex/regexec.c,v 1.23 2003/08/08 21:41:56 momjian Exp $
*
*/
*/
int
pg_regexec(regex_t *re,
- const chr * string,
+ const chr *string,
size_t len,
- rm_detail_t * details,
+ rm_detail_t *details,
size_t nmatch,
regmatch_t pmatch[],
int flags)
struct colormap * cm,
struct dfa * d,
struct dfa * s,
- chr ** coldp) /* where to put coldstart pointer */
+ chr **coldp) /* where to put coldstart pointer */
{
chr *begin;
chr *end;
static void
subset(struct vars * v,
struct subre * sub,
- chr * begin,
- chr * end)
+ chr *begin,
+ chr *end)
{
int n = sub->subno;
static int /* regexec return code */
dissect(struct vars * v,
struct subre * t,
- chr * begin, /* beginning of relevant substring */
- chr * end) /* end of same */
+ chr *begin, /* beginning of relevant substring */
+ chr *end) /* end of same */
{
assert(t != NULL);
MDEBUG(("dissect %ld-%ld\n", LOFF(begin), LOFF(end)));
static int /* regexec return code */
condissect(struct vars * v,
struct subre * t,
- chr * begin, /* beginning of relevant substring */
- chr * end) /* end of same */
+ chr *begin, /* beginning of relevant substring */
+ chr *end) /* end of same */
{
struct dfa *d;
struct dfa *d2;
static int /* regexec return code */
altdissect(struct vars * v,
struct subre * t,
- chr * begin, /* beginning of relevant substring */
- chr * end) /* end of same */
+ chr *begin, /* beginning of relevant substring */
+ chr *end) /* end of same */
{
struct dfa *d;
int i;
static int /* regexec return code */
cdissect(struct vars * v,
struct subre * t,
- chr * begin, /* beginning of relevant substring */
- chr * end) /* end of same */
+ chr *begin, /* beginning of relevant substring */
+ chr *end) /* end of same */
{
int er;
static int /* regexec return code */
ccondissect(struct vars * v,
struct subre * t,
- chr * begin, /* beginning of relevant substring */
- chr * end) /* end of same */
+ chr *begin, /* beginning of relevant substring */
+ chr *end) /* end of same */
{
struct dfa *d;
struct dfa *d2;
static int /* regexec return code */
crevdissect(struct vars * v,
struct subre * t,
- chr * begin, /* beginning of relevant substring */
- chr * end) /* end of same */
+ chr *begin, /* beginning of relevant substring */
+ chr *end) /* end of same */
{
struct dfa *d;
struct dfa *d2;
static int /* regexec return code */
cbrdissect(struct vars * v,
struct subre * t,
- chr * begin, /* beginning of relevant substring */
- chr * end) /* end of same */
+ chr *begin, /* beginning of relevant substring */
+ chr *end) /* end of same */
{
int i;
int n = t->subno;
static int /* regexec return code */
caltdissect(struct vars * v,
struct subre * t,
- chr * begin, /* beginning of relevant substring */
- chr * end) /* end of same */
+ chr *begin, /* beginning of relevant substring */
+ chr *end) /* end of same */
{
struct dfa *d;
int er;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.127 2003/08/04 02:40:03 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.128 2003/08/08 21:41:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
Oid relation; /* OID of relation having rules */
CmdType event; /* type of rule being fired */
-} rewrite_event;
+} rewrite_event;
static Query *rewriteRuleAction(Query *parsetree,
Query *rule_action,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.76 2003/08/04 02:40:03 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteManip.c,v 1.77 2003/08/08 21:41:58 momjian Exp $
*
*-------------------------------------------------------------------------
*/
typedef struct
{
int sublevels_up;
-} checkExprHasAggs_context;
+} checkExprHasAggs_context;
static bool checkExprHasAggs_walker(Node *node,
- checkExprHasAggs_context * context);
+ checkExprHasAggs_context *context);
static bool checkExprHasSubLink_walker(Node *node, void *context);
static Relids offset_relid_set(Relids relids, int offset);
static Relids adjust_relid_set(Relids relids, int oldrelid, int newrelid);
}
static bool
-checkExprHasAggs_walker(Node *node, checkExprHasAggs_context * context)
+checkExprHasAggs_walker(Node *node, checkExprHasAggs_context *context)
{
if (node == NULL)
return false;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/freespace/freespace.c,v 1.20 2003/08/04 02:40:03 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/freespace/freespace.c,v 1.21 2003/08/08 21:41:59 momjian Exp $
*
*
* NOTES:
uint32 endian;
uint32 version;
int32 numRels;
-} FsmCacheFileHeader;
+} FsmCacheFileHeader;
/* Per-relation header */
typedef struct FsmCacheRelHeader
uint32 avgRequest; /* moving average of space requests */
int32 lastPageCount; /* pages passed to RecordRelationFreeSpace */
int32 storedPages; /* # of pages stored in arena */
-} FsmCacheRelHeader;
+} FsmCacheRelHeader;
/*
int *outPageIndex);
static void compact_fsm_storage(void);
static void push_fsm_rels_after(FSMRelation *afterRel);
-static void pack_incoming_pages(FSMPageData * newLocation, int newPages,
- PageFreeSpaceInfo * pageSpaces, int nPages);
-static void pack_existing_pages(FSMPageData * newLocation, int newPages,
- FSMPageData * oldLocation, int oldPages);
+static void pack_incoming_pages(FSMPageData *newLocation, int newPages,
+ PageFreeSpaceInfo *pageSpaces, int nPages);
+static void pack_existing_pages(FSMPageData *newLocation, int newPages,
+ FSMPageData *oldLocation, int oldPages);
static int fsm_calc_request(FSMRelation *fsmrel);
static int fsm_calc_target_allocation(int myRequest);
static int fsm_current_chunks(FSMRelation *fsmrel);
void
RecordRelationFreeSpace(RelFileNode *rel,
int nPages,
- PageFreeSpaceInfo * pageSpaces)
+ PageFreeSpaceInfo *pageSpaces)
{
FSMRelation *fsmrel;
#define HISTOGRAM_BINS 64
static void
-pack_incoming_pages(FSMPageData * newLocation, int newPages,
- PageFreeSpaceInfo * pageSpaces, int nPages)
+pack_incoming_pages(FSMPageData *newLocation, int newPages,
+ PageFreeSpaceInfo *pageSpaces, int nPages)
{
int histogram[HISTOGRAM_BINS];
int above,
* so that we can copy data moving forward in the arrays without problem.
*/
static void
-pack_existing_pages(FSMPageData * newLocation, int newPages,
- FSMPageData * oldLocation, int oldPages)
+pack_existing_pages(FSMPageData *newLocation, int newPages,
+ FSMPageData *oldLocation, int oldPages)
{
int histogram[HISTOGRAM_BINS];
int above,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/deadlock.c,v 1.23 2003/08/04 02:40:03 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/deadlock.c,v 1.24 2003/08/08 21:42:00 momjian Exp $
*
* Interface:
*
LOCKTAG locktag; /* ID of awaited lock object */
LOCKMODE lockmode; /* type of lock we're waiting for */
int pid; /* PID of blocked backend */
-} DEADLOCK_INFO;
+} DEADLOCK_INFO;
static bool DeadLockCheckRecurse(PGPROC *proc);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/s_lock.c,v 1.15 2003/08/06 16:43:43 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/s_lock.c,v 1.16 2003/08/08 21:42:00 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* finish 100 iterations. However, on a uniprocessor, the tight loop
* is just a waste of cycles, so don't iterate thousands of times.
*
- * Once we do decide to block, we use randomly increasing select() delays.
- * The first delay is 10 msec, then the delay randomly increases to about
- * one second, after which we reset to 10 msec and start again. The idea
- * here is that in the presence of heavy contention we need to increase
- * the delay, else the spinlock holder may never get to run and release
- * the lock. (Consider situation where spinlock holder has been nice'd
- * down in priority by the scheduler --- it will not get scheduled until
- * all would-be acquirers are sleeping, so if we always use a 10-msec
- * sleep, there is a real possibility of starvation.) But we can't just
- * clamp the delay to an upper bound, else it would take a long time to
- * make a reasonable number of tries.
+ * Once we do decide to block, we use randomly increasing select()
+ * delays. The first delay is 10 msec, then the delay randomly
+ * increases to about one second, after which we reset to 10 msec and
+ * start again. The idea here is that in the presence of heavy
+ * contention we need to increase the delay, else the spinlock holder
+ * may never get to run and release the lock. (Consider situation
+ * where spinlock holder has been nice'd down in priority by the
+ * scheduler --- it will not get scheduled until all would-be
+ * acquirers are sleeping, so if we always use a 10-msec sleep, there
+ * is a real possibility of starvation.) But we can't just clamp the
+ * delay to an upper bound, else it would take a long time to make a
+ * reasonable number of tries.
*
* We time out and declare error after NUM_DELAYS delays (thus, exactly
* that many tries). With the given settings, this will usually take
- * 3 or so minutes. It seems better to fix the total number of tries (and
- * thus the probability of unintended failure) than to fix the total time
- * spent.
+ * 3 or so minutes. It seems better to fix the total number of tries
+ * (and thus the probability of unintended failure) than to fix the
+ * total time spent.
*
- * The select() delays are measured in centiseconds (0.01 sec) because
- * 10 msec is a common resolution limit at the OS level.
+ * The select() delays are measured in centiseconds (0.01 sec) because 10
+ * msec is a common resolution limit at the OS level.
*/
#define SPINS_PER_DELAY 100
#define NUM_DELAYS 1000
(void) select(0, NULL, NULL, NULL, &delay);
#if defined(S_LOCK_TEST)
- fprintf(stdout, "*"); fflush(stdout);
+ fprintf(stdout, "*");
+ fflush(stdout);
#endif
/* increase delay by a random fraction between 1X and 2X */
cur_delay += (int) (cur_delay *
- (((double) random()) / ((double) MAX_RANDOM_VALUE)) + 0.5);
+ (((double) random()) / ((double) MAX_RANDOM_VALUE)) + 0.5);
/* wrap back to minimum delay when max is exceeded */
if (cur_delay > MAX_DELAY_CSEC)
cur_delay = MIN_DELAY_CSEC;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.96 2003/08/04 02:40:04 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.97 2003/08/08 21:42:04 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
Oid elemtype;
FmgrInfo coerce_finfo;
- } alc_extra;
+ } alc_extra;
alc_extra *my_extra;
FunctionCallInfoData locfcinfo;
{
ArrayMetaState inp_extra;
ArrayMetaState ret_extra;
- } am_extra;
+ } am_extra;
am_extra *my_extra;
ArrayMetaState *inp_extra;
ArrayMetaState *ret_extra;
char typalign;
FmgrInfo eqproc;
FmgrInfo ordproc;
- } ac_extra;
+ } ac_extra;
ac_extra *my_extra;
element_type = ARR_ELEMTYPE(array1);
Oid srctype;
Oid desttype;
FmgrInfo coerce_finfo;
- } atc_extra;
+ } atc_extra;
atc_extra *my_extra;
FunctionCallInfoData locfcinfo;
* rcontext is where to keep working state
*/
ArrayBuildState *
-accumArrayResult(ArrayBuildState * astate,
+accumArrayResult(ArrayBuildState *astate,
Datum dvalue, bool disnull,
Oid element_type,
MemoryContext rcontext)
* rcontext is where to construct result
*/
Datum
-makeArrayResult(ArrayBuildState * astate,
+makeArrayResult(ArrayBuildState *astate,
MemoryContext rcontext)
{
int dims[1];
* rcontext is where to construct result
*/
Datum
-makeMdArrayResult(ArrayBuildState * astate,
+makeMdArrayResult(ArrayBuildState *astate,
int ndims,
int *dims,
int *lbs,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.112 2003/08/05 18:30:21 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.113 2003/08/08 21:42:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* *numfields - set to the actual number of fields detected
*
* The fields extracted from the input are stored as separate, null-terminated
- * strings in the workspace at lowstr. Any text is converted to lower case.
+ * strings in the workspace at lowstr. Any text is converted to lower case.
*
* Several field types are assigned:
* DTK_NUMBER - digits and (possibly) a decimal point
else if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
{
/* save delimiting character to use later */
- char delim = *cp;
+ char delim = *cp;
*lp++ = *cp++;
/* second field is all digits? then no embedded text month */
*/
if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
{
- char delim = *cp;
+ char delim = *cp;
ftype[nf] = DTK_DATE;
*lp++ = *cp++;
if (*cp == '.')
{
- double frac;
+ double frac;
/*
* More than two digits before decimal point? Then could be a date
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/oracle_compat.c,v 1.47 2003/08/04 00:43:25 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/oracle_compat.c,v 1.48 2003/08/08 21:42:06 momjian Exp $
*
*-------------------------------------------------------------------------
*/
********************************************************************/
Datum
-chr(PG_FUNCTION_ARGS)
+chr (PG_FUNCTION_ARGS)
{
int32 cvalue = PG_GETARG_INT32(0);
text *result;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/regexp.c,v 1.48 2003/08/04 02:40:05 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/regexp.c,v 1.49 2003/08/08 21:42:07 momjian Exp $
*
* Alistair Crooks added the code for the regex caching
* agc - cached the regular expressions used - there's a good chance
text *cre_pat; /* original RE (untoasted TEXT form) */
int cre_flags; /* compile flags: extended,icase etc */
regex_t cre_re; /* the compiled regular expression */
-} cached_re_str;
+} cached_re_str;
static int num_res = 0; /* # of cached re's */
static cached_re_str re_array[MAX_CACHED_RES]; /* cached re's */
* back to source text
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.149 2003/08/04 00:43:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.150 2003/08/08 21:42:09 momjian Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
char **schemaname, char **refname, char **attname);
static RangeTblEntry *find_rte_by_refname(const char *refname,
deparse_context *context);
-static const char *get_simple_binary_op_name(OpExpr * expr);
+static const char *get_simple_binary_op_name(OpExpr *expr);
static bool isSimpleNode(Node *node, Node *parentNode, int prettyFlags);
static void appendStringInfoSpaces(StringInfo buf, int count);
static void appendContextKeyword(deparse_context *context, const char *str,
int indentBefore, int indentAfter, int indentPlus);
static void get_rule_expr(Node *node, deparse_context *context,
bool showimplicit);
-static void get_oper_expr(OpExpr * expr, deparse_context *context);
-static void get_func_expr(FuncExpr * expr, deparse_context *context,
+static void get_oper_expr(OpExpr *expr, deparse_context *context);
+static void get_func_expr(FuncExpr *expr, deparse_context *context,
bool showimplicit);
static void get_agg_expr(Aggref *aggref, deparse_context *context);
static Node *strip_type_coercion(Node *expr, Oid resultType);
* will return single char binary operator name, or NULL if it's not
*/
static const char *
-get_simple_binary_op_name(OpExpr * expr)
+get_simple_binary_op_name(OpExpr *expr)
{
List *args = expr->args;
* get_oper_expr - Parse back an OpExpr node
*/
static void
-get_oper_expr(OpExpr * expr, deparse_context *context)
+get_oper_expr(OpExpr *expr, deparse_context *context)
{
StringInfo buf = context->buf;
Oid opno = expr->opno;
* get_func_expr - Parse back a FuncExpr node
*/
static void
-get_func_expr(FuncExpr * expr, deparse_context *context,
+get_func_expr(FuncExpr *expr, deparse_context *context,
bool showimplicit)
{
StringInfo buf = context->buf;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.144 2003/08/04 02:40:05 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.145 2003/08/08 21:42:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{ /* varinfos is a List of these */
Var *var;
double ndistinct;
- } MyVarInfo;
+ } MyVarInfo;
/* We should not be called unless query has GROUP BY (or DISTINCT) */
Assert(groupExprs != NIL);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/timestamp.c,v 1.91 2003/08/08 00:10:31 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/timestamp.c,v 1.92 2003/08/08 21:42:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#ifdef HAVE_INT64_TIMESTAMP
return ((dt1 < dt2) ? -1 : ((dt1 > dt2) ? 1 : 0));
#else
+
/*
* When using float representation, we have to be wary of NaNs.
*
- * We consider all NANs to be equal and larger than any non-NAN. This
- * is somewhat arbitrary; the important thing is to have a consistent
+ * We consider all NANs to be equal and larger than any non-NAN. This is
+ * somewhat arbitrary; the important thing is to have a consistent
* sort order.
*/
if (isnan(dt1))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.118 2003/08/04 02:40:06 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.119 2003/08/08 21:42:11 momjian Exp $
*
*-------------------------------------------------------------------------
*/
char *context; /* context message */
int cursorpos; /* cursor index into query string */
int saved_errno; /* errno at entry */
-} ErrorData;
+} ErrorData;
/* We provide a small stack of ErrorData records for re-entrant cases */
#define ERRORDATA_STACK_SIZE 5
} while (0)
-static void send_message_to_server_log(ErrorData * edata);
-static void send_message_to_frontend(ErrorData * edata);
-static char *expand_fmt_string(const char *fmt, ErrorData * edata);
+static void send_message_to_server_log(ErrorData *edata);
+static void send_message_to_frontend(ErrorData *edata);
+static char *expand_fmt_string(const char *fmt, ErrorData *edata);
static const char *useful_strerror(int errnum);
static const char *error_severity(int elevel);
static const char *print_timestamp(void);
* Write error report to server's log
*/
static void
-send_message_to_server_log(ErrorData * edata)
+send_message_to_server_log(ErrorData *edata)
{
StringInfoData buf;
* Write error report to client
*/
static void
-send_message_to_frontend(ErrorData * edata)
+send_message_to_frontend(ErrorData *edata)
{
StringInfoData msgbuf;
* The result is a palloc'd string.
*/
static char *
-expand_fmt_string(const char *fmt, ErrorData * edata)
+expand_fmt_string(const char *fmt, ErrorData *edata)
{
StringInfoData buf;
const char *cp;
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/misc/help_config.c,v 1.4 2003/08/04 00:43:27 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/misc/help_config.c,v 1.5 2003/08/08 21:42:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
struct config_real real;
struct config_int integer;
struct config_string string;
-} mixedStruct;
+} mixedStruct;
/* function prototypes */
-static bool varMatches(mixedStruct * structToTest);
+static bool varMatches(mixedStruct *structToTest);
static int compareMixedStructs(const void *, const void *);
static mixedStruct **varsToDisplay(int *resultListSize);
static const char *usageErrMsg(void);
static void listAllGroups(void);
static void printGenericHead(struct config_generic structToPrint);
static void printGenericFoot(struct config_generic structToPrint);
-static void printMixedStruct(mixedStruct * structToPrint);
-static bool displayStruct(mixedStruct * structToDisplay);
+static void printMixedStruct(mixedStruct *structToPrint);
+static bool displayStruct(mixedStruct *structToDisplay);
/*
* + It's flag bits are set to GUC_DISALLOW_IN_FILE
*/
static bool
-displayStruct(mixedStruct * structToDisplay)
+displayStruct(mixedStruct *structToDisplay)
{
if (structToDisplay->generic.flags & (GUC_NO_SHOW_ALL |
GUC_NOT_IN_SAMPLE |
* be returned to the user.
*/
static bool
-varMatches(mixedStruct * structToTest)
+varMatches(mixedStruct *structToTest)
{
bool matches = false;
bool specificSearch = false; /* This is true if the user
* a different format, depending on what the user wants to see.
*/
static void
-printMixedStruct(mixedStruct * structToPrint)
+printMixedStruct(mixedStruct *structToPrint)
{
printGenericHead(structToPrint->generic);
*
* Copyright (c) 2000-2003, PostgreSQL Global Development Group
*
- * $Header: /cvsroot/pgsql/src/bin/psql/common.c,v 1.70 2003/08/04 23:59:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/bin/psql/common.c,v 1.71 2003/08/08 21:42:24 momjian Exp $
*/
#include "postgres_fe.h"
#include "common.h"
*/
static bool
PrintQueryResults(PGresult *results,
- const TimevalStruct * before,
- const TimevalStruct * after)
+ const TimevalStruct *before,
+ const TimevalStruct *after)
{
bool success = false;
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: genam.h,v 1.42 2003/08/04 02:40:10 momjian Exp $
+ * $Id: genam.h,v 1.43 2003/08/08 21:42:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
bool vacuum_full; /* VACUUM FULL (we have exclusive lock) */
int message_level; /* ereport level for progress messages */
-} IndexVacuumCleanupInfo;
+} IndexVacuumCleanupInfo;
/* Struct for heap-or-index scans of system tables */
typedef struct SysScanDescData
IndexBulkDeleteCallback callback,
void *callback_state);
extern IndexBulkDeleteResult *index_vacuum_cleanup(Relation indexRelation,
- IndexVacuumCleanupInfo * info,
+ IndexVacuumCleanupInfo *info,
IndexBulkDeleteResult *stats);
extern RegProcedure index_cost_estimator(Relation indexRelation);
extern RegProcedure index_getprocid(Relation irel, AttrNumber attnum,
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: nbtree.h,v 1.69 2003/08/04 02:40:10 momjian Exp $
+ * $Id: nbtree.h,v 1.70 2003/08/08 21:42:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
uint32 level;
BlockNumber fastroot;
uint32 fastlevel;
-} xl_btree_metadata;
+} xl_btree_metadata;
/*
* This is what we need to know about simple (without split) insert.
BlockNumber leftblk; /* child block's left sibling, if any */
BlockNumber rightblk; /* child block's right sibling */
/* xl_btree_metadata FOLLOWS IF XLOG_BTREE_DELETE_PAGE_META */
-} xl_btree_delete_page;
+} xl_btree_delete_page;
#define SizeOfBtreeDeletePage (offsetof(xl_btree_delete_page, rightblk) + sizeof(BlockNumber))
{
RelFileNode node;
xl_btree_metadata meta;
-} xl_btree_newmeta;
+} xl_btree_newmeta;
#define SizeOfBtreeNewmeta (sizeof(xl_btree_newmeta))
RelFileNode node;
BlockNumber blkno; /* location of new page */
/* entire page contents follow at end of record */
-} xl_btree_newpage;
+} xl_btree_newpage;
#define SizeOfBtreeNewpage (offsetof(xl_btree_newpage, blkno) + sizeof(BlockNumber))
* Portions Copyright (c) 2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: slru.h,v 1.2 2003/08/04 00:43:30 momjian Exp $
+ * $Id: slru.h,v 1.3 2003/08/08 21:42:32 momjian Exp $
*/
#ifndef SLRU_H
#define SLRU_H
* doesn't need to be in shared memory.
*/
LWLockId BufferLocks[NUM_CLOG_BUFFERS]; /* Per-buffer I/O locks */
-} SlruLockData;
+} SlruLockData;
typedef SlruLockData *SlruLock;
typedef struct SlruCtlData
*/
bool (*PagePrecedes) (int, int);
-} SlruCtlData;
+} SlruCtlData;
typedef SlruCtlData *SlruCtl;
extern int SimpleLruShmemSize(void);
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: xact.h,v 1.54 2003/08/04 02:40:10 momjian Exp $
+ * $Id: xact.h,v 1.55 2003/08/08 21:42:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
TRANS_INPROGRESS,
TRANS_COMMIT,
TRANS_ABORT
-} TransState;
+} TransState;
/*
* transaction block states - transaction state of client queries
TBLOCK_END,
TBLOCK_ABORT,
TBLOCK_ENDABORT
-} TBlockState;
+} TBlockState;
/* ----------------
* transaction state structure
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_constraint.h,v 1.8 2003/08/04 02:40:12 momjian Exp $
+ * $Id: pg_constraint.h,v 1.9 2003/08/08 21:42:32 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
CONSTRAINT_RELATION,
CONSTRAINT_DOMAIN,
CONSTRAINT_ASSERTION
-} CONSTRAINTCATEGORY;
+} CONSTRAINTCATEGORY;
/*
* prototypes for functions in pg_constraint.c
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: portalcmds.h,v 1.12 2003/08/04 02:40:13 momjian Exp $
+ * $Id: portalcmds.h,v 1.13 2003/08/08 21:42:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/portal.h"
-extern void PerformCursorOpen(DeclareCursorStmt * stmt);
+extern void PerformCursorOpen(DeclareCursorStmt *stmt);
extern void PerformPortalFetch(FetchStmt *stmt, DestReceiver *dest,
char *completionTag);
*
* Copyright (c) 2002-2003, PostgreSQL Global Development Group
*
- * $Id: prepare.h,v 1.7 2003/08/04 00:43:30 momjian Exp $
+ * $Id: prepare.h,v 1.8 2003/08/08 21:42:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
List *plan_list; /* list of plans */
List *argtype_list; /* list of parameter type OIDs */
MemoryContext context; /* context containing this query */
-} PreparedStatement;
+} PreparedStatement;
/* Utility statements PREPARE, EXECUTE, DEALLOCATE, EXPLAIN EXECUTE */
bool throwError);
extern void DropPreparedStatement(const char *stmt_name, bool showError);
extern List *FetchPreparedStatementParams(const char *stmt_name);
-extern TupleDesc FetchPreparedStatementResultDesc(PreparedStatement * stmt);
+extern TupleDesc FetchPreparedStatementResultDesc(PreparedStatement *stmt);
#endif /* PREPARE_H */
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: sequence.h,v 1.25 2003/08/04 02:40:13 momjian Exp $
+ * $Id: sequence.h,v 1.26 2003/08/08 21:42:41 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Datum setval_and_iscalled(PG_FUNCTION_ARGS);
extern void DefineSequence(CreateSeqStmt *stmt);
-extern void AlterSequence(AlterSeqStmt * stmt);
+extern void AlterSequence(AlterSeqStmt *stmt);
extern void seq_redo(XLogRecPtr lsn, XLogRecord *rptr);
extern void seq_undo(XLogRecPtr lsn, XLogRecord *rptr);
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: executor.h,v 1.98 2003/08/04 02:40:13 momjian Exp $
+ * $Id: executor.h,v 1.99 2003/08/08 21:42:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* prototypes from functions in execAmi.c
*/
-extern void ExecReScan(PlanState * node, ExprContext *exprCtxt);
-extern void ExecMarkPos(PlanState * node);
-extern void ExecRestrPos(PlanState * node);
+extern void ExecReScan(PlanState *node, ExprContext *exprCtxt);
+extern void ExecMarkPos(PlanState *node);
+extern void ExecRestrPos(PlanState *node);
extern bool ExecSupportsMarkRestore(NodeTag plantype);
extern bool ExecSupportsBackwardScan(Plan *node);
TupleTableSlot *slot,
bool *isnew);
extern TupleHashEntry ScanTupleHashTable(TupleHashTable hashtable,
- TupleHashIterator * state);
+ TupleHashIterator *state);
/*
* prototypes from functions in execJunk.c
extern void ExecutorEnd(QueryDesc *queryDesc);
extern void ExecutorRewind(QueryDesc *queryDesc);
extern void ExecCheckRTPerms(List *rangeTable, CmdType operation);
-extern void ExecEndPlan(PlanState * planstate, EState *estate);
+extern void ExecEndPlan(PlanState *planstate, EState *estate);
extern void ExecConstraints(ResultRelInfo *resultRelInfo,
TupleTableSlot *slot, EState *estate);
extern TupleTableSlot *EvalPlanQual(EState *estate, Index rti,
* prototypes from functions in execProcnode.c
*/
extern PlanState *ExecInitNode(Plan *node, EState *estate);
-extern TupleTableSlot *ExecProcNode(PlanState * node);
+extern TupleTableSlot *ExecProcNode(PlanState *node);
extern int ExecCountSlotsNode(Plan *node);
-extern void ExecEndNode(PlanState * node);
+extern void ExecEndNode(PlanState *node);
/*
* prototypes from functions in execQual.c
bool *isNull);
extern Datum GetAttributeByName(TupleTableSlot *slot, char *attname,
bool *isNull);
-extern void init_fcache(Oid foid, FuncExprState * fcache,
+extern void init_fcache(Oid foid, FuncExprState *fcache,
MemoryContext fcacheCxt);
-extern Datum ExecMakeFunctionResult(FuncExprState * fcache,
+extern Datum ExecMakeFunctionResult(FuncExprState *fcache,
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone);
-extern Tuplestorestate *ExecMakeTableFunctionResult(ExprState * funcexpr,
+extern Tuplestorestate *ExecMakeTableFunctionResult(ExprState *funcexpr,
ExprContext *econtext,
TupleDesc expectedDesc,
TupleDesc *returnDesc);
-extern Datum ExecEvalExpr(ExprState * expression, ExprContext *econtext,
+extern Datum ExecEvalExpr(ExprState *expression, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
-extern Datum ExecEvalExprSwitchContext(ExprState * expression, ExprContext *econtext,
+extern Datum ExecEvalExprSwitchContext(ExprState *expression, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
-extern ExprState *ExecInitExpr(Expr *node, PlanState * parent);
-extern SubPlanState *ExecInitExprInitPlan(SubPlan *node, PlanState * parent);
+extern ExprState *ExecInitExpr(Expr *node, PlanState *parent);
+extern SubPlanState *ExecInitExprInitPlan(SubPlan *node, PlanState *parent);
extern ExprState *ExecPrepareExpr(Expr *node, EState *estate);
extern bool ExecQual(List *qual, ExprContext *econtext, bool resultForNull);
extern int ExecTargetListLength(List *targetlist);
/*
* prototypes from functions in execScan.c
*/
-typedef TupleTableSlot *(*ExecScanAccessMtd) (ScanState * node);
+typedef TupleTableSlot *(*ExecScanAccessMtd) (ScanState *node);
-extern TupleTableSlot *ExecScan(ScanState * node, ExecScanAccessMtd accessMtd);
-extern void ExecAssignScanProjectionInfo(ScanState * node);
+extern TupleTableSlot *ExecScan(ScanState *node, ExecScanAccessMtd accessMtd);
+extern void ExecAssignScanProjectionInfo(ScanState *node);
/*
* prototypes from functions in execTuples.c
extern void ExecSetSlotDescriptor(TupleTableSlot *slot,
TupleDesc tupdesc, bool shouldFree);
extern void ExecSetSlotDescriptorIsNew(TupleTableSlot *slot, bool isNew);
-extern void ExecInitResultTupleSlot(EState *estate, PlanState * planstate);
-extern void ExecInitScanTupleSlot(EState *estate, ScanState * scanstate);
+extern void ExecInitResultTupleSlot(EState *estate, PlanState *planstate);
+extern void ExecInitScanTupleSlot(EState *estate, ScanState *scanstate);
extern TupleTableSlot *ExecInitExtraTupleSlot(EState *estate);
extern TupleTableSlot *ExecInitNullTupleSlot(EState *estate,
TupleDesc tupType);
extern TupleDesc ExecTypeFromTL(List *targetList, bool hasoid);
extern TupleDesc ExecCleanTypeFromTL(List *targetList, bool hasoid);
-extern void UpdateChangedParamSet(PlanState * node, Bitmapset * newchg);
+extern void UpdateChangedParamSet(PlanState *node, Bitmapset *newchg);
typedef struct TupOutputState
{
ResetExprContext((estate)->es_per_tuple_exprcontext); \
} while (0)
-extern void ExecAssignExprContext(EState *estate, PlanState * planstate);
-extern void ExecAssignResultType(PlanState * planstate,
+extern void ExecAssignExprContext(EState *estate, PlanState *planstate);
+extern void ExecAssignResultType(PlanState *planstate,
TupleDesc tupDesc, bool shouldFree);
-extern void ExecAssignResultTypeFromOuterPlan(PlanState * planstate);
-extern void ExecAssignResultTypeFromTL(PlanState * planstate);
-extern TupleDesc ExecGetResultType(PlanState * planstate);
+extern void ExecAssignResultTypeFromOuterPlan(PlanState *planstate);
+extern void ExecAssignResultTypeFromTL(PlanState *planstate);
+extern TupleDesc ExecGetResultType(PlanState *planstate);
extern ProjectionInfo *ExecBuildProjectionInfo(List *targetList,
ExprContext *econtext,
TupleTableSlot *slot);
-extern void ExecAssignProjectionInfo(PlanState * planstate);
-extern void ExecFreeExprContext(PlanState * planstate);
-extern TupleDesc ExecGetScanType(ScanState * scanstate);
-extern void ExecAssignScanType(ScanState * scanstate,
+extern void ExecAssignProjectionInfo(PlanState *planstate);
+extern void ExecFreeExprContext(PlanState *planstate);
+extern TupleDesc ExecGetScanType(ScanState *scanstate);
+extern void ExecAssignScanType(ScanState *scanstate,
TupleDesc tupDesc, bool shouldFree);
-extern void ExecAssignScanTypeFromOuterPlan(ScanState * scanstate);
+extern void ExecAssignScanTypeFromOuterPlan(ScanState *scanstate);
extern void ExecOpenIndices(ResultRelInfo *resultRelInfo);
extern void ExecCloseIndices(ResultRelInfo *resultRelInfo);
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodeSeqscan.h,v 1.18 2003/08/04 02:40:13 momjian Exp $
+ * $Id: nodeSeqscan.h,v 1.19 2003/08/08 21:42:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern int ExecCountSlotsSeqScan(SeqScan *node);
extern SeqScanState *ExecInitSeqScan(SeqScan *node, EState *estate);
-extern TupleTableSlot *ExecSeqScan(SeqScanState * node);
-extern void ExecEndSeqScan(SeqScanState * node);
-extern void ExecSeqMarkPos(SeqScanState * node);
-extern void ExecSeqRestrPos(SeqScanState * node);
-extern void ExecSeqReScan(SeqScanState * node, ExprContext *exprCtxt);
+extern TupleTableSlot *ExecSeqScan(SeqScanState *node);
+extern void ExecEndSeqScan(SeqScanState *node);
+extern void ExecSeqMarkPos(SeqScanState *node);
+extern void ExecSeqRestrPos(SeqScanState *node);
+extern void ExecSeqReScan(SeqScanState *node, ExprContext *exprCtxt);
#endif /* NODESEQSCAN_H */
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodeSubplan.h,v 1.17 2003/08/04 02:40:13 momjian Exp $
+ * $Id: nodeSubplan.h,v 1.18 2003/08/08 21:42:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/execnodes.h"
-extern void ExecInitSubPlan(SubPlanState * node, EState *estate);
-extern Datum ExecSubPlan(SubPlanState * node,
+extern void ExecInitSubPlan(SubPlanState *node, EState *estate);
+extern Datum ExecSubPlan(SubPlanState *node,
ExprContext *econtext,
bool *isNull);
-extern void ExecEndSubPlan(SubPlanState * node);
-extern void ExecReScanSetParamPlan(SubPlanState * node, PlanState * parent);
+extern void ExecEndSubPlan(SubPlanState *node);
+extern void ExecReScanSetParamPlan(SubPlanState *node, PlanState *parent);
-extern void ExecSetParamPlan(SubPlanState * node, ExprContext *econtext);
+extern void ExecSetParamPlan(SubPlanState *node, ExprContext *econtext);
#endif /* NODESUBPLAN_H */
*
* Copyright (c) 2003, PostgreSQL Global Development Group
*
- * $Id: getaddrinfo.h,v 1.9 2003/08/07 16:45:21 tgl Exp $
+ * $Id: getaddrinfo.h,v 1.10 2003/08/08 21:42:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define EAI_SERVICE -8
#define EAI_MEMORY -10
#define EAI_SYSTEM -11
-
#endif
#ifndef AI_PASSIVE
char *ai_canonname;
struct addrinfo *ai_next;
};
-
-#endif /* HAVE_STRUCT_ADDRINFO */
+#endif /* HAVE_STRUCT_ADDRINFO */
#ifndef HAVE_GETADDRINFO
extern int getnameinfo(const struct sockaddr * sa, int salen,
char *node, int nodelen,
char *service, int servicelen, int flags);
-
#endif /* HAVE_GETADDRINFO */
#endif /* GETADDRINFO_H */
*
* Portions Copyright (c) 2003, PostgreSQL Global Development Group
*
- * $Header: /cvsroot/pgsql/src/include/getopt_long.h,v 1.3 2003/08/07 21:11:58 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/include/getopt_long.h,v 1.4 2003/08/08 21:42:31 momjian Exp $
*/
#ifndef GETOPT_LONG_H
#define GETOPT_LONG_H
#define no_argument 0
#define required_argument 1
-
#endif
#ifndef HAVE_GETOPT_LONG
extern int getopt_long(int argc, char *const argv[],
const char *optstring,
const struct option * longopts, int *longindex);
-
#endif
-#endif /* GETOPT_LONG_H */
+#endif /* GETOPT_LONG_H */
*
* Copyright (c) 2003, PostgreSQL Global Development Group
*
- * $Id: bitmapset.h,v 1.3 2003/08/04 00:43:31 momjian Exp $
+ * $Id: bitmapset.h,v 1.4 2003/08/08 21:42:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
int nwords; /* number of words in array */
bitmapword words[1]; /* really [nwords] */
-} Bitmapset; /* VARIABLE LENGTH STRUCT */
+} Bitmapset; /* VARIABLE LENGTH STRUCT */
/* result of bms_membership */
BMS_EMPTY_SET, /* 0 members */
BMS_SINGLETON, /* 1 member */
BMS_MULTIPLE /* >1 member */
-} BMS_Membership;
+} BMS_Membership;
/*
* function prototypes in nodes/bitmapset.c
*/
-extern Bitmapset *bms_copy(const Bitmapset * a);
-extern bool bms_equal(const Bitmapset * a, const Bitmapset * b);
+extern Bitmapset *bms_copy(const Bitmapset *a);
+extern bool bms_equal(const Bitmapset *a, const Bitmapset *b);
extern Bitmapset *bms_make_singleton(int x);
-extern void bms_free(Bitmapset * a);
+extern void bms_free(Bitmapset *a);
-extern Bitmapset *bms_union(const Bitmapset * a, const Bitmapset * b);
-extern Bitmapset *bms_intersect(const Bitmapset * a, const Bitmapset * b);
-extern Bitmapset *bms_difference(const Bitmapset * a, const Bitmapset * b);
-extern bool bms_is_subset(const Bitmapset * a, const Bitmapset * b);
-extern bool bms_is_member(int x, const Bitmapset * a);
-extern bool bms_overlap(const Bitmapset * a, const Bitmapset * b);
-extern bool bms_nonempty_difference(const Bitmapset * a, const Bitmapset * b);
-extern int bms_singleton_member(const Bitmapset * a);
-extern int bms_num_members(const Bitmapset * a);
+extern Bitmapset *bms_union(const Bitmapset *a, const Bitmapset *b);
+extern Bitmapset *bms_intersect(const Bitmapset *a, const Bitmapset *b);
+extern Bitmapset *bms_difference(const Bitmapset *a, const Bitmapset *b);
+extern bool bms_is_subset(const Bitmapset *a, const Bitmapset *b);
+extern bool bms_is_member(int x, const Bitmapset *a);
+extern bool bms_overlap(const Bitmapset *a, const Bitmapset *b);
+extern bool bms_nonempty_difference(const Bitmapset *a, const Bitmapset *b);
+extern int bms_singleton_member(const Bitmapset *a);
+extern int bms_num_members(const Bitmapset *a);
/* optimized tests when we don't need to know exact membership count: */
-extern BMS_Membership bms_membership(const Bitmapset * a);
-extern bool bms_is_empty(const Bitmapset * a);
+extern BMS_Membership bms_membership(const Bitmapset *a);
+extern bool bms_is_empty(const Bitmapset *a);
/* these routines recycle (modify or free) their non-const inputs: */
-extern Bitmapset *bms_add_member(Bitmapset * a, int x);
-extern Bitmapset *bms_del_member(Bitmapset * a, int x);
-extern Bitmapset *bms_add_members(Bitmapset * a, const Bitmapset * b);
-extern Bitmapset *bms_int_members(Bitmapset * a, const Bitmapset * b);
-extern Bitmapset *bms_del_members(Bitmapset * a, const Bitmapset * b);
-extern Bitmapset *bms_join(Bitmapset * a, Bitmapset * b);
+extern Bitmapset *bms_add_member(Bitmapset *a, int x);
+extern Bitmapset *bms_del_member(Bitmapset *a, int x);
+extern Bitmapset *bms_add_members(Bitmapset *a, const Bitmapset *b);
+extern Bitmapset *bms_int_members(Bitmapset *a, const Bitmapset *b);
+extern Bitmapset *bms_del_members(Bitmapset *a, const Bitmapset *b);
+extern Bitmapset *bms_join(Bitmapset *a, Bitmapset *b);
/* support for iterating through the integer elements of a set: */
-extern int bms_first_member(Bitmapset * a);
+extern int bms_first_member(Bitmapset *a);
#endif /* BITMAPSET_H */
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: execnodes.h,v 1.102 2003/08/04 02:40:13 momjian Exp $
+ * $Id: execnodes.h,v 1.103 2003/08/08 21:42:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
uint32 hashkey; /* exact hash key of this entry */
HeapTuple firstTuple; /* copy of first tuple in this group */
/* there may be additional data beyond the end of this struct */
-} TupleHashEntryData; /* VARIABLE LENGTH STRUCT */
+} TupleHashEntryData; /* VARIABLE LENGTH STRUCT */
typedef struct TupleHashTableData
{
Size entrysize; /* actual size to make each hash entry */
int nbuckets; /* number of buckets in hash table */
TupleHashEntry buckets[1]; /* VARIABLE LENGTH ARRAY */
-} TupleHashTableData; /* VARIABLE LENGTH STRUCT */
+} TupleHashTableData; /* VARIABLE LENGTH STRUCT */
typedef struct
{
TupleHashEntry next_entry; /* next entry in current chain */
int next_bucket; /* next chain */
-} TupleHashIterator;
+} TupleHashIterator;
#define ResetTupleHashIterator(iter) \
((iter)->next_entry = NULL, \
{
NodeTag type;
Expr *expr; /* associated Expr node */
-} ExprState;
+} ExprState;
/* ----------------
* GenericExprState node
{
ExprState xprstate;
ExprState *arg; /* state of my child node */
-} GenericExprState;
+} GenericExprState;
/* ----------------
* AggrefExprState node
ExprState xprstate;
ExprState *target; /* state of my child node */
int aggno; /* ID number for agg within its plan node */
-} AggrefExprState;
+} AggrefExprState;
/* ----------------
* ArrayRefExprState node
int16 refelemlength; /* typlen of the array element type */
bool refelembyval; /* is the element type pass-by-value? */
char refelemalign; /* typalign of the element type */
-} ArrayRefExprState;
+} ArrayRefExprState;
/* ----------------
* FuncExprState node
* data only if setArgsValid is true.
*/
FunctionCallInfoData setArgs;
-} FuncExprState;
+} FuncExprState;
/* ----------------
* ScalarArrayOpExprState node
int16 typlen;
bool typbyval;
char typalign;
-} ScalarArrayOpExprState;
+} ScalarArrayOpExprState;
/* ----------------
* BoolExprState node
{
ExprState xprstate;
List *args; /* states of argument expression(s) */
-} BoolExprState;
+} BoolExprState;
/* ----------------
* SubPlanState node
AttrNumber *keyColIdx; /* control data for hash tables */
FmgrInfo *eqfunctions; /* comparison functions for hash tables */
FmgrInfo *hashfunctions; /* lookup data for hash functions */
-} SubPlanState;
+} SubPlanState;
/* ----------------
* CaseExprState node
ExprState xprstate;
List *args; /* the arguments (list of WHEN clauses) */
ExprState *defresult; /* the default result (ELSE clause) */
-} CaseExprState;
+} CaseExprState;
/* ----------------
* CaseWhenState node
ExprState xprstate;
ExprState *expr; /* condition expression */
ExprState *result; /* substitution result */
-} CaseWhenState;
+} CaseWhenState;
/* ----------------
* ArrayExprState node
int16 elemlength; /* typlen of the array element type */
bool elembyval; /* is the element type pass-by-value? */
char elemalign; /* typalign of the element type */
-} ArrayExprState;
+} ArrayExprState;
/* ----------------
* CoalesceExprState node
{
ExprState xprstate;
List *args; /* the arguments */
-} CoalesceExprState;
+} CoalesceExprState;
/* ----------------
* CoerceToDomainState node
ExprState *arg; /* input expression */
/* Cached list of constraints that need to be checked */
List *constraints; /* list of DomainConstraintState nodes */
-} CoerceToDomainState;
+} CoerceToDomainState;
/*
* DomainConstraintState - one item to check during CoerceToDomain
{
DOM_CONSTRAINT_NOTNULL,
DOM_CONSTRAINT_CHECK
-} DomainConstraintType;
+} DomainConstraintType;
typedef struct DomainConstraintState
{
DomainConstraintType constrainttype; /* constraint type */
char *name; /* name of constraint (for error msgs) */
ExprState *check_expr; /* for CHECK, a boolean expression */
-} DomainConstraintState;
+} DomainConstraintState;
/* ----------------------------------------------------------------
ProjectionInfo *ps_ProjInfo; /* info for doing tuple projection */
bool ps_TupFromTlist;/* state flag for processing set-valued
* functions in targetlist */
-} PlanState;
+} PlanState;
/* ----------------
* these are are defined to avoid confusion problems with "left"
Relation ss_currentRelation;
HeapScanDesc ss_currentScanDesc;
TupleTableSlot *ss_ScanTupleSlot;
-} ScanState;
+} ScanState;
/*
* SeqScan uses a bare ScanState as its state node, since it needs
LIMIT_SUBPLANEOF, /* at EOF of subplan (within window) */
LIMIT_WINDOWEND, /* stepped off end of window */
LIMIT_WINDOWSTART /* stepped off beginning of window */
-} LimitStateCond;
+} LimitStateCond;
typedef struct LimitState
{
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parsenodes.h,v 1.245 2003/08/04 02:40:13 momjian Exp $
+ * $Id: parsenodes.h,v 1.246 2003/08/08 21:42:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
QSRC_INSTEAD_RULE, /* added by unconditional INSTEAD rule */
QSRC_QUAL_INSTEAD_RULE, /* added by conditional INSTEAD rule */
QSRC_NON_INSTEAD_RULE /* added by non-INSTEAD rule */
-} QuerySource;
+} QuerySource;
/*****************************************************************************
AEXPR_DISTINCT, /* IS DISTINCT FROM - name must be "=" */
AEXPR_NULLIF, /* NULLIF - name must be "=" */
AEXPR_OF /* IS (not) OF - name must be "=" or "!=" */
-} A_Expr_Kind;
+} A_Expr_Kind;
typedef struct A_Expr
{
NodeTag type;
RangeVar *relation;
bool including_defaults;
-} InhRelation;
+} InhRelation;
/*
* IndexElem - index parameters (used in CREATE INDEX)
OBJECT_TYPE,
OBJECT_USER,
OBJECT_VIEW
-} ObjectType;
+} ObjectType;
/* ----------------------
* Create Schema Statement
* new owner */
Node *def; /* definition of default or constraint */
DropBehavior behavior; /* RESTRICT or CASCADE for DROP cases */
-} AlterDomainStmt;
+} AlterDomainStmt;
/* ----------------------
ONCOMMIT_PRESERVE_ROWS, /* ON COMMIT PRESERVE ROWS (do nothing) */
ONCOMMIT_DELETE_ROWS, /* ON COMMIT DELETE ROWS */
ONCOMMIT_DROP /* ON COMMIT DROP */
-} OnCommitAction;
+} OnCommitAction;
typedef struct CreateStmt
{
NodeTag type;
RangeVar *sequence; /* the sequence to alter */
List *options;
-} AlterSeqStmt;
+} AlterSeqStmt;
/* ----------------------
* Create {Aggregate|Operator|Type} Statement
char *portalname; /* name of the portal (cursor) */
int options; /* bitmask of options (see above) */
Node *query; /* the SELECT query */
-} DeclareCursorStmt;
+} DeclareCursorStmt;
/* ----------------------
* Close Portal Statement
/* for these, howMany indicates a position; only one row is fetched */
FETCH_ABSOLUTE,
FETCH_RELATIVE
-} FetchDirection;
+} FetchDirection;
#define FETCH_ALL LONG_MAX
TRANS_STMT_START, /* semantically identical to BEGIN */
TRANS_STMT_COMMIT,
TRANS_STMT_ROLLBACK
-} TransactionStmtKind;
+} TransactionStmtKind;
typedef struct TransactionStmt
{
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_list.h,v 1.39 2003/08/04 02:40:13 momjian Exp $
+ * $Id: pg_list.h,v 1.40 2003/08/08 21:42:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
List *head;
List *tail;
-} FastList;
+} FastList;
#define FastListInit(fl) ( (fl)->head = (fl)->tail = NIL )
#define FastListFromList(fl, l) \
extern List *lappendi(List *list, int datum);
extern List *lappendo(List *list, Oid datum);
extern List *nconc(List *list1, List *list2);
-extern void FastAppend(FastList * fl, void *datum);
-extern void FastAppendi(FastList * fl, int datum);
-extern void FastAppendo(FastList * fl, Oid datum);
-extern void FastConc(FastList * fl, List *cells);
-extern void FastConcFast(FastList * fl, FastList * fl2);
+extern void FastAppend(FastList *fl, void *datum);
+extern void FastAppendi(FastList *fl, int datum);
+extern void FastAppendo(FastList *fl, Oid datum);
+extern void FastConc(FastList *fl, List *cells);
+extern void FastConcFast(FastList *fl, FastList *fl2);
extern void *nth(int n, List *l);
extern int length(List *list);
extern void *llast(List *list);
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: plannodes.h,v 1.67 2003/08/04 02:40:13 momjian Exp $
+ * $Id: plannodes.h,v 1.68 2003/08/08 21:42:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
AGG_PLAIN, /* simple agg across all input rows */
AGG_SORTED, /* grouped agg, input must be sorted */
AGG_HASHED /* grouped agg, use internal hashtable */
-} AggStrategy;
+} AggStrategy;
typedef struct Agg
{
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: primnodes.h,v 1.89 2003/08/04 02:40:13 momjian Exp $
+ * $Id: primnodes.h,v 1.90 2003/08/08 21:42:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
COERCION_IMPLICIT, /* coercion in context of expression */
COERCION_ASSIGNMENT, /* coercion in context of assignment */
COERCION_EXPLICIT /* explicit cast operation */
-} CoercionContext;
+} CoercionContext;
/*
* CoercionForm - information showing how to display a function-call node
COERCE_EXPLICIT_CAST, /* display as an explicit cast */
COERCE_IMPLICIT_CAST, /* implicit cast, so hide it */
COERCE_DONTCARE /* special case for pathkeys */
-} CoercionForm;
+} CoercionForm;
/*
* FuncExpr - expression node for a function call
bool funcretset; /* true if function returns set */
CoercionForm funcformat; /* how to display this function call */
List *args; /* arguments to the function */
-} FuncExpr;
+} FuncExpr;
/*
* OpExpr - expression node for an operator invocation
Oid opresulttype; /* PG_TYPE OID of result value */
bool opretset; /* true if operator returns set */
List *args; /* arguments to the operator (1 or 2) */
-} OpExpr;
+} OpExpr;
/*
* DistinctExpr - expression node for "x IS DISTINCT FROM y"
Oid opfuncid; /* PG_PROC OID of underlying function */
bool useOr; /* true for ANY, false for ALL */
List *args; /* the scalar and array operands */
-} ScalarArrayOpExpr;
+} ScalarArrayOpExpr;
/*
* BoolExpr - expression node for the basic Boolean operators AND, OR, NOT
typedef enum BoolExprType
{
AND_EXPR, OR_EXPR, NOT_EXPR
-} BoolExprType;
+} BoolExprType;
typedef struct BoolExpr
{
Expr xpr;
BoolExprType boolop;
List *args; /* arguments to this expression */
-} BoolExpr;
+} BoolExpr;
/* ----------------
* SubLink
Oid element_typeid; /* common type of expression elements */
List *elements; /* the array elements */
int ndims; /* number of array dimensions */
-} ArrayExpr;
+} ArrayExpr;
/*
* CoalesceExpr - a COALESCE expression
Expr xpr;
Oid coalescetype; /* type of expression result */
List *args; /* the arguments */
-} CoalesceExpr;
+} CoalesceExpr;
/*
* NullIfExpr - a NULLIF expression
Oid resulttype; /* domain type ID (result type) */
int32 resulttypmod; /* output typmod (currently always -1) */
CoercionForm coercionformat; /* how to display this node */
-} CoerceToDomain;
+} CoerceToDomain;
/*
* Placeholder node for the value to be processed by a domain's check
Expr xpr;
Oid typeId; /* type for substituted value */
int32 typeMod; /* typemod for substituted value */
-} CoerceToDomainValue;
+} CoerceToDomainValue;
/*
* Placeholder node for a DEFAULT marker in an INSERT or UPDATE command.
Expr xpr;
Oid typeId; /* type for substituted value */
int32 typeMod; /* typemod for substituted value */
-} SetToDefault;
+} SetToDefault;
/*
* TargetEntry -
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: relation.h,v 1.84 2003/08/04 02:40:13 momjian Exp $
+ * $Id: relation.h,v 1.85 2003/08/08 21:42:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
Cost startup; /* one-time cost */
Cost per_tuple; /* per-evaluation cost */
-} QualCost;
+} QualCost;
/*----------
* RelOptInfo
Path path;
Path *subpath;
List *constantqual;
-} ResultPath;
+} ResultPath;
/*
* MaterialPath represents use of a Material plan node, i.e., caching of
{
Path path;
Path *subpath;
-} MaterialPath;
+} MaterialPath;
/*
* UniquePath represents elimination of distinct rows from the output of
Path *subpath;
bool use_hash;
double rows; /* estimated number of result tuples */
-} UniquePath;
+} UniquePath;
/*
* All join-type paths share these fields.
bool isouterjoin; /* true if join is outer */
/* Best path for this lookup key: */
Path *best_innerpath; /* best inner indexscan, or NULL if none */
-} InnerIndexscanInfo;
+} InnerIndexscanInfo;
/*
* IN clause info.
* Note: sub_targetlist is just a list of Vars or expressions; it does
* not contain TargetEntry nodes.
*/
-} InClauseInfo;
+} InClauseInfo;
#endif /* RELATION_H */
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: clauses.h,v 1.67 2003/08/04 02:40:13 momjian Exp $
+ * $Id: clauses.h,v 1.68 2003/08/08 21:42:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void clause_get_relids_vars(Node *clause, Relids *relids, List **vars);
extern int NumRelids(Node *clause);
-extern void CommuteClause(OpExpr * clause);
+extern void CommuteClause(OpExpr *clause);
extern Node *eval_const_expressions(Node *node);
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: cost.h,v 1.56 2003/08/04 02:40:13 momjian Exp $
+ * $Id: cost.h,v 1.57 2003/08/08 21:42:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void cost_nestloop(NestPath *path, Query *root);
extern void cost_mergejoin(MergePath *path, Query *root);
extern void cost_hashjoin(HashPath *path, Query *root);
-extern void cost_qual_eval(QualCost * cost, List *quals);
+extern void cost_qual_eval(QualCost *cost, List *quals);
extern void set_baserel_size_estimates(Query *root, RelOptInfo *rel);
extern void set_joinrel_size_estimates(Query *root, RelOptInfo *rel,
RelOptInfo *outer_rel,
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: planmain.h,v 1.74 2003/08/04 02:40:14 momjian Exp $
+ * $Id: planmain.h,v 1.75 2003/08/08 21:42:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
extern void set_plan_references(Plan *plan, List *rtable);
extern void fix_opfuncids(Node *node);
-extern void set_opfuncid(OpExpr * opexpr);
+extern void set_opfuncid(OpExpr *opexpr);
#endif /* PLANMAIN_H */
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: port.h,v 1.11 2003/08/08 04:52:22 momjian Exp $
+ * $Id: port.h,v 1.12 2003/08/08 21:42:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#endif
/* Portable path handling for Unix/Win32 */
-extern bool is_absolute_path(const char *filename);
-extern char *first_path_separator(const char *filename);
-extern char *last_path_separator(const char *filename);
-extern char *get_progname(char *argv0);
+extern bool is_absolute_path(const char *filename);
+extern char *first_path_separator(const char *filename);
+extern char *last_path_separator(const char *filename);
+extern char *get_progname(char *argv0);
extern char *simple_prompt(const char *prompt, int maxlen, bool echo);
#if defined(bsdi) || defined(netbsd)
-extern int fseeko(FILE *stream, off_t offset, int whence);
-extern off_t ftello(FILE *stream);
+extern int fseeko(FILE *stream, off_t offset, int whence);
+extern off_t ftello(FILE *stream);
#endif
#ifdef WIN32
* Win32 doesn't have reliable rename/unlink during concurrent access
*/
#ifndef FRONTEND
-extern int pgrename(const char *from, const char *to);
-extern int pgunlink(const char *path);
+extern int pgrename(const char *from, const char *to);
+extern int pgunlink(const char *path);
#define rename(from, to) pgrename(from, to)
#define unlink(path) pgunlink(path)
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
- * $Id: regex.h,v 1.24 2003/08/04 00:43:32 momjian Exp $
+ * $Id: regex.h,v 1.25 2003/08/08 21:42:51 momjian Exp $
*/
/*
typedef struct
{
regmatch_t rm_extend; /* see REG_EXPECT */
-} rm_detail_t;
+} rm_detail_t;
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: freespace.h,v 1.12 2003/08/04 02:40:14 momjian Exp $
+ * $Id: freespace.h,v 1.13 2003/08/08 21:42:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
BlockNumber blkno; /* which page in relation */
Size avail; /* space available on this page */
-} PageFreeSpaceInfo;
+} PageFreeSpaceInfo;
/* GUC variables */
extern Size GetAvgFSMRequestSize(RelFileNode *rel);
extern void RecordRelationFreeSpace(RelFileNode *rel,
int nPages,
- PageFreeSpaceInfo * pageSpaces);
+ PageFreeSpaceInfo *pageSpaces);
extern BlockNumber GetFreeIndexPage(RelFileNode *rel);
extern void RecordIndexFreeSpace(RelFileNode *rel,
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: dest.h,v 1.41 2003/08/06 17:46:46 tgl Exp $
+ * $Id: dest.h,v 1.42 2003/08/08 21:42:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
DestReceiver *self);
/* Per-executor-run initialization and shutdown: */
void (*rStartup) (DestReceiver *self,
- int operation,
- TupleDesc typeinfo);
+ int operation,
+ TupleDesc typeinfo);
void (*rShutdown) (DestReceiver *self);
/* Destroy the receiver object itself (if dynamically allocated) */
void (*rDestroy) (DestReceiver *self);
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: acl.h,v 1.60 2003/08/04 02:40:15 momjian Exp $
+ * $Id: acl.h,v 1.61 2003/08/08 21:42:55 momjian Exp $
*
* NOTES
* For backward-compatibility purposes we have to allow there
ACL_KIND_OPCLASS, /* pg_opclass */
ACL_KIND_CONVERSION, /* pg_conversion */
MAX_ACL_KIND /* MUST BE LAST */
-} AclObjectKind;
+} AclObjectKind;
/*
* routines used internally
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: array.h,v 1.44 2003/08/04 02:40:15 momjian Exp $
+ * $Id: array.h,v 1.45 2003/08/08 21:42:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
int16 typlen; /* needed info about datatype */
bool typbyval;
char typalign;
-} ArrayBuildState;
+} ArrayBuildState;
/*
* structure to cache type metadata needed for array manipulation
Oid typelem;
Oid typiofunc;
FmgrInfo proc;
-} ArrayMetaState;
+} ArrayMetaState;
/*
* fmgr macros for array objects
Oid elmtype,
int elmlen, bool elmbyval, char elmalign,
Datum **elemsp, int *nelemsp);
-extern ArrayBuildState *accumArrayResult(ArrayBuildState * astate,
+extern ArrayBuildState *accumArrayResult(ArrayBuildState *astate,
Datum dvalue, bool disnull,
Oid element_type,
MemoryContext rcontext);
-extern Datum makeArrayResult(ArrayBuildState * astate,
+extern Datum makeArrayResult(ArrayBuildState *astate,
MemoryContext rcontext);
-extern Datum makeMdArrayResult(ArrayBuildState * astate, int ndims,
+extern Datum makeMdArrayResult(ArrayBuildState *astate, int ndims,
int *dims, int *lbs, MemoryContext rcontext);
/*
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: builtins.h,v 1.226 2003/08/04 02:40:15 momjian Exp $
+ * $Id: builtins.h,v 1.227 2003/08/08 21:42:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Datum rtrim(PG_FUNCTION_ARGS);
extern Datum rtrim1(PG_FUNCTION_ARGS);
extern Datum translate(PG_FUNCTION_ARGS);
-extern Datum chr(PG_FUNCTION_ARGS);
+extern Datum chr (PG_FUNCTION_ARGS);
extern Datum repeat(PG_FUNCTION_ARGS);
extern Datum ascii(PG_FUNCTION_ARGS);
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: elog.h,v 1.62 2003/08/04 02:40:15 momjian Exp $
+ * $Id: elog.h,v 1.63 2003/08/08 21:42:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
struct ErrorContextCallback *previous;
void (*callback) (void *arg);
void *arg;
-} ErrorContextCallback;
+} ErrorContextCallback;
extern DLLIMPORT ErrorContextCallback *error_context_stack;
PGERROR_TERSE, /* single-line error messages */
PGERROR_DEFAULT, /* recommended style */
PGERROR_VERBOSE /* all the facts, ma'am */
-} PGErrorVerbosity;
+} PGErrorVerbosity;
extern PGErrorVerbosity Log_error_verbosity;
extern bool Log_timestamp;
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: lsyscache.h,v 1.78 2003/08/04 02:40:15 momjian Exp $
+ * $Id: lsyscache.h,v 1.79 2003/08/08 21:42:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
IOFunc_output,
IOFunc_receive,
IOFunc_send
-} IOFuncSelector;
+} IOFuncSelector;
extern bool op_in_opclass(Oid opno, Oid opclass);
extern bool op_requires_recheck(Oid opno, Oid opclass);
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: portal.h,v 1.46 2003/08/04 02:40:15 momjian Exp $
+ * $Id: portal.h,v 1.47 2003/08/08 21:42:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
PORTAL_ONE_SELECT,
PORTAL_UTIL_SELECT,
PORTAL_MULTI_QUERY
-} PortalStrategy;
+} PortalStrategy;
/*
* Note: typedef Portal is declared in tcop/dest.h as
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-misc.c,v 1.101 2003/08/04 17:25:14 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-misc.c,v 1.102 2003/08/08 21:42:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* read data unless the file selected for reading already.
*
* In SSL mode it's even worse: SSL_read() could say WANT_READ and then
- * data could arrive before we make the pqReadReady() test. So we must
- * play dumb and assume there is more data, relying on the SSL layer to
- * detect true EOF.
+ * data could arrive before we make the pqReadReady() test. So we
+ * must play dumb and assume there is more data, relying on the SSL
+ * layer to detect true EOF.
*/
#ifdef USE_SSL
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: libpq-fe.h,v 1.96 2003/08/04 02:40:20 momjian Exp $
+ * $Id: libpq-fe.h,v 1.97 2003/08/08 21:42:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
PQTRANS_INTRANS, /* idle, within transaction block */
PQTRANS_INERROR, /* idle, within failed transaction */
PQTRANS_UNKNOWN /* cannot determine status */
-} PGTransactionStatusType;
+} PGTransactionStatusType;
typedef enum
{
PQERRORS_TERSE, /* single-line error messages */
PQERRORS_DEFAULT, /* recommended style */
PQERRORS_VERBOSE /* all the facts, ma'am */
-} PGVerbosity;
+} PGVerbosity;
/* PGconn encapsulates a connection to the backend.
* The contents of this struct are not supposed to be known to applications.
* ENHANCEMENTS, OR MODIFICATIONS.
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/tcl/pltcl.c,v 1.75 2003/08/04 18:40:50 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/pl/tcl/pltcl.c,v 1.76 2003/08/08 21:42:59 momjian Exp $
*
**********************************************************************/
tupdesc, &tcl_trigtup);
/*
- * Now the command part of the event for TG_op and data for NEW and
- * OLD
+ * Now the command part of the event for TG_op and data for NEW
+ * and OLD
*/
if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
{
projects / postgresql / commitdiff