Allow users to customize ofType columns during table creation #223

Author: mzabuawala

web/pgadmin/browser/server_groups/servers/databases/schemas/tables/__init__.py

@@ -797,6 +797,20 @@ def get_oftype(self, gid, sid, did, scid, tid=None):
                 if not status:
                     return internal_server_error(errormsg=type_cols)
 
+                # Mark columns as inherited from type (not table)
+                # so the UI allows editing defaults/constraints
+                # Also store original values for comparison later
+                for col in type_cols['rows']:
+                    if 'inheritedfrom' in col:
+                        col['inheritedfromtype'] = col['inheritedfrom']
+                        # Keep inheritedfrom for backward compatibility
+                        # but UI will check inheritedfromtype first
+
+                    # Store original values from the composite type
+                    # This allows backend to detect actual modifications
+                    col['original_defval'] = col.get('defval')
+                    col['original_attnotnull'] = col.get('attnotnull', False)
+
                 res.append({
                     'label': row['typname'],
                     'value': row['typname'],

web/pgadmin/browser/server_groups/servers/databases/schemas/tables/columns/static/js/column.ui.js

@@ -160,6 +160,10 @@ export default class ColumnSchema extends BaseUISchema {
     return { cell: this.attlenRange(state) ? 'int' : '' };
   }
 
+  isInheritedFromType(state) {
+    return !isEmptyString(state.inheritedfromtype);
+  }
+
   get baseFields() {
     let obj = this;
 
@@ -284,6 +288,30 @@ export default class ColumnSchema extends BaseUISchema {
         }
         return false;
       },
+    },{
+      /* This field is used to track inheritance from composite types */
+      id: 'inheritedfromtype',
+      label: gettext('Inherited from type'),
+      type: 'text',
+      visible: false,
+    },{
+      /* This field is used to track inheritance from parent tables */
+      id: 'inheritedfromtable',
+      label: gettext('Inherited from table'),
+      type: 'text',
+      visible: false,
+    },{
+      /* Store original DEFAULT from composite type to detect modifications */
+      id: 'original_defval',
+      label: gettext('Original Default'),
+      type: 'text',
+      visible: false,
+    },{
+      /* Store original NOT NULL from composite type to detect modifications */
+      id: 'original_attnotnull',
+      label: gettext('Original NOT NULL'),
+      type: 'boolean',
+      visible: false,
     },{
       id:'geometry', label: gettext('Geometry Type'), deps: ['cltype'],
       group: gettext('Definition'), type: 'select', options: this.geometryTypes,
@@ -712,4 +740,4 @@ export default class ColumnSchema extends BaseUISchema {
 
     return false;
   }
-}
+}

web/pgadmin/browser/server_groups/servers/databases/schemas/tables/columns/utils.py

@@ -364,9 +364,60 @@ def parse_format_columns(data, mode=None):
         # tables 'CREATE' mode
         final_columns = []
 
+        # Get list of columns in primary key constraint
+        pk_columns = set()
+        if 'primary_key' in data and len(data['primary_key']) > 0:
+            for pk in data['primary_key']:
+                if 'columns' in pk:
+                    for col in pk['columns']:
+                        if 'column' in col:
+                            pk_columns.add(col['column'])
+
         for c in columns:
+            # Include non-inherited columns
             if c.get('inheritedfrom', None) is None:
                 final_columns.append(c)
+            # Also include columns inherited from composite types (OF TYPE)
+            # that have modifications (WITH OPTIONS clause)
+            elif c.get('inheritedfromtype', None) is not None:
+                # Check if column has been modified or is in a constraint
+                has_modifications = False
+
+                # Check if column is in PRIMARY KEY constraint
+                # Note: We don't include the column for PRIMARY KEY because
+                # it's added as a separate table-level constraint
+                # Uncomment this if you want column-level PRIMARY KEY:
+                # if c.get('name') in pk_columns:
+                #     has_modifications = True
+
+                # Check for PRIMARY KEY (marked via is_primary_key checkbox)
+                if c.get('is_primary_key'):
+                    has_modifications = True
+
+                # Check if DEFAULT value was actually modified
+                # (different from type)
+                original_defval = c.get('original_defval')
+                current_defval = c.get('defval')
+                # Compare as strings, treating None and empty string
+                # as equivalent
+                orig_val = str(original_defval) \
+                    if original_defval is not None else ''
+                curr_val = str(current_defval) \
+                    if current_defval is not None else ''
+                if orig_val != curr_val:
+                    has_modifications = True
+
+                # Check if NOT NULL was actually modified
+                # (different from type)
+                original_attnotnull = c.get('original_attnotnull', False)
+                current_attnotnull = c.get('attnotnull', False)
+                if original_attnotnull != current_attnotnull:
+                    has_modifications = True
+
+                if has_modifications:
+                    # Mark this column to use WITH OPTIONS syntax in template
+                    c['has_with_options'] = True
+                    final_columns.append(c)
 
         # Now we have all lis of columns which we need
         # to include in our create definition, Let's format them