pgadmin-org
/
pgadmin4
mirror of https://github.com/pgadmin-org/pgadmin4.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Handle sized time/timestamp columns correctly. Fixes #2076

pull/3/head
Murtuza Zabuawala 2017-02-03 14:51:58 +01:00 committed by Dave Page
parent f2ac6fc6a7
commit bf8c3c4180
12 changed files with 248 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -655,13 +655,13 @@ class TableView(PGChildNodeView, DataTypeReader, VacuumSettings):
# If we have length & precision both
matchObj = re.search(r'(\d+),(\d+)', fulltype)
if matchObj:
column['attlen'] = int(matchObj.group(1))
column['attprecision'] = int(matchObj.group(2))
column['attlen'] = matchObj.group(1)
column['attprecision'] = matchObj.group(2)
else:
# If we have length only
matchObj = re.search(r'(\d+)', fulltype)
if matchObj:
column['attlen'] = int(matchObj.group(1))
column['attlen'] = matchObj.group(1)
column['attprecision'] = None
else:
column['attlen'] = None
@ -695,21 +695,7 @@ class TableView(PGChildNodeView, DataTypeReader, VacuumSettings):
edit_types_list.append(present_type)
column['edit_types'] = edit_types_list
# Manual Data type formatting
# If data type has () with them then we need to remove them
# eg bit(1) because we need to match the name with combobox
isArray = False
if column['cltype'].endswith('[]'):
isArray = True
column['cltype'] = column['cltype'].rstrip('[]')
idx = column['cltype'].find('(')
if idx and column['cltype'].endswith(')'):
column['cltype'] = column['cltype'][:idx]
if isArray:
column['cltype'] += "[]"
column['cltype'] = DataTypeReader.parse_type_name(column['cltype'])
if 'indkey' in column:
# Current column
@ -1317,6 +1303,24 @@ class TableView(PGChildNodeView, DataTypeReader, VacuumSettings):
else:
return data_type, False
@staticmethod
def convert_length_precision_to_string(data):
"""
This function is used to convert length & precision to string
to handle case like when user gives 0 as length
Args:
data: Data from client
Returns:
Converted data
"""
if 'attlen' in data and data['attlen'] is not None:
data['attlen'] = str(data['attlen'])
if 'attprecision' in data and data['attprecision'] is not None:
data['attprecision'] = str(data['attprecision'])
return data
def _parse_format_columns(self, data, mode=None):
"""
data:
@ -1344,6 +1348,8 @@ class TableView(PGChildNodeView, DataTypeReader, VacuumSettings):
# check type for '[]' in it
c['cltype'], c['hasSqrBracket'] = self._cltype_formatter(c['cltype'])
c = self.convert_length_precision_to_string(c)
data['columns'][action] = final_columns
else:
# We need to exclude all the columns which are inherited from other tables
@ -1364,6 +1370,8 @@ class TableView(PGChildNodeView, DataTypeReader, VacuumSettings):
# check type for '[]' in it
c['cltype'], c['hasSqrBracket'] = self._cltype_formatter(c['cltype'])
c = self.convert_length_precision_to_string(c)
data['columns'] = final_columns
return data
@ -2200,6 +2208,7 @@ class TableView(PGChildNodeView, DataTypeReader, VacuumSettings):
old_data = res['rows'][0]
old_data['cltype'], old_data['hasSqrBracket'] = self._cltype_formatter(old_data['cltype'])
old_data = self.convert_length_precision_to_string(old_data)
fulltype = self.get_full_type(
old_data['typnspname'], old_data['typname'],
@ -2221,20 +2230,7 @@ class TableView(PGChildNodeView, DataTypeReader, VacuumSettings):
old_data['attlen'] = None
old_data['attprecision'] = None
# Manual Data type formatting
# If data type has () with them then we need to remove them
# eg bit(1) because we need to match the name with combobox
isArray = False
if old_data['cltype'].endswith('[]'):
isArray = True
old_data['cltype'] = old_data['cltype'].rstrip('[]')
idx = old_data['cltype'].find('(')
if idx and old_data['cltype'].endswith(')'):
old_data['cltype'] = old_data['cltype'][:idx]
if isArray:
old_data['cltype'] += "[]"
old_data['cltype'] = DataTypeReader.parse_type_name(old_data['cltype'])
# Sql for alter column
if 'inheritedfrom' not in c:
@ -2251,6 +2247,9 @@ class TableView(PGChildNodeView, DataTypeReader, VacuumSettings):
if 'attacl' in c:
c['attacl'] = parse_priv_to_db(c['attacl'],
self.column_acl)
c = self.convert_length_precision_to_string(c)
if 'inheritedfrom' not in c:
column_sql += render_template("/".join(
[self.column_template_path, 'create.sql']),

41
web/pgadmin/browser/server_groups/servers/databases/schemas/tables/column/__init__.py
View File

@ -436,20 +436,7 @@ class ColumnsView(PGChildNodeView, DataTypeReader):
data['edit_types'] = edit_types_list
# Manual Data type formatting
# If data type has () with them then we need to remove them
# eg bit(1) because we need to match the name with combobox
isArray = False
if data['cltype'].endswith('[]'):
isArray = True
data['cltype'] = data['cltype'].rstrip('[]')
idx = data['cltype'].find('(')
if idx and data['cltype'].endswith(')'):
data['cltype'] = data['cltype'][:idx]
if isArray:
data['cltype'] += "[]"
data['cltype'] = DataTypeReader.parse_type_name(data['cltype'])
return data
@ -511,6 +498,24 @@ class ColumnsView(PGChildNodeView, DataTypeReader):
return type
@staticmethod
def convert_length_precision_to_string(data):
"""
This function is used to convert length & precision to string
to handle case like when user gives 0 as length
Args:
data: Data from client
Returns:
Converted data
"""
if 'attlen' in data and data['attlen'] is not None:
data['attlen'] = str(data['attlen'])
if 'attprecision' in data and data['attprecision'] is not None:
data['attprecision'] = str(data['attprecision'])
return data
@check_precondition
def create(self, gid, sid, did, scid, tid):
"""
@ -560,6 +565,7 @@ class ColumnsView(PGChildNodeView, DataTypeReader):
# check type for '[]' in it
data['cltype'] = self._cltype_formatter(data['cltype'])
data['hasSqrBracket'] = self.hasSqrBracket
data = self.convert_length_precision_to_string(data)
SQL = render_template("/".join([self.template_path,
'create.sql']),
@ -733,6 +739,8 @@ class ColumnsView(PGChildNodeView, DataTypeReader):
"""
This function will genrate sql from model data
"""
data = self.convert_length_precision_to_string(data)
if clid is not None:
SQL = render_template("/".join([self.template_path,
'properties.sql']), tid=tid, clid=clid
@ -746,6 +754,11 @@ class ColumnsView(PGChildNodeView, DataTypeReader):
# We will add table & schema as well
old_data = self._formatter(scid, tid, clid, old_data)
# check type for '[]' in it
if 'cltype' in old_data:
old_data['cltype'] = self._cltype_formatter(old_data['cltype'])
old_data['hasSqrBracket'] = self.hasSqrBracket
# If name is not present in data then
# we will fetch it from old data, we also need schema & table name
if 'name' not in data:

7
web/pgadmin/browser/server_groups/servers/databases/schemas/tables/templates/column/sql/9.2_plus/update.sql
View File

@ -1,6 +1,7 @@
{% import 'column/macros/security.macros' as SECLABEL %}
{% import 'column/macros/privilege.macros' as PRIVILEGE %}
{% import 'macros/variable.macros' as VARIABLE %}
{% import 'type/macros/get_full_type_sql_format.macros' as GET_TYPE %}
{### Rename column name ###}
{% if data.name and data.name != o_data.name %}
ALTER TABLE {{conn|qtIdent(data.schema, data.table)}}
@ -8,11 +9,9 @@ ALTER TABLE {{conn|qtIdent(data.schema, data.table)}}
{% endif %}
{### Alter column type and collation ###}
{% if (data.cltype and data.cltype != o_data.cltype) or (data.attlen and data.attlen != o_data.attlen) or (data.attprecision or data.attprecision != o_data.attprecision) %}
{% if (data.cltype and data.cltype != o_data.cltype) or (data.attlen and data.attlen != o_data.attlen) or (data.attprecision and data.attprecision != o_data.attprecision) %}
ALTER TABLE {{conn|qtIdent(data.schema, data.table)}}
ALTER COLUMN {% if data.name %}{{conn|qtTypeIdent(data.name)}}{% else %}{{conn|qtTypeIdent(o_data.name)}}{% endif %} TYPE {% if data.cltype %}{{conn|qtTypeIdent(data.cltype)}} {% elif o_data.typnspname != 'pg_catalog' %}{{conn|qtTypeIdent(o_data.typnspname, o_data.cltype)}}{% else %}{{conn|qtTypeIdent(o_data.cltype)}} {% endif %}
{% if data.attlen and data.attlen != 'None' %}({{data.attlen}}{% if data.attlen != 'None' and data.attprecision %}, {{data.attprecision}}){% elif (data.cltype is defined and not data.cltype) %}, {{o_data.attprecision}}){% elif data.attlen %}){% endif %}{% endif %}{% if data.hasSqrBracket %}
[]{% endif %}{% if data.collspcname and data.collspcname != o_data.collspcname %}
ALTER COLUMN {% if data.name %}{{conn|qtTypeIdent(data.name)}}{% else %}{{conn|qtTypeIdent(o_data.name)}}{% endif %} TYPE {{ GET_TYPE.UPDATE_TYPE_SQL(conn, data, o_data) }}{% if data.collspcname and data.collspcname != o_data.collspcname %}
COLLATE {{data.collspcname}}{% endif %};
{% endif %}
{### Alter column default value ###}

5
web/pgadmin/browser/server_groups/servers/databases/schemas/tables/templates/column/sql/default/create.sql
View File

@ -1,12 +1,11 @@
{% import 'column/macros/security.macros' as SECLABEL %}
{% import 'column/macros/privilege.macros' as PRIVILEGE %}
{% import 'macros/variable.macros' as VARIABLE %}
{% import 'type/macros/get_full_type_sql_format.macros' as GET_TYPE %}
{### Add column ###}
{% if data.name and data.cltype %}
ALTER TABLE {{conn|qtIdent(data.schema, data.table)}}
ADD COLUMN {{conn|qtIdent(data.name)}} {{conn|qtTypeIdent(data.cltype)}}{% if data.attlen %}
({{data.attlen}}{% if data.attprecision%}, {{data.attprecision}}{% endif %}){% endif %}{% if data.hasSqrBracket %}
[]{% endif %}{% if data.collspcname %}
ADD COLUMN {{conn|qtIdent(data.name)}} {{ GET_TYPE.CREATE_TYPE_SQL(conn, data.cltype, data.attlen, data.attprecision, data.hasSqrBracket) }}{% if data.collspcname %}
COLLATE {{data.collspcname}}{% endif %}{% if data.attnotnull %}
NOT NULL{% endif %}{% if data.defval %}
DEFAULT {{data.defval}}{% endif %};

7
web/pgadmin/browser/server_groups/servers/databases/schemas/tables/templates/column/sql/default/update.sql
View File

@ -1,6 +1,7 @@
{% import 'column/macros/security.macros' as SECLABEL %}
{% import 'column/macros/privilege.macros' as PRIVILEGE %}
{% import 'macros/variable.macros' as VARIABLE %}
{% import 'type/macros/get_full_type_sql_format.macros' as GET_TYPE %}
{### Rename column name ###}
{% if data.name and data.name != o_data.name %}
ALTER TABLE {{conn|qtIdent(data.schema, data.table)}}
@ -8,11 +9,9 @@ ALTER TABLE {{conn|qtIdent(data.schema, data.table)}}
{% endif %}
{### Alter column type and collation ###}
{% if (data.cltype and data.cltype != o_data.cltype) or (data.attlen and data.attlen != o_data.attlen) or (data.attprecision or data.attprecision != o_data.attprecision) %}
{% if (data.cltype and data.cltype != o_data.cltype) or (data.attlen and data.attlen != o_data.attlen) or (data.attprecision and data.attprecision != o_data.attprecision) %}
ALTER TABLE {{conn|qtIdent(data.schema, data.table)}}
ALTER COLUMN {% if data.name %}{{conn|qtTypeIdent(data.name)}}{% else %}{{conn|qtTypeIdent(o_data.name)}}{% endif %} TYPE {% if data.cltype %}{{conn|qtTypeIdent(data.cltype)}} {% elif o_data.typnspname != 'pg_catalog' %}{{conn|qtTypeIdent(o_data.typnspname, o_data.cltype)}}{% else %}{{conn|qtTypeIdent(o_data.cltype)}} {% endif %}
{% if data.attlen and data.attlen != 'None' %}({{data.attlen}}{% if data.attlen != 'None' and data.attprecision %}, {{data.attprecision}}){% elif (data.cltype is defined and not data.cltype) %}, {{o_data.attprecision}}){% elif data.attlen %}){% endif %}{% endif %}{% if data.hasSqrBracket %}
[]{% endif %}{% if data.collspcname and data.collspcname != o_data.collspcname %}
ALTER COLUMN {% if data.name %}{{conn|qtTypeIdent(data.name)}}{% else %}{{conn|qtTypeIdent(o_data.name)}}{% endif %} TYPE {{ GET_TYPE.UPDATE_TYPE_SQL(conn, data, o_data) }}{% if data.collspcname and data.collspcname != o_data.collspcname %}
COLLATE {{data.collspcname}}{% endif %};
{% endif %}
{### Alter column default value ###}

5
web/pgadmin/browser/server_groups/servers/databases/schemas/tables/templates/table/sql/default/create.sql
View File

@ -4,6 +4,7 @@
{% import 'column/macros/security.macros' as COLUMN_SECLABEL %}
{% import 'column/macros/privilege.macros' as COLUMN_PRIVILEGE %}
{% import 'table/sql/macros/constraints.macro' as CONSTRAINTS %}
{% import 'type/macros/get_full_type_sql_format.macros' as GET_TYPE %}
{#===========================================#}
{#====== MAIN TABLE TEMPLATE STARTS HERE ======#}
{#===========================================#}
@ -43,9 +44,7 @@ CREATE {% if data.relpersistence %}UNLOGGED {% endif %}TABLE {{conn|qtIdent(data
{% if c.name and c.cltype %}
{% if loop.index != 1 %},
{% endif %}
{{conn|qtIdent(c.name)}} {{conn|qtTypeIdent(c.cltype)}}{% if c.attlen %}
({{c.attlen}}{% if c.attprecision%}, {{c.attprecision}}{% endif %}){% endif %}{% if c.hasSqrBracket %}
[]{% endif %}{% if c.collspcname %} COLLATE {{c.collspcname}}{% endif %}{% if c.attnotnull %} NOT NULL{% endif %}{% if c.defval %} DEFAULT {{c.defval}}{% endif %}
{{conn|qtIdent(c.name)}} {{ GET_TYPE.CREATE_TYPE_SQL(conn, c.cltype, c.attlen, c.attprecision, c.hasSqrBracket) }}{% if c.collspcname %} COLLATE {{c.collspcname}}{% endif %}{% if c.attnotnull %} NOT NULL{% endif %}{% if c.defval %} DEFAULT {{c.defval}}{% endif %}
{% endif %}
{% endfor %}
{% endif %}

72
web/pgadmin/browser/server_groups/servers/databases/schemas/types/__init__.py
View File

@ -347,6 +347,43 @@ class TypeView(PGChildNodeView, DataTypeReader):
status=200
)
def _cltype_formatter(self, type):
"""
Args:
data: Type string
Returns:
We need to remove [] from type and append it
after length/precision so we will set flag for
sql template
"""
if '[]' in type:
type = type.replace('[]', '')
self.hasSqrBracket = True
else:
self.hasSqrBracket = False
return type
@staticmethod
def convert_length_precision_to_string(data):
"""
This function is used to convert length & precision to string
to handle case like when user gives 0 as length
Args:
data: Data from client
Returns:
Converted data
"""
if 'tlength' in data and data['tlength'] is not None:
data['tlength'] = str(data['tlength'])
if 'precision' in data and data['precision'] is not None:
data['precision'] = str(data['precision'])
return data
def additional_properties(self, copy_dict, tid):
"""
We will use this function to add additional properties according to type
@ -412,11 +449,17 @@ class TypeView(PGChildNodeView, DataTypeReader):
is_tlength = True if t_len else False
is_precision = True if t_prec else False
type_name = DataTypeReader.parse_type_name(row['typname'])
row['type'] = self._cltype_formatter(type_name)
row['hasSqrBracket'] = self.hasSqrBracket
row = self.convert_length_precision_to_string(row)
composite_lst.append({
'attnum': row['attnum'], 'member_name': row['attname'], 'type': row['typname'],
'collation': full_collate,
'attnum': row['attnum'], 'member_name': row['attname'], 'type': type_name,
'collation': full_collate, 'cltype': row['type'],
'tlength': t_len, 'precision': t_prec,
'is_tlength': is_tlength, 'is_precision': is_precision})
'is_tlength': is_tlength, 'is_precision': is_precision,
'hasSqrBracket': row['hasSqrBracket']})
# Adding both results
res['member_list'] = ', '.join(properties_list)
@ -900,6 +943,12 @@ class TypeView(PGChildNodeView, DataTypeReader):
data = self._convert_for_sql(data)
try:
if 'composite' in data and len(data['composite']) > 0:
for each_type in data['composite']:
each_type = self.convert_length_precision_to_string(each_type)
each_type['cltype'] = self._cltype_formatter(each_type['type'])
each_type['hasSqrBracket'] = self.hasSqrBracket
SQL = render_template("/".join([self.template_path, 'create.sql']),
data=data, conn=self.conn)
status, res = self.conn.execute_dict(SQL)
@ -1118,6 +1167,15 @@ class TypeView(PGChildNodeView, DataTypeReader):
if 'deleted' in data[key]:
data[key]['deleted'] = parse_priv_to_db(data[key]['deleted'], self.acl)
if 'composite' in data and len(data['composite']) > 0:
for key in ['added', 'changed', 'deleted']:
if key in data['composite']:
for each_type in data['composite'][key]:
each_type = self.convert_length_precision_to_string(each_type)
if 'type' in each_type:
each_type['cltype'] = self._cltype_formatter(each_type['type'])
each_type['hasSqrBracket'] = self.hasSqrBracket
SQL = render_template("/".join([self.template_path,
'properties.sql']),
scid=scid, tid=tid,
@ -1169,7 +1227,15 @@ class TypeView(PGChildNodeView, DataTypeReader):
# Privileges
if 'typacl' in data and data['typacl'] is not None:
data['typacl'] = parse_priv_to_db(data['typacl'], self.acl)
data = self._convert_for_sql(data)
if 'composite' in data and len(data['composite']) > 0:
for each_type in data['composite']:
each_type = self.convert_length_precision_to_string(each_type)
each_type['cltype'] = self._cltype_formatter(each_type['type'])
each_type['hasSqrBracket'] = self.hasSqrBracket
SQL = render_template("/".join([self.template_path,
'create.sql']),
data=data, conn=self.conn)

8
web/pgadmin/browser/server_groups/servers/databases/schemas/types/templates/type/js/type.js
View File

@ -113,6 +113,9 @@ function($, _, S, pgAdmin, pgBrowser, alertify, Backgrid) {
m.set('is_tlength', true, {silent: true});
m.set('min_val', o.min_val, {silent: true});
m.set('max_val', o.max_val, {silent: true});
} else {
// set the values in model
m.set('is_tlength', false, {silent: true});
}
}
});
@ -140,6 +143,9 @@ function($, _, S, pgAdmin, pgBrowser, alertify, Backgrid) {
m.set('is_precision', true, {silent: true});
m.set('min_val', o.min_val, {silent: true});
m.set('max_val', o.max_val, {silent: true});
} else {
// set the values in model
m.set('is_precision', false, {silent: true});
}
}
});
@ -166,7 +172,7 @@ function($, _, S, pgAdmin, pgBrowser, alertify, Backgrid) {
if (flag) {
setTimeout(function(){
m.set('collspcname', "");
m.set('collspcname', "", {silent: true});
}, 10);
}
return flag;

62
web/pgadmin/browser/server_groups/servers/databases/schemas/types/templates/type/macros/get_full_type_sql_format.macros
View File

@ -1,13 +1,17 @@
{% macro CREATE_TYPE_SQL(conn, type_name, type_length, type_precision, is_type_array) %}
{% if type_name.startswith('time') and type_length %}
{#############################################################}
{###### Need to check against separate time types - START ######}
{#############################################################}
{% if type_name == "timestamp without time zone" %}
timestamp({{ type_length }}) without time zone{% elif type_name == "timestamp with time zone" %}
timestamp({{ type_length }}) with time zone{% elif type_name == "time without time zone" %}
time({{ type_length }}) without time zone{% elif type_name == "time with time zone" %}
time({{ type_length }}) with time zone{% endif %}{% if is_type_array %}
[]{% endif %}
{#############################################################}
{###### Need to check against separate time types - END ######}
{#############################################################}
{% else %}
{{ conn|qtTypeIdent(type_name) }}{% if type_length %}
({{ type_length }}{% if type_precision%}, {{ type_precision }}{% endif %}){% endif %}{% if is_type_array %}
@ -19,45 +23,41 @@ time({{ type_length }}) with time zone{% endif %}{% if is_type_array %}
{######################################################}
{% macro UPDATE_TYPE_SQL(conn, data, o_data) %}
{% if data.cltype and data.cltype.startswith('time') and data.attlen %}
{#############################################################}
{###### Need to check against separate time types - START ######}
{#############################################################}
{% if data.cltype == "timestamp without time zone" %}
timestamp({{ data.attlen }}) without time zone
{% elif data.cltype == "timestamp with time zone" %}
timestamp({{ data.attlen }}) with time zone
{% elif data.cltype == "time without time zone" %}
time({{ data.attlen }}) without time zone
{% elif data.cltype == "time with time zone" %}
time({{ data.attlen }}) with time zone
{% endif %}{% if data.hasSqrBracket %}
[]{% endif %}
timestamp({{ data.attlen }}) without time zone {% elif data.cltype == "timestamp with time zone" %}
timestamp({{ data.attlen }}) with time zone {% elif data.cltype == "time without time zone" %}
time({{ data.attlen }}) without time zone {% elif data.cltype == "time with time zone" %}
time({{ data.attlen }}) with time zone {% endif %}{% if data.hasSqrBracket %}[]{% endif %}
{#############################################################}
{# if only type changes, we need to give previous length to current type#}
{#############################################################}
{% elif data.cltype and data.cltype.startswith('time') and o_data.attlen != 'None' %}
{% if data.cltype == "timestamp without time zone" %}
timestamp({{ o_data.attlen }}) without time zone
{% elif data.cltype == "timestamp with time zone" %}
timestamp({{ o_data.attlen }}) with time zone
{% elif data.cltype == "time without time zone" %}
time({{ o_data.attlen }}) without time zone
{% elif data.cltype == "time with time zone" %}
time({{ o_data.attlen }}) with time zone
{% endif %}{% if data.hasSqrBracket %}
[]{% endif %}
timestamp({{ o_data.attlen }}) without time zone {% elif data.cltype == "timestamp with time zone" %}
timestamp({{ o_data.attlen }}) with time zone {% elif data.cltype == "time without time zone" %}
time({{ o_data.attlen }}) without time zone {% elif data.cltype == "time with time zone" %}
time({{ o_data.attlen }}) with time zone {% endif %}{% if data.hasSqrBracket %}[]{% endif %}
{#############################################################}
{# if only length changes, we need to give previous length to current type#}
{#############################################################}
{% elif data.attlen and o_data.cltype.startswith('time') %}
{% if o_data.cltype == "timestamp without time zone" %}
timestamp({{ data.attlen }}) without time zone
{% elif o_data.cltype == "timestamp with time zone" %}
timestamp({{ data.attlen }}) with time zone
{% elif o_data.cltype == "time without time zone" %}
time({{ data.attlen }}) without time zone
{% elif o_data.cltype == "time with time zone" %}
time({{ data.attlen }}) with time zone
{% endif %}{% if o_data.hasSqrBracket %}
[]{% endif %}
timestamp({{ data.attlen }}) without time zone {% elif o_data.cltype == "timestamp with time zone" %}
timestamp({{ data.attlen }}) with time zone {% elif o_data.cltype == "time without time zone" %}
time({{ data.attlen }}) without time zone {% elif o_data.cltype == "time with time zone" %}
time({{ data.attlen }}) with time zone {% endif %}{% if o_data.hasSqrBracket %}[]{% endif %}
{###### Need to check against separate time types - END ######}
{% else %}
{% if data.cltype %}{{conn|qtTypeIdent(data.cltype)}} {% elif o_data.typnspname != 'pg_catalog' %}{{conn|qtTypeIdent(o_data.typnspname, o_data.cltype)}}{% else %}{{conn|qtTypeIdent(o_data.cltype)}} {% endif %}
{% if data.attlen and data.attlen != 'None' %}({{data.attlen}}{% if data.attlen != 'None' and data.attprecision %}, {{data.attprecision}}){% elif (data.cltype is defined and not data.cltype) %}, {{o_data.attprecision}}){% elif data.attlen %}){% endif %}{% endif %}{% if data.hasSqrBracket %}
[]{% endif %}
{% elif (data.cltype and not data.cltype.startswith('time')) or not o_data.cltype.startswith('time') %}
{#############################################################}
{########## We will create SQL for other types here ##########}
{#############################################################}
{% if data.cltype %}{{conn|qtTypeIdent(data.cltype)}} {% elif o_data.typnspname != 'pg_catalog' %}{{conn|qtTypeIdent(o_data.typnspname, o_data.cltype)}}{% else %}{{conn|qtTypeIdent(o_data.cltype)}} {% endif %}{% if (data.attlen and data.attlen != 'None') or (data.attprecision and data.attprecision != 'None') %}
{% if data.attlen and data.attlen != 'None' %}
({{ data.attlen }}{% elif data.attprecision and data.attprecision != 'None' %}({{ o_data.attlen }}{% endif %}{% if data.attprecision and data.attprecision != 'None' %}
, {{ data.attprecision }}){% elif o_data.attprecision and o_data.attprecision != 'None' %}, {{ o_data.attprecision }}){% else %}){% endif %}
{% endif %}
{% endif %}
{% endmacro %}

3
web/pgadmin/browser/server_groups/servers/databases/schemas/types/templates/type/sql/default/create.sql
View File

@ -1,5 +1,6 @@
{% import 'macros/schemas/security.macros' as SECLABEL %}
{% import 'macros/schemas/privilege.macros' as PRIVILEGE %}
{% import 'type/macros/get_full_type_sql_format.macros' as GET_TYPE %}
{## If user selected shell type then just create type template ##}
{% if data and data.typtype == 'p' %}
CREATE TYPE {{ conn|qtIdent(data.schema, data.name) }};
@ -7,7 +8,7 @@ CREATE TYPE {{ conn|qtIdent(data.schema, data.name) }};
{### Composite Type ###}
{% if data and data.typtype == 'c' %}
CREATE TYPE {% if data.schema %}{{ conn|qtIdent(data.schema, data.name) }}{% else %}{{ conn|qtIdent(data.name) }}{% endif %} AS
({{"\n\t"}}{% if data.composite %}{% for d in data.composite %}{% if loop.index != 1 %},{{"\n\t"}}{% endif %}{{ conn|qtIdent(d.member_name) }} {{ d.type }}{% if d.is_tlength and d.tlength %}({{d.tlength}}{% if d.is_precision and d.precision %},{{d.precision}}{% endif %}){% endif %}{% if d.collation %} COLLATE {{d.collation}}{% endif %}{% endfor %}{% endif %}{{"\n"}});
({{"\n\t"}}{% if data.composite %}{% for d in data.composite %}{% if loop.index != 1 %},{{"\n\t"}}{% endif %}{{ conn|qtIdent(d.member_name) }} {{ GET_TYPE.CREATE_TYPE_SQL(conn, d.cltype, d.tlength, d.precision, d.hasSqrBracket) }}{% if d.collation %} COLLATE {{d.collation}}{% endif %}{% endfor %}{% endif %}{{"\n"}});
{% endif %}
{### Enum Type ###}
{% if data and data.typtype == 'e' %}

48
web/pgadmin/browser/server_groups/servers/databases/schemas/types/templates/type/sql/default/update.sql
View File

@ -1,6 +1,6 @@
{% import 'macros/schemas/security.macros' as SECLABEL %}
{% import 'macros/schemas/privilege.macros' as PRIVILEGE %}
{% if data %}
{% import 'type/macros/get_full_type_sql_format.macros' as GET_TYPE %}
{#======================================#}
{# Below will change object owner #}
{% if data.typeowner and data.typeowner != o_data.typeowner %}
@ -28,28 +28,47 @@ ALTER TYPE {{ conn|qtIdent(o_data.schema, o_data.name) }}
{% if 'added' in composite and composite.added|length > 0 %}
{% for r in composite.added %}
ALTER TYPE {{ conn|qtIdent(o_data.schema, o_data.name) }}
ADD ATTRIBUTE {{conn|qtIdent(r.member_name)}} {{conn|qtTypeIdent(r.type)}}{% if r.is_tlength and r.tlength %}
({{r.tlength}}{% if r.is_precision and r.precision %},{{r.precision}}{% endif %}){% endif %}{% if r.collation %}
ADD ATTRIBUTE {{conn|qtIdent(r.member_name)}} {{ GET_TYPE.CREATE_TYPE_SQL(conn, r.cltype, r.tlength, r.precision, r.hasSqrBracket) }}{% if r.collation %}
COLLATE {{r.collation}}{% endif %};
{% endfor %}
{% endif %}
{% if 'changed' in composite and composite.changed|length > 0 %}
{% for r in composite.changed %}
{% for o in o_data.composite %}
{% if o.attnum == r.attnum and r.member_name and o.member_name != r.member_name %}
{##### Variables for the loop #####}
{% set member_name = o.member_name %}
{% set cltype = o.cltype %}
{% set tlength = o.tlength %}
{% set precision = o.precision %}
{% set hasSqrBracket = o.hasSqrBracket %}
{##### If member name changed #####}
{% if o.attnum == r.attnum %}
{% if r.member_name and o.member_name != r.member_name %}
ALTER TYPE {{ conn|qtIdent(o_data.schema, o_data.name) }}
RENAME ATTRIBUTE {{o.member_name}} TO {{r.member_name}};
{% if r.type and o.type != r.type %}
{% set member_name = r.member_name %}
{% endif %}
{##### If type changed #####}
{% if r.cltype and cltype != r.cltype %}
{% set cltype = r.cltype %}
{% set hasSqrBracket = r.hasSqrBracket %}
{##### If length is not allowed on type #####}
{% if not r.is_tlength %}
{% set tlength = 0 %}
{% set precision = 0 %}
{% endif %}
{% endif %}
{##### If length changed #####}
{% if r.tlength and tlength != r.tlength %}
{% set tlength = r.tlength %}
{% endif %}
{##### If precision changed #####}
{% if tlength and r.precision and precision != r.precision %}
{% set precision = r.precision %}
{% endif %}
ALTER TYPE {{ conn|qtIdent(o_data.schema, o_data.name) }}
ALTER ATTRIBUTE {{conn|qtIdent(r.member_name)}} SET DATA TYPE {{conn|qtTypeIdent(r.type)}}{% if r.is_tlength and r.tlength %}
({{r.tlength}}{% if r.is_precision and r.precision %},{{r.precision}}{% endif %}){% endif %}{% if r.collation %}
ALTER ATTRIBUTE {{conn|qtIdent(member_name)}} SET DATA TYPE {{ GET_TYPE.CREATE_TYPE_SQL(conn, cltype, tlength, precision, hasSqrBracket) }}{% if r.collation %}
COLLATE {{r.collation}}{% endif %};
{% else %}
ALTER TYPE {{ conn|qtIdent(o_data.schema, o_data.name) }}
ALTER ATTRIBUTE {{conn|qtIdent(r.member_name)}} SET DATA TYPE {{conn|qtTypeIdent(o.type)}}{% if o.is_tlength and o.tlength %}
({{o.tlength}}{% if o.is_precision and o.precision %},{{o.precision}}{% endif %}){% endif %}{% if o.collation %}
COLLATE {{r.collation}}{% endif %};
{% endif%}
{% endif%}
{% endfor %}
{% endfor %}
@ -135,5 +154,4 @@ ALTER TYPE {% if data.name and data.name != o_data.name %}{{ conn|qtIdent(o_data
{% else %}{{ conn|qtIdent(o_data.schema, o_data.name) }}
{% endif %}
SET SCHEMA {{ conn|qtIdent(data.schema) }};
{% endif %}
{% endif %}
{% endif %}

38
web/pgadmin/browser/server_groups/servers/databases/schemas/utils.py
View File

@ -234,6 +234,44 @@ class DataTypeReader:
else:
return name + length + array
@classmethod
def parse_type_name(cls, type_name):
"""
Returns prase type name without length and precision
so that we can match the end result with types in the select2.
Args:
self: self
type_name: Type name
"""
# Manual Data type formatting
# If data type has () with them then we need to remove them
# eg bit(1) because we need to match the name with combobox
is_array = False
if type_name.endswith('[]'):
is_array = True
type_name = type_name.rstrip('[]')
idx = type_name.find('(')
if idx and type_name.endswith(')'):
type_name = type_name[:idx]
# We need special handling of timestamp types as
# variable precision is between the type
elif idx and type_name.startswith("time"):
end_idx = type_name.find(')')
# If we found the end then form the type string
if end_idx != 1:
from re import sub as sub_str
pattern = r'(\(\d+\))'
type_name = sub_str(pattern, '', type_name)
if is_array:
type_name += "[]"
return type_name
def trigger_definition(data):
"""