Copy source query exact datatypes when possible in CREATE TABLE AS SELECT.

Author: asfernandes

doc/sql.extensions/README.create_table_as_query.md

@@ -22,10 +22,25 @@ be explicitly aliased.
 For global and local temporary tables, normal temporary-table data lifetime rules apply. Package temporary tables
 do not support this syntax.
 
+## Datatypes and Domains
+
+When a select list item is a direct reference to a source table or view column, the new column copies the source
+column's exact datatype instead of one derived only from the query's runtime result (which would lose information
+such as declared `NUMERIC`/`DECIMAL` precision).
+
+* If the source column is based on a named domain, the new column references that domain directly, as if it had
+  been declared `<column name> <domain name>`.
+* If the source column is based on an auto-generated (implicit) domain, its exact type (precision/scale, character
+  set, collation, etc.) is copied.
+
+For any other select list item (an expression, a literal, or an aggregate, for example), the new column's datatype
+is derived from the query result.
+
 ## Character Sets
 
-For `CHAR` and `VARCHAR` columns, the database default character set is not used. The character set and collation
-of the new column are copied from the corresponding query expression.
+For `CHAR` and `VARCHAR` columns not covered by the direct column-reference rule above, the database default
+character set is not used. The character set and collation of the new column are copied from the corresponding
+query expression.
 
 String literals use the connection character set, so columns created from string literals inherit the connection
 character set.

src/dsql/DdlNodes.epp

@@ -9986,54 +9986,57 @@ void CreateRelationNode::defineQueryColumns(thread_db* tdbb, DsqlCompilerScratch
 	{
 		MetaName fieldName;
 
-		if (queryColumns)
-			fieldName = nodeAs<FieldNode>(queryColumns->items[position])->dsqlName;
-		else
-		{
-			const ValueExprNode* nameNode = item;
-			const char* aliasName = nullptr;
+		// Unwrap aliases/derived fields/union maps/package references to reach the underlying
+		// node. This is used to find the field name (when no explicit column list is given) and,
+		// in all cases, to detect a direct reference to a source table column so its exact
+		// datatype (and, for named domains, the domain itself) can be copied.
+		const ValueExprNode* nameNode = item;
+		const char* aliasName = nullptr;
 
-			while (nodeIs<DsqlAliasNode>(nameNode) || nodeIs<DerivedFieldNode>(nameNode) ||
-				nodeIs<DsqlMapNode>(nameNode) || nodeAs<PackageReferenceNode>(nameNode))
+		while (nodeIs<DsqlAliasNode>(nameNode) || nodeIs<DerivedFieldNode>(nameNode) ||
+			nodeIs<DsqlMapNode>(nameNode) || nodeAs<PackageReferenceNode>(nameNode))
+		{
+			if (const auto aliasNode = nodeAs<DsqlAliasNode>(nameNode))
 			{
-				if (const auto aliasNode = nodeAs<DsqlAliasNode>(nameNode))
-				{
-					if (!aliasName)
-						aliasName = aliasNode->name.c_str();
-
-					nameNode = aliasNode->value;
-				}
-				else if (const auto mapNode = nodeAs<DsqlMapNode>(nameNode))
-					nameNode = mapNode->map->map_node;
-				else if (const auto derivedField = nodeAs<DerivedFieldNode>(nameNode))
-				{
-					if (!aliasName)
-						aliasName = derivedField->name.c_str();
-
-					nameNode = derivedField->value;
-				}
-				else if (const auto referenceNode = nodeAs<PackageReferenceNode>(nameNode))
-				{
-					if (!aliasName)
-						aliasName = referenceNode->getName();
+				if (!aliasName)
+					aliasName = aliasNode->name.c_str();
 
-					nameNode = nullptr;
-				}
+				nameNode = aliasNode->value;
 			}
+			else if (const auto mapNode = nodeAs<DsqlMapNode>(nameNode))
+				nameNode = mapNode->map->map_node;
+			else if (const auto derivedField = nodeAs<DerivedFieldNode>(nameNode))
+			{
+				if (!aliasName)
+					aliasName = derivedField->name.c_str();
 
-			if (aliasName)
-				fieldName = aliasName;
-			else if (const auto fieldNode = nodeAs<FieldNode>(nameNode))
-				fieldName = fieldNode->dsqlField->fld_name;
-			else
+				nameNode = derivedField->value;
+			}
+			else if (const auto referenceNode = nodeAs<PackageReferenceNode>(nameNode))
 			{
-				status_exception::raise(
-					Arg::Gds(isc_sqlerr) << Arg::Num(-607) <<
-					Arg::Gds(isc_dsql_command_err) <<
-					Arg::Gds(isc_specify_field_err));
+				if (!aliasName)
+					aliasName = referenceNode->getName();
+
+				nameNode = nullptr;
 			}
 		}
 
+		const auto sourceFieldNode = nodeAs<FieldNode>(nameNode);
+
+		if (queryColumns)
+			fieldName = nodeAs<FieldNode>(queryColumns->items[position])->dsqlName;
+		else if (aliasName)
+			fieldName = aliasName;
+		else if (sourceFieldNode)
+			fieldName = sourceFieldNode->dsqlField->fld_name;
+		else
+		{
+			status_exception::raise(
+				Arg::Gds(isc_sqlerr) << Arg::Num(-607) <<
+				Arg::Gds(isc_dsql_command_err) <<
+				Arg::Gds(isc_specify_field_err));
+		}
+
 		for (const auto& name : names)
 		{
 			if (name == fieldName)
@@ -10063,30 +10066,76 @@ void CreateRelationNode::defineQueryColumns(thread_db* tdbb, DsqlCompilerScratch
 
 		auto field = clause->field;
 		field->fld_name = fieldName;
-		field->dtype = desc.dsc_dtype;
-		field->length = desc.dsc_length;
-		field->scale = desc.dsc_scale;
-		field->subType = desc.dsc_sub_type;
 
-		if (desc.dsc_flags & DSC_nullable)
-			field->flags |= FLD_nullable;
+		// If the select item is a direct reference to a source table/view column, copy its
+		// exact datatype rather than relying only on the runtime descriptor. A column based on
+		// a named domain is copied as a full domain reference (inheriting its NOT NULL/DEFAULT/
+		// CHECK, like a hand-written column of that domain). A column based on an implicit
+		// (auto-generated) domain has its exact primitive type copied instead, since implicit
+		// domains must not be shared between tables (they are erased, unconditionally, when
+		// their owning column is dropped).
+		dsql_fld* sourceField = nullptr;
 
-		if (desc.isText() || (desc.isBlob() && desc.getBlobSubType() == isc_blob_text))
+		if (sourceFieldNode && sourceFieldNode->dsqlField &&
+			sourceFieldNode->dsqlField->fld_relation &&
+			!(sourceFieldNode->dsqlField->flags & FLD_computed) &&
+			sourceFieldNode->dsqlField->fieldSource.object.hasData())
 		{
-			field->charSetId = desc.getCharSet();
-			field->collationId = desc.getCollation();
+			sourceField = sourceFieldNode->dsqlField;
 		}
 
-		if (desc.isText())
+		if (sourceField && !fb_utils::implicit_domain(sourceField->fieldSource.object.c_str()))
 		{
-			const USHORT adjust = (desc.dsc_dtype == dtype_varying) ? sizeof(USHORT) : 0;
-			const USHORT bpc = METD_get_charset_bpc(dsqlScratch->getTransaction(), field->charSetId.value_or(CS_NONE));
-			field->charLength = (field->length - adjust) / bpc;
+			// Named domain: reference it directly, like "<field name> <domain name>".
+			field->typeOfName = sourceField->fieldSource;
+			field->fullDomain = true;
+		}
+		else
+		{
+			if (sourceField)
+			{
+				// Implicit domain: copy its exact stored type (precision, charset, collation,
+				// dimensions, etc.) instead of sharing the domain object itself.
+				METD_get_domain(dsqlScratch->getTransaction(), field, sourceField->fieldSource);
+				field->flags &= ~(FLD_computed | FLD_system);
+			}
+			else
+			{
+				field->dtype = desc.dsc_dtype;
+				field->length = desc.dsc_length;
+				field->scale = desc.dsc_scale;
+				field->subType = desc.dsc_sub_type;
+
+				if (desc.isText() || (desc.isBlob() && desc.getBlobSubType() == isc_blob_text))
+				{
+					field->charSetId = desc.getCharSet();
+					field->collationId = desc.getCollation();
+				}
+
+				if (desc.isText())
+				{
+					const USHORT adjust = (desc.dsc_dtype == dtype_varying) ? sizeof(USHORT) : 0;
+					const USHORT bpc = METD_get_charset_bpc(dsqlScratch->getTransaction(), field->charSetId.value_or(CS_NONE));
+					field->charLength = (field->length - adjust) / bpc;
+				}
+				else if (desc.isBlob())
+					field->segLength = 80;
+
+				field->setExactPrecision();
+			}
+
+			field->flags &= ~FLD_nullable;
+			if (desc.dsc_flags & DSC_nullable)
+				field->flags |= FLD_nullable;
+			else
+			{
+				// A newly created (non-domain) column is nullable unless a NOT NULL constraint
+				// is explicitly added - field->flags alone does not drive this, see defineField().
+				auto& notNullConstraint = clause->constraints.add();
+				notNullConstraint.constraintType = AddConstraintClause::CTYPE_NOT_NULL;
+			}
 		}
-		else if (desc.isBlob())
-			field->segLength = 80;
 
-		field->setExactPrecision();
 		clauses.add(clause);
 
 		++position;

src/dsql/metd.epp

@@ -509,6 +509,10 @@ bool METD_get_domain(jrd_tra* transaction, TypeClause* field, const QualifiedNam
 		if (!FLX.RDB$CHARACTER_LENGTH.NULL)
 			field->charLength = FLX.RDB$CHARACTER_LENGTH;
 
+		field->precision = 0;
+		if (!FLX.RDB$FIELD_PRECISION.NULL)
+			field->precision = FLX.RDB$FIELD_PRECISION;
+
 		if (!FLX.RDB$COMPUTED_BLR.NULL)
 			field->flags |= FLD_computed;