</para>

<para>

Column storage and compression settings are inherited from parent

tables. If a column is inherited from multiple tables, the storage

settings or any explicit compression settings for the column must be the

same in all parent tables, else an error is reported. Storage or

compression settings explicitly specified for the new table override any

inherited settings and can also be used to override conflicting

inherited settings.

Column <literal>STORAGE</literal> settings are also copied from parent tables.

</para>

<para>

returnpstrdup(buf);

}

GetAttributeStorageName(charc)

{

switch (c)

{

caseTYPSTORAGE_PLAIN:

return"PLAIN";

caseTYPSTORAGE_EXTERNAL:

return"EXTERNAL";

caseTYPSTORAGE_EXTENDED:

return"EXTENDED";

caseTYPSTORAGE_MAIN:

return"MAIN";

default:

elog(ERROR,"invalid storage type %c",c);

returnNULL;

}

}

#define child_dependency_type(child_is_partition)\

((child_is_partition) ? DEPENDENCY_AUTO : DEPENDENCY_NORMAL)

/*

* Bogus property string to track conflict in inherited properties of a column.

* It is currently used for storage and compression specifications, but may be

* used for other string specifications in future. It can be any string which

* does not look like a valid compression or storage method. It is meant to be

* used by MergeAttributes() and its minions. It is not expected to be stored

* on disk.

*/

static const char *conflicting_column_property = "*** conflicting column property ***";

static void truncate_check_rel(Oid relid, Form_pg_class reltuple);

static void truncate_check_perms(Oid relid, Form_pg_class reltuple);

static void truncate_check_activity(Relation rel);

List **supnotnulls);

static List *MergeCheckConstraint(List *constraints, const char *name, Node *expr);

static void MergeChildAttribute(List *inh_columns, int exist_attno, int newcol_attno, const ColumnDef *newdef);

static ColumnDef *MergeInheritedAttribute(List *inh_columns, int exist_attno, const ColumnDef *newdef,

bool *have_deferred_conflicts);

static ColumnDef *MergeInheritedAttribute(List *inh_columns, int exist_attno, const ColumnDef *newdef);

static void MergeAttributesIntoExisting(Relation child_rel, Relation parent_rel, bool ispartition);

static void MergeConstraintsIntoExisting(Relation child_rel, Relation parent_rel);

static void StoreCatalogInheritance(Oid relationId, List *supers,

const char *column, Node *newValue, LOCKMODE lockmode);

static void index_copy_data(Relation rel, RelFileLocator newrlocator);

static const char *storage_name(char c);

static void RangeVarCallbackForDropRelation(const RangeVar *rel, Oid relOid,

Oid oldRelOid, void *arg);

att->attidentity = entry->identity;

att->attgenerated = entry->generated;

att->attcompression = GetAttributeCompression(att->atttypid, entry->compression);

if (entry->storage_name)

if (entry->storage)

att->attstorage = entry->storage;

else if (entry->storage_name)

att->attstorage = GetAttributeStorage(att->atttypid, entry->storage_name);

}

CheckTableNotInUse(rel, "TRUNCATE");

}

/*

* storage_name

* returns the name corresponding to a typstorage/attstorage enum value

*/

static const char *

storage_name(char c)

{

switch (c)

{

case TYPSTORAGE_PLAIN:

return "PLAIN";

case TYPSTORAGE_EXTERNAL:

return "EXTERNAL";

case TYPSTORAGE_EXTENDED:

return "EXTENDED";

case TYPSTORAGE_MAIN:

return "MAIN";

default:

return "???";

}

}

/*----------

* MergeAttributes

*Returns new schema given initial schema and superclasses.

List *inh_columns = NIL;

List *constraints = NIL;

List *nnconstraints = NIL;

boolhave_deferred_conflicts = false;

boolhave_bogus_defaults = false;

intchild_attno;

static Node bogus_marker = {0}; /* marks conflicting defaults */

List *saved_columns = NIL;

*/

newdef = makeColumnDef(attributeName, attribute->atttypid,

attribute->atttypmod, attribute->attcollation);

newdef->storage_name =GetAttributeStorageName(attribute->attstorage);

newdef->storage = attribute->attstorage;

newdef->generated = attribute->attgenerated;

if (CompressionMethodIsValid(attribute->attcompression))

newdef->compression = GetCompressionMethodName(attribute->attcompression);

newdef->compression =

pstrdup(GetCompressionMethodName(attribute->attcompression));

/*

* Regular inheritance children are independent enough not to

/*

* Yes, try to merge the two column definitions.

*/

mergeddef = MergeInheritedAttribute(inh_columns, exist_attno, newdef,

&have_deferred_conflicts);

mergeddef = MergeInheritedAttribute(inh_columns, exist_attno, newdef);

newattmap->attnums[parent_attno - 1] = exist_attno;

else if (!equal(def->cooked_default, this_default))

{

def->cooked_default = &bogus_marker;

have_deferred_conflicts = true;

have_bogus_defaults = true;

}

}

}

/*

* If we found any conflicting parent default values or conflicting parent

*properties, check to make surethey were overridden by the child.

* If we found any conflicting parent default values, check to make sure

* they were overridden by the child.

*/

if (have_deferred_conflicts)

if (have_bogus_defaults)

{

foreach(lc, columns)

{

def->colname),

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

}

if (def->compression == conflicting_column_property)

ereport(ERROR,

(errcode(ERRCODE_DATATYPE_MISMATCH),

errmsg("column \"%s\" inherits conflicting compression methods",

def->colname),

errhint("To resolve the conflict, specify a compression method explicitly.")));

if (def->storage_name == conflicting_column_property)

ereport(ERROR,

(errcode(ERRCODE_DATATYPE_MISMATCH),

errmsg("column \"%s\" inherits conflicting storage methods",

def->colname),

errhint("To resolve the conflict, specify a storage method explicitly.")));

}

}

inhdef->identity = newdef->identity;

/*

* Child storage specification, if any, overrides inherited storage

* property.

* Copy storage parameter

*/

if (newdef->storage_name != NULL)

inhdef->storage_name = newdef->storage_name;

if (inhdef->storage == 0)

inhdef->storage = newdef->storage;

else if (newdef->storage != 0 && inhdef->storage != newdef->storage)

ereport(ERROR,

(errcode(ERRCODE_DATATYPE_MISMATCH),

errmsg("column \"%s\" has a storage parameter conflict",

attributeName),

errdetail("%s versus %s",

storage_name(inhdef->storage),

storage_name(newdef->storage))));

/*

* Child compression specification, if any, overrides inherited

* compression property.

* Copy compression parameter

*/

if (newdef->compression!= NULL)

if (inhdef->compression== NULL)

inhdef->compression = newdef->compression;

else if (newdef->compression != NULL)

{

if (strcmp(inhdef->compression, newdef->compression) != 0)

ereport(ERROR,

(errcode(ERRCODE_DATATYPE_MISMATCH),

errmsg("column \"%s\" has a compression method conflict",

attributeName),

errdetail("%s versus %s", inhdef->compression, newdef->compression)));

}

/*

* Merge of not-null constraints = OR 'em together

* 'exist_attno' is the number the existing matching attribute in inh_columns.

* 'newdef' is the new parent column/attribute definition to be merged.

*

* Output arguments:

* 'have_deferred_conflicts' is set to true if there is a conflict in inherited

* compression properties; remains unchanged otherwise.

*

* The matching ColumnDef in 'inh_columns' list is modified and returned.

*

* Notes:

static ColumnDef *

MergeInheritedAttribute(List *inh_columns,

int exist_attno,

const ColumnDef *newdef,

bool *have_deferred_conflicts)

const ColumnDef *newdef)

{

char *attributeName = newdef->colname;

ColumnDef *prevdef;

/*

* Copy/check storage parameter

*/

if (prevdef->storage_name == NULL)

prevdef->storage_name = newdef->storage_name;

else if (newdef->storage_name != NULL &&

strcmp(prevdef->storage_name, newdef->storage_name) != 0)

{

prevdef->storage_name = conflicting_column_property;

*have_deferred_conflicts = true;

}

if (prevdef->storage == 0)

prevdef->storage = newdef->storage;

else if (prevdef->storage != newdef->storage)

ereport(ERROR,

(errcode(ERRCODE_DATATYPE_MISMATCH),

errmsg("inherited column \"%s\" has a storage parameter conflict",

attributeName),

errdetail("%s versus %s",

storage_name(prevdef->storage),

storage_name(newdef->storage))));

/*

* Copy/check compression parameter

*/

if (prevdef->compression == NULL)

prevdef->compression = newdef->compression;

else if (newdef->compression !=NULL &&

prevdef->compression= conflicting_column_property;

else if (strcmp(prevdef->compression,newdef->compression) !=0)

errmsg("column \"%s\" has acompressionmethod conflict",

/*

* Check for GENERATED conflicts

n->is_local= true;

n->is_not_null= false;

n->is_from_type= false;

n->storage_name=NULL;

n->storage=0;

n->raw_default=NULL;

n->cooked_default=NULL;

n->collClause=NULL;

n->is_local =true;

n->is_not_null =false;

n->is_from_type =false;

n->storage =0;

n->raw_default =NULL;

n->cooked_default =NULL;

n->collOid = InvalidOid;

n->is_local =true;

n->is_not_null =false;

n->is_from_type =false;

n->storage_name =NULL;

n->storage =0;

n->raw_default =NULL;

n->cooked_default =NULL;

n->collOid = InvalidOid;

n->is_local =true;

n->is_not_null =false;

n->is_from_type =false;

n->storage_name =NULL;

n->storage =0;

n->raw_default =NULL;

n->cooked_default =NULL;

n->collOid = InvalidOid;

n->is_local =true;

n->is_not_null =false;

n->is_from_type =false;

n->storage_name =NULL;

n->storage =0;

n->raw_default =NULL;

n->cooked_default =NULL;

n->collClause = (CollateClause *)$3;

if (table_like_clause->options&CREATE_TABLE_LIKE_STORAGE)

def->storage_name=GetAttributeStorageName(attribute->attstorage);

def->storage=attribute->attstorage;

def->storage_name=NULL;

def->storage=0;

if ((table_like_clause->options&CREATE_TABLE_LIKE_COMPRESSION)!=0

&&CompressionMethodIsValid(attribute->attcompression))

def->compression=GetCompressionMethodName(attribute->attcompression);

pstrdup(GetCompressionMethodName(attribute->attcompression));

def->compression=NULL;

externchar*makeMultirangeTypeName(constchar*rangeTypeName,

OidtypeNamespace);

externconstchar*GetAttributeStorageName(charstorage);

NodeTagtype;

char*colname;/* name of column */

TypeName*typeName;/* type of column */

constchar*compression;/* compression method for column */

char*compression;/* compression method for column */

intinhcount;/* number of times column is inherited */

boolis_local;/* column has local (non-inherited) def'n */

boolis_not_null;/* NOT NULL constraint specified? */

boolis_from_type;/* column definition came from table type */

constchar*storage_name;/* attstorage setting name or NULL for default */

charstorage;/* attstorage setting, or 0 for default */

char*storage_name;/* attstorage setting name or NULL for default */

Node*raw_default;/* default value (untransformed parse tree) */

Node*cooked_default;/* default value (transformed expr tree) */

charidentity;/* attidentity setting */