</para>

</listitem>

<listitem>

<para>For inheritance:</para>

<para>For inheritance and partitioning:</para>

<itemizedlist>

<listitem>

<para>

If a parent column is a generated column, a child column must also be

a generated column using the same expression. In the definition of

the child column, leave off the <literal>GENERATED</literal> clause,

as it will be copied from the parent.

If a parent column is a generated column, its child column must also

be a generated column; however, the child column can have a

different generation expression. The generation expression that is

actually applied during insert or update of a row is the one

associated with the table that the row is physically in.

(This is unlike the behavior for column defaults: for those, the

default value associated with the table named in the query applies.)

</para>

</listitem>

<listitem>

<para>

In case of multiple inheritance, if one parent column is a generated

column, then all parent columns must be generated columns and with the

same expression.

If a parent column is not a generated column, its child column must

not be generated either.

</para>

</listitem>

<listitem>

<para>

For inherited tables, if you write a child column definition without

any <literal>GENERATED</literal> clause in <command>CREATE TABLE

... INHERITS</command>, then its <literal>GENERATED</literal> clause

will automatically be copied from the parent. <command>ALTER TABLE

... INHERIT</command> will insist that parent and child columns

already match as to generation status, but it will not require their

generation expressions to match.

</para>

</listitem>

<listitem>

<para>

If a parent column is not a generated column, a child column may be

defined to be a generated column or not.

Similarly for partitioned tables, if you write a child column

definition without any <literal>GENERATED</literal> clause

in <command>CREATE TABLE ... PARTITION OF</command>, then

its <literal>GENERATED</literal> clause will automatically be copied

from the parent. <command>ALTER TABLE ... ADD PARTITION</command>

will insist that parent and child columns already match as to

generation status, but it will not require their generation

expressions to match.

</para>

</listitem>

<listitem>

<para>

In case of multiple inheritance, if one parent column is a generated

column, then all parent columns must be generated columns. If they

do not all have the same generation expression, then the desired

expression for the child must be specified explicitly.

</para>

</listitem>

</itemizedlist>

*(3) If conflicting defaults are inherited from different parents

*(and not overridden by the child), an error is raised.

*(4) Otherwise the inherited default is used.

*Rule (3) is new in Postgres 7.1; in earlier releases you got a

*rather arbitrary choice of which parent default to use.

*

*Note that the default-value infrastructure is used for generated

*columns' expressions too, so most of the preceding paragraph applies

*to generation expressions too. We insist that a child column be

*generated if and only if its parent(s) are, but it need not have

*the same generation expression.

*----------

*/

static List *

}

/*

* Locate default if any

* Locate default/generation expression if any

*/

if (attribute->atthasdef)

{

/*

* Check for conflicts related to generated columns.

*

* If the parent column is generated, the child column must be

* unadorned and will be made a generated column. (We could

* in theory allow the child column definition specifying the

* exact same generation expression, but that's a bit

* complicated to implement and doesn't seem very useful.) We

* also check that the child column doesn't specify a default

* value or identity, which matches the rules for a single

* column in parse_util.c.

* If the parent column is generated, the child column will be

* made a generated column if it isn't already. If it is a

* generated column, we'll take its generation expression in

* preference to the parent's. We must check that the child

* column doesn't specify a default value or identity, which

* matches the rules for a single column in parse_util.c.

*

* Conversely, if the parent column is not generated, the

* child column can't be either. (We used to allow that, but

* it results in being able to override the generation

* expression via UPDATEs through the parent.)

*/

if (def->generated)

{

if (newdef->generated)

ereport(ERROR,

(errcode(ERRCODE_INVALID_COLUMN_DEFINITION),

errmsg("child column \"%s\" specifies generation expression",

def->colname),

errhint("Omit the generation expression in the definition of the child table column to inherit the generation expression from the parent table.")));

if (newdef->raw_default && !newdef->generated)

ereport(ERROR,

(errcode(ERRCODE_INVALID_COLUMN_DEFINITION),

errmsg("column \"%s\" inherits from generated column but specifies identity",

def->colname)));

}

/*

* If the parent column is not generated, then take whatever

* the child column definition says.

*/

else

{

if (newdef->generated)

def->generated = newdef->generated;

ereport(ERROR,

(errcode(ERRCODE_INVALID_COLUMN_DEFINITION),

errmsg("child column \"%s\" specifies generation expression",

def->colname),

errhint("A child table column cannot be generated unless its parent column is.")));

}

/* If new def has a default, override previous default */

/*

* Now that we have the column definition list for a partition, we can

* check whether the columns referenced in the column constraint specs

* actually exist. Also, we merge NOT NULLand defaults into each

* corresponding column definition.

* actually exist. Also, we mergeparent'sNOT NULLconstraints and

*defaults into eachcorresponding column definition.

*/

if (is_partition)

{

found = true;

coldef->is_not_null |= restdef->is_not_null;

/*

* As above, reject generated columns in partitions that

* are not generated in the parent.

*/

if (restdef->generated && !coldef->generated)

ereport(ERROR,

(errcode(ERRCODE_INVALID_COLUMN_DEFINITION),

errmsg("child column \"%s\" specifies generation expression",

restdef->colname),

errhint("A child table column cannot be generated unless its parent column is.")));

/* Other way around should have been dealt with above */

Assert(!(coldef->generated && !restdef->generated));

/*

* Override the parent's default value for this column

* (coldef->cooked_default) with the partition's local

ereport(ERROR,

(errcode(ERRCODE_INVALID_COLUMN_DEFINITION),

errmsg("column \"%s\" inherits conflicting generation expressions",

def->colname)));

def->colname),

errhint("To resolve the conflict, specify a generation expression explicitly.")));

else

ereport(ERROR,

(errcode(ERRCODE_INVALID_COLUMN_DEFINITION),

attributeName)));

/*

*If parentcolumnisgenerated, child column must be, too.

*Childcolumnmust begenerated if and only if parent column is.

*/

if (attribute->attgenerated && !childatt->attgenerated)

ereport(ERROR,

(errcode(ERRCODE_DATATYPE_MISMATCH),

errmsg("column \"%s\" in child table must be a generated column",

attributeName)));

/*

* Check that both generation expressions match.

*

* The test we apply is to see whether they reverse-compile to the

* same source string. This insulates us from issues like whether

* attributes have the same physical column numbers in parent and

* child relations. (See also constraints_equivalent().)

*/

if (attribute->attgenerated && childatt->attgenerated)

{

TupleConstr *child_constr = child_rel->rd_att->constr;

TupleConstr *parent_constr = parent_rel->rd_att->constr;

char *child_expr = NULL;

char *parent_expr = NULL;

Assert(child_constr != NULL);

Assert(parent_constr != NULL);

for (int i = 0; i < child_constr->num_defval; i++)

{

if (child_constr->defval[i].adnum == childatt->attnum)

{

child_expr =

TextDatumGetCString(DirectFunctionCall2(pg_get_expr,

CStringGetTextDatum(child_constr->defval[i].adbin),

ObjectIdGetDatum(child_rel->rd_id)));

break;

}

}

Assert(child_expr != NULL);

for (int i = 0; i < parent_constr->num_defval; i++)

{

if (parent_constr->defval[i].adnum == attribute->attnum)

{

parent_expr =

TextDatumGetCString(DirectFunctionCall2(pg_get_expr,

CStringGetTextDatum(parent_constr->defval[i].adbin),

ObjectIdGetDatum(parent_rel->rd_id)));

break;

}

}

Assert(parent_expr != NULL);

if (strcmp(child_expr, parent_expr) != 0)

ereport(ERROR,

(errcode(ERRCODE_DATATYPE_MISMATCH),

errmsg("column \"%s\" in child table has a conflicting generation expression",

attributeName)));

}

if (childatt->attgenerated && !attribute->attgenerated)

ereport(ERROR,

(errcode(ERRCODE_DATATYPE_MISMATCH),

errmsg("column \"%s\" in child table must not be a generated column",

attributeName)));

/*

* OK, bump the child column's inheritance count. (If we fail

ereport(ERROR,

(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

errmsg("generated columns are not supported on typed tables")));

if (cxt->partbound)

ereport(ERROR,

(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

errmsg("generated columns are not supported on partitions")));

if (saw_generated)

ereport(ERROR,

(errcode(ERRCODE_SYNTAX_ERROR),

{

boolfoundNotNull;/* Attr was NOT NULL in a parent */

boolfoundDefault;/* Found a default in a parent */

boolfoundGenerated;/* Found a generated in a parent */

boolfoundSameGenerated;/* Found matching GENERATED */

boolfoundDiffGenerated;/* Found non-matching GENERATED */

if (tbinfo->attisdropped[j])

continue;

foundNotNull= false;

foundDefault= false;

foundGenerated= false;

foundSameGenerated= false;

foundDiffGenerated= false;

for (k=0;k<numParents;k++)

{

TableInfo*parent=parents[k];

if (inhAttrInd >=0)

{

foundNotNull |=parent->notnull[inhAttrInd];

foundDefault |= (parent->attrdefs[inhAttrInd]!=NULL&& !parent->attgenerated[inhAttrInd]);

foundGenerated |=parent->attgenerated[inhAttrInd];

foundDefault |= (parent->attrdefs[inhAttrInd]!=NULL&&

!parent->attgenerated[inhAttrInd]);

if (parent->attgenerated[inhAttrInd])

{

if (parent->attrdefs[inhAttrInd]!=NULL&&

tbinfo->attrdefs[j]!=NULL&&

strcmp(parent->attrdefs[inhAttrInd]->adef_expr,

tbinfo->attrdefs[j]->adef_expr)==0)

foundSameGenerated= true;

foundDiffGenerated= true;

}

}

}

tbinfo->attrdefs[j]=attrDef;

}

if (foundGenerated&& !tbinfo->ispartition&& !dopt->binary_upgrade)

if (foundSameGenerated&& !foundDiffGenerated&&

!tbinfo->ispartition&& !dopt->binary_upgrade)

tbinfo->attrdefs[j]=NULL;

}

}

{

/*

* Column generation expressions cannot be dumped separately,

* because there is no syntax for it. The !shouldPrintColumn

* case below will be tempted to set them to separate if they

* are attached to an inherited column without a local

* definition, but that would be wrong and unnecessary,

* because generation expressions are always inherited, so

* there is no need to set them again in child tables, and

* there is no syntax for it either. By setting separate to

* because there is no syntax for it. By setting separate to

* false here we prevent the "default" from being processed as

* its own dumpable object, and flagInhAttrs() will remove it

* from the tablewhen it detectsthat itbelongs to an

*inherited column.

* from the tableif possible (thatis, ifitcan be inherited

*from a parent).

*/

attrdefs[j].separate = false;

}