diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/__init__.py new file mode 100644 index 0000000..9c89c02 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/__init__.py @@ -0,0 +1,503 @@ +########################################################################## +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +########################################################################## +import json +from flask import render_template, make_response, request, jsonify +from flask.ext.babel import gettext +from pgadmin.utils.ajax import make_json_response, \ + make_response as ajax_response, internal_server_error +from pgadmin.browser.utils import NodeView +from pgadmin.browser.collection import CollectionNodeModule +import pgadmin.browser.server_groups.servers.databases as database +from pgadmin.utils.ajax import precondition_required +from pgadmin.utils.driver import get_driver +from config import PG_DEFAULT_DRIVER +from functools import wraps + + +class CollationModule(CollectionNodeModule): + NODE_TYPE = 'collation' + COLLECTION_LABEL = gettext("Collations") + + def __init__(self, *args, **kwargs): + self.min_ver = None + self.max_ver = None + super(CollationModule, self).__init__(*args, **kwargs) + + # Before loading this module we need to make sure that scid is catalog and schema object + # and catalog name is 'sys', 'dbo', 'information_schema' then only we load this module + def BackendSupported(self, manager, **kwargs): + """ + This function will validate schema name & scid against catalogs then allow us to + make dission if we want to load this module or not for that schema + """ + if super(CollationModule, self).BackendSupported(manager, **kwargs): + conn = manager.connection() + # If DB is not connected then return error to browser + if not conn.connected(): + return precondition_required( + gettext( + "Connection to the server has been lost!" + ) + ) + ver = manager.version + server_type = manager.server_type + # we will set template path for sql scripts + if ver >= 90100: + template_path = 'collation/sql/9.1_plus' + else: + # Note: Collation is not supported below postgres version 9.1 + # Hence we will not load this module + return False + + SQL = render_template("/".join([template_path, + 'backend_support.sql']), + scid=kwargs['scid']) + status, res = conn.execute_scalar(SQL) + # check if any errors + if not status: + return internal_server_error(errormsg=res) + # Check scid is catalog and from 'sys', 'dbo', + # 'information_schema' then False (Do not load this module) + # otherwise True (Load this module) + if res is True: + return False + else: + return True + + def get_nodes(self, gid, sid, did, scid): + """ + Generate the collection node + """ + yield self.generate_browser_collection_node(scid) + + @property + def script_load(self): + """ + Load the module script for database, when any of the database node is + initialized. + """ + return database.DatabaseModule.NODE_TYPE + + @property + def node_inode(self): + return False + +blueprint = CollationModule(__name__) + + +class CollationView(NodeView): + node_type = blueprint.node_type + + parent_ids = [ + {'type': 'int', 'id': 'gid'}, + {'type': 'int', 'id': 'sid'}, + {'type': 'int', 'id': 'did'}, + {'type': 'int', 'id': 'scid'} + ] + ids = [ + {'type': 'int', 'id': 'coid'} + ] + + operations = dict({ + 'obj': [ + {'get': 'properties', 'delete': 'delete', 'put': 'update'}, + {'get': 'list', 'post': 'create'} + ], + 'delete': [{'delete': 'delete'}], + 'children': [{'get': 'children'}], + 'nodes': [{'get': 'node'}, {'get': 'nodes'}], + 'sql': [{'get': 'sql'}], + 'msql': [{'get': 'msql'}, {'get': 'msql'}], + 'stats': [{'get': 'statistics'}], + 'dependency': [{'get': 'dependencies'}], + 'dependent': [{'get': 'dependents'}], + 'module.js': [{}, {}, {'get': 'module_js'}], + 'get_collations': [{'get': 'getCollations'}, {'get': 'getCollations'}] + }) + + def module_js(self): + """ + This property defines (if javascript) exists for this node. + Override this property for your own logic. + """ + return make_response( + render_template( + "collation/js/collation.js", + _=gettext + ), + 200, {'Content-Type': 'application/x-javascript'} + ) + + def check_precondition(f): + """ + This function will behave as a decorator which will checks + database connection before running view, it will also attaches + manager,conn & template_path properties to self + """ + @wraps(f) + def wrap(*args, **kwargs): + # Here args[0] will hold self & kwargs will hold gid,sid,did + self = args[0] + self.manager = get_driver(PG_DEFAULT_DRIVER).connection_manager( + kwargs['sid'] + ) + self.conn = self.manager.connection(did=kwargs['did']) + # If DB not connected then return error to browser + if not self.conn.connected(): + return precondition_required( + gettext( + "Connection to the server has been lost!" + ) + ) + + ver = self.manager.version + server_type = self.manager.server_type + # we will set template path for sql scripts + if ver >= 90100: + self.template_path = 'collation/sql/9.1_plus' + return f(*args, **kwargs) + + return wrap + + + @check_precondition + def list(self, gid, sid, did, scid): + SQL = render_template("/".join([self.template_path, + 'properties.sql']), scid=scid) + status, res = self.conn.execute_dict(SQL) + + if not status: + return internal_server_error(errormsg=res) + return ajax_response( + response=res['rows'], + status=200 + ) + + @check_precondition + def nodes(self, gid, sid, did, scid): + res = [] + SQL = render_template("/".join([self.template_path, + 'properties.sql']), scid=scid) + status, rset = self.conn.execute_2darray(SQL) + if not status: + return internal_server_error(errormsg=rset) + + for row in rset['rows']: + res.append( + self.blueprint.generate_browser_node( + row['oid'], + scid, + row['name'], + icon="icon-collation" + )) + + return make_json_response( + data=res, + status=200 + ) + + @check_precondition + def properties(self, gid, sid, did, scid, coid): + try: + SQL = render_template("/".join([self.template_path, + 'properties.sql']), + scid=scid, coid=coid) + status, res = self.conn.execute_dict(SQL) + + if not status: + return internal_server_error(errormsg=res) + + return ajax_response( + response=res['rows'][0], + status=200 + ) + + except Exception as e: + return internal_server_error(errormsg=str(e)) + + @check_precondition + def getCollations(self, gid, sid, did, scid, coid=None): + res = [{ 'label': '', 'value': '' }] + try: + SQL = render_template("/".join([self.template_path, + 'get_collations.sql'])) + status, rset = self.conn.execute_2darray(SQL) + if not status: + return internal_server_error(errormsg=res) + + for row in rset['rows']: + res.append( + {'label': row['copy_collation'], + 'value': row['copy_collation']} + ) + return make_json_response( + data=res, + status=200 + ) + + except Exception as e: + return internal_server_error(errormsg=str(e)) + + + + @check_precondition + def create(self, gid, sid, did, scid): + """ + This function will creates new the collation object + """ + + data = request.form if request.form else json.loads(request.data.decode()) + required_args = [ + 'name', + 'schema' + ] + + for arg in required_args: + if arg not in data: + return make_json_response( + status=410, + success=0, + errormsg=gettext( + "Couldn't find the required parameter (%s)." % arg + ) + ) + + definition_args = [ + 'locale', + 'copy_collation', + 'lc_collate', + 'lc_type' + ] + + # Additional Server Side validation to check if definition is sent properly from client side + missing_definition_flag = False + + for arg in definition_args: + if arg == 'locale' and arg not in data: + if 'copy_collation' not in data and ( + 'lc_collate' not in data and 'lc_type' not in data + ): + missing_definition_flag = True + + if arg == 'copy_collation' and arg not in data: + if 'locale' not in data and ( + 'lc_collate' not in data and 'lc_type' not in data + ): + missing_definition_flag = True + + if (arg == 'lc_collate' or arg == 'lc_type') and arg not in data: + if 'copy_collation' not in data and 'locale' not in data: + missing_definition_flag = True + + if missing_definition_flag: + return make_json_response( + status=410, + success=0, + errormsg=gettext( + "Incomplete definition, Please provide Locale \ + OR Copy collation OR LC_TYPE/LC_COLLATE" + ) + ) + + try: + SQL = render_template("/".join([self.template_path, + 'create.sql']), + data=data, conn=self.conn) + status, res = self.conn.execute_scalar(SQL) + if not status: + return internal_server_error(errormsg=res) + + # We need oid to to add object in tree at browser + SQL = render_template("/".join([self.template_path, + 'get_oid.sql']), data=data) + status, coid = self.conn.execute_scalar(SQL) + if not status: + return internal_server_error(errormsg=coid) + + return jsonify( + node=self.blueprint.generate_browser_node( + coid, + scid, + data['name'], + icon="icon-collation" + ) + ) + except Exception as e: + return internal_server_error(errormsg=str(e)) + + @check_precondition + def delete(self, gid, sid, did, scid, coid): + """ + This function will drop the object + """ + # Below will decide if it's simple drop or drop with cascade call + if self.cmd == 'delete': + # This is a cascade operation + cascade = True + else: + cascade = False + + try: + SQL = render_template("/".join([self.template_path, + 'delete.sql']), + scid=scid, coid=coid) + status, name = self.conn.execute_scalar(SQL) + if not status: + return internal_server_error(errormsg=name) + + SQL = render_template("/".join([self.template_path, + 'delete.sql']), + name=name, cascade=cascade) + status, res = self.conn.execute_scalar(SQL) + if not status: + return internal_server_error(errormsg=res) + + return make_json_response( + success=1, + info=gettext("Collation dropped"), + data={ + 'id': coid, + 'scid': scid, + 'sid': sid, + 'gid': gid, + 'did': did + } + ) + + except Exception as e: + return internal_server_error(errormsg=str(e)) + + @check_precondition + def update(self, gid, sid, did, scid, coid): + """ + This function will update the object + """ + data = request.form if request.form else json.loads( + request.data.decode() + ) + SQL = self.getSQL(gid, sid, data, scid, coid) + try: + if SQL and SQL.strip('\n') and SQL.strip(' '): + status, res = self.conn.execute_scalar(SQL) + if not status: + return internal_server_error(errormsg=res) + + return make_json_response( + success=1, + info="Collation updated", + data={ + 'id': coid, + 'scid': scid, + 'sid': sid, + 'gid': gid, + 'did': did + } + ) + else: + return make_json_response( + success=1, + info="Nothing to update", + data={ + 'id': coid, + 'scid': scid, + 'sid': sid, + 'gid': gid, + 'did': did + } + ) + + except Exception as e: + return internal_server_error(errormsg=str(e)) + + @check_precondition + def msql(self, gid, sid, did, scid, coid=None): + """ + This function to return modified SQL + """ + data = dict() + for k, v in request.args.items(): + try: + data[k] = json.loads(v) + except ValueError: + data[k] = v + + try: + SQL = self.getSQL(gid, sid, data, scid, coid) + if SQL and SQL.strip('\n') and SQL.strip(' '): + return make_json_response( + data=SQL, + status=200 + ) + except Exception as e: + return internal_server_error(errormsg=str(e)) + + def getSQL(self, gid, sid, data, scid, coid=None): + """ + This function will genrate sql from model data + """ + if coid is not None: + SQL = render_template("/".join([self.template_path, + 'properties.sql']), + scid=scid, coid=coid) + status, res = self.conn.execute_dict(SQL) + if not status: + return internal_server_error(errormsg=res) + old_data = res['rows'][0] + SQL = render_template( + "/".join([self.template_path, 'update.sql']), + data=data, o_data=old_data, conn=self.conn + ) + else: + required_args = [ + 'name', + 'schema' + ] + + for arg in required_args: + if arg not in data: + return make_json_response( + status=200, + data="-- missing definition" + ) + + SQL = render_template("/".join([self.template_path, + 'create.sql']), + data=data, conn=self.conn) + return SQL + + @check_precondition + def sql(self, gid, sid, did, scid, coid): + """ + This function will genrate sql for sql panel + """ + SQL = render_template("/".join([self.template_path, + 'properties.sql']), + scid=scid, coid=coid) + status, res = self.conn.execute_dict(SQL) + if not status: + return internal_server_error(errormsg=res) + + data = res['rows'][0] + + SQL = render_template("/".join([self.template_path, + 'create.sql']), + data=data, conn=self.conn) + + sql_header = """ +-- Collation: {0}; + +-- DROP COLLATION {0}; + +""".format(data['name']) + + SQL = sql_header + SQL + + return ajax_response(response=SQL) + +CollationView.register_node_view(blueprint) diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/static/img/coll-collation.png b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/static/img/coll-collation.png new file mode 100644 index 0000000000000000000000000000000000000000..fa46a49b36bd910f1aab83a0d82576f5e1fb74c5 GIT binary patch literal 178 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`oCO|{#S9GG!XV7ZFl&wkP%y>Q z#WBR<^xjE$lBKJZ&qE)`;EOW5#Oc%8;RXl53*~!-2V< zH~d^R_2AruX-C=}CjGnPrgEEQ;e5Nv4expPX-b^5WV(FH{>PFFJ3p3QzQizT8&}^; Z#<$nB^!IGkwF275;OXk;vd$@?2>?$7Ktuol literal 0 HcmV?d00001 diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/static/img/collation.png b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/static/img/collation.png new file mode 100644 index 0000000000000000000000000000000000000000..0bc8ff7d260f82c275ba5df3252d23b441714413 GIT binary patch literal 233 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61SBU+%rFB|jKx9jP7LeL$-D$|I14-?iy0WW zg+Z8+Vb&Z8pdfpRr>`sfZ5B>`Y1Vg3uj>JYBuiW)N}Tg^b5rw57@Uhz6H8K46v{J8 zG8EiBeFMT9`NV;W!aQ9ZLp07O|M~ylo>{Y@v(e>%QT@M~OC|;e1{JY;xgK_W{{m$0 z(a}7(v}*P?vy*;{_Oi8Aetz~>UFyti^ZqXhu6$xm3y&CRICmD_+f%tDb3tVmE5nZC WPAwi!3pN04VDNPHb6Mw<&;$TuGEA%h literal 0 HcmV?d00001 diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/js/collation.js b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/js/collation.js new file mode 100644 index 0000000..58ce8d6 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/js/collation.js @@ -0,0 +1,247 @@ +define( + ['jquery', 'underscore', 'underscore.string', 'pgadmin', 'pgadmin.browser', 'alertify', 'pgadmin.browser.collection'], +function($, _, S, pgAdmin, pgBrowser, alertify) { + + if (!pgBrowser.Nodes['coll-collation']) { + var databases = pgAdmin.Browser.Nodes['coll-collation'] = + pgAdmin.Browser.Collection.extend({ + node: 'collation', + label: '{{ _('Collations') }}', + type: 'coll-collation', + columns: ['name', 'oid', 'description'] + }); + }; + + if (!pgBrowser.Nodes['collation']) { + pgAdmin.Browser.Nodes['collation'] = pgBrowser.Node.extend({ + type: 'collation', + label: '{{ _('Collation') }}', + collection_type: 'coll-collation', + hasSQL: true, + parent_type: ['schema', 'catalog'], + Init: function() { + /* Avoid mulitple registration of menus */ + if (this.initialized) + return; + + this.initialized = true; + + pgBrowser.add_menus([{ + name: 'create_collation_on_coll', node: 'coll-collation', module: this, + applies: ['object', 'context'], callback: 'show_obj_properties', + category: 'create', priority: 4, label: '{{ _('Collation...') }}', + icon: 'wcTabIcon icon-collation', data: {action: 'create', check: true}, + enable: 'canCreate' + },{ + name: 'create_collation', node: 'collation', module: this, + applies: ['object', 'context'], callback: 'show_obj_properties', + category: 'create', priority: 4, label: '{{ _('Collation...') }}', + icon: 'wcTabIcon icon-collation', data: {action: 'create', check: true}, + enable: 'canCreate' + },{ + name: 'create_collation', node: 'schema', module: this, + applies: ['object', 'context'], callback: 'show_obj_properties', + category: 'create', priority: 4, label: '{{ _('Collation...') }}', + icon: 'wcTabIcon icon-collation', data: {action: 'create', check: false}, + enable: 'canCreate' + } + ]); + + }, + canDrop: pgBrowser.Nodes['schema'].canChildDrop, + canDropCascade: pgBrowser.Nodes['schema'].canChildDrop, + model: pgAdmin.Browser.Node.Model.extend({ + defaults: { + name: undefined, + oid: undefined, + owner: undefined, + lc_type: undefined, + lc_collate: undefined, + description: undefined, + slony: undefined, + }, + schema: [{ + id: 'name', label: '{{ _('Name') }}', cell: 'string', + type: 'text', mode: ['properties', 'create', 'edit'], + disabled: 'inSchema' + },{ + id: 'oid', label:'{{ _('Oid') }}', cell: 'string', + type: 'text' , mode: ['properties'] + },{ + id: 'owner', label:'{{ _('Owner') }}', cell: 'string', + type: 'text', mode: ['properties', 'create', 'edit'], + disabled: 'inSchema', control: 'node-list-by-name', node: 'role' + },{ + id: 'schema', label:'{{ _('Schema') }}', cell: 'string', + control: 'node-list-by-name', + type: 'text', mode: ['create', 'edit'], node: 'schema', + disabled: 'inSchema', filter: function(d) { + // If schema name start with pg_* then we need to exclude them + if(d && d.label.match(/^pg_/)) + { + return false; + } + return true; + } + },{ + id: 'locale', label:'{{ _('Locale') }}', cell: 'string', + type: 'text', mode: ['create', 'edit'], group: 'Definition', + disabled: 'inSchemaWithModelCheck', + deps: ['lc_collate', 'lc_type', 'copy_collation'] + },{ + id: 'lc_collate', label:'{{ _('LC_COLLATE') }}', cell: 'string', + type: 'text', mode: ['properties', 'create', 'edit'], group: 'Definition', + deps: ['locale', 'copy_collation'], disabled: 'inSchemaWithModelCheck' + },{ + id: 'lc_type', label:'{{ _('LC_TYPE') }}', cell: 'string', + type: 'text', mode: ['properties', 'create', 'edit'], group: 'Definition', + disabled: 'inSchemaWithModelCheck', + deps: ['locale', 'copy_collation'] + },{ + id: 'copy_collation', label:'{{ _('Copy collation') }}', cell: 'string', + control: 'node-ajax-options', + type: 'text', mode: ['create', 'edit'], group: 'Definition', + url: 'get_collations', disabled: 'inSchemaWithModelCheck', + deps: ['locale', 'lc_collate', 'lc_type'] + },{ + id: 'description', label:'{{ _('Comment') }}', cell: 'string', + type: 'multiline', mode: ['properties', 'create', 'edit'], + disabled: 'inSchema' + } + ], + validate: function() { + var err = {}, + msg = undefined, + changedAttrs = this.changed, + locale_flag = false, + lc_type_flag = false, + lc_coll_flag = false, + copy_coll_flag = false, + msg = undefined, + data = this.toJSON(); + + + if (_.has(changedAttrs,data.name) && _.isUndefined(data.name) + || String(data.name).replace(/^\s+|\s+$/g, '') == '') { + msg = '{{ _('Name can not be empty!') }}'; + err['name'] = msg; + } + if (_.has(changedAttrs,data.schema) && _.isUndefined(data.schema) + || String(data.schema).replace(/^\s+|\s+$/g, '') == '') { + msg = '{{ _('Schema can not be empty!') }}'; + err['schema'] = msg; + } + if (_.has(changedAttrs,data.locale) && _.isUndefined(data.locale) + || String(data.locale).replace(/^\s+|\s+$/g, '') == '') { + locale_flag = true; + } + if (_.has(changedAttrs,data.lc_collate) && _.isUndefined(data.lc_collate) + || String(data.lc_collate).replace(/^\s+|\s+$/g, '') == '') { + lc_coll_flag = true; + } + if (_.has(changedAttrs,data.lc_type) && _.isUndefined(data.lc_type) + || String(data.lc_type).replace(/^\s+|\s+$/g, '') == '') { + lc_type_flag = true; + } + if (_.has(changedAttrs,data.copy_collation) && _.isUndefined(data.copy_collation) + || String(data.copy_collation).replace(/^\s+|\s+$/g, '') == '') { + copy_coll_flag = true; + } + if (locale_flag && (lc_coll_flag || lc_coll_flag) && copy_coll_flag) { + msg = '{{ _('Incomplete definition, Please provide Locale OR Copy collation OR LC_TYPE/LC_COLLATE!') }}'; + err['locale'] = msg + } + if (_.size(err)) { + this.trigger('on-status',{msg:msg,type:"type"}); + return msg; + } + this.trigger('on-status-clear'); + return null; + }, + // We will disable everything if we are under catalog node + inSchema: function() { + if(this.node_info && 'catalog' in this.node_info) + { + return true; + } + return false; + }, + // We will check if we are under schema node & in 'create' mode + inSchemaWithModelCheck: function(m) { + if(this.node_info && 'schema' in this.node_info) + { + // Enable copy_collation only if locale & lc_* is not provided + if (m.isNew() && this.name == "copy_collation") + { + if(m.get('locale')) + return true; + if(m.get('lc_collate') || m.get('lc_type')) + return true + return false; + } + + // Enable lc_* only if copy_collation & locale is not provided + if (m.isNew() && (this.name == 'lc_collate' || this.name == 'lc_type')) + { + if(m.get('locale')) + return true; + if(m.get('copy_collation')) + return true + return false; + } + + // Enable localy only if lc_* & copy_collation is not provided + if (m.isNew() && this.name == 'locale') + { + if(m.get('lc_collate') || m.get('lc_type')) + return true; + if(m.get('copy_collation')) + return true + return false; + } + + // We will disbale control if it's in 'edit' mode + if (m.isNew()) { + return false; + } else { + return true; + } + + } + return true; + } + }), + canCreate: function(itemData, item, data) { + //If check is false then , we will allow create menu + if (data && data.check == false) + return true; + + var t = pgBrowser.tree, i = item, d = itemData; + // To iterate over tree to check parent node + while (i) { + // If it is schema then allow user to create collation + if (_.indexOf(['schema'], d._type) > -1) + return true; + + if ('coll-collation' == d._type) { + //Check if we are not child of catalog + prev_i = t.hasParent(i) ? t.parent(i) : null; + prev_d = prev_i ? t.itemData(prev_i) : null; + if( prev_d._type == 'catalog') { + return false; + } else { + return true; + } + } + i = t.hasParent(i) ? t.parent(i) : null; + d = i ? t.itemData(i) : null; + } + // by default we do not want to allow create menu + return true; + } + }); + + } + + return pgBrowser.Nodes['collation']; +}); diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/backend_support.sql b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/backend_support.sql new file mode 100644 index 0000000..f9b9564 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/backend_support.sql @@ -0,0 +1,18 @@ +SELECT + CASE WHEN nsp.nspname IN ('sys', 'dbo', 'information_schema') THEN true ELSE false END AS dbSupport +FROM pg_namespace nsp +WHERE nsp.oid={{scid}}::int +AND ( + (nspname = 'pg_catalog' AND EXISTS + (SELECT 1 FROM pg_class WHERE relname = 'pg_class' AND relnamespace = nsp.oid LIMIT 1)) + OR (nspname = 'pgagent' AND EXISTS + (SELECT 1 FROM pg_class WHERE relname = 'pga_job' AND relnamespace = nsp.oid LIMIT 1)) + OR (nspname = 'information_schema' AND EXISTS + (SELECT 1 FROM pg_class WHERE relname = 'tables' AND relnamespace = nsp.oid LIMIT 1)) + OR (nspname LIKE '_%' AND EXISTS + (SELECT 1 FROM pg_proc WHERE proname='slonyversion' AND pronamespace = nsp.oid LIMIT 1)) +) +AND + nspname NOT LIKE E'pg\\temp\\%' +AND + nspname NOT LIKE E'pg\\toast_temp\\%' \ No newline at end of file diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/create.sql b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/create.sql new file mode 100644 index 0000000..4954b38 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/create.sql @@ -0,0 +1,25 @@ +{% if data %} +CREATE COLLATION {{ conn|qtIdent(data.schema, data.name) }} +{# if user has provided lc_collate & lc_type #} +{% if data.lc_collate and data.lc_type %} + (LC_COLLATE = {{ data.lc_collate|qtLiteral }}, LC_CTYPE = {{ data.lc_type|qtLiteral }}); +{% endif %} +{# if user has provided locale only #} +{% if data.locale %} + (LOCALE = {{ data.locale|qtLiteral }}); +{% endif %} +{# if user has choosed to copy from existing collation #} +{% if data.copy_collation %} + FROM {{ data.copy_collation }}; +{% endif %} + +{% if data.owner %} +ALTER COLLATION {{ conn|qtIdent(data.schema, data.name) }} + OWNER TO {{ conn|qtIdent(data.owner) }}; +{% endif %} + +{% if data.description %} +COMMENT ON COLLATION {{ conn|qtIdent(data.schema, data.name) }} + IS {{ data.description|qtLiteral }}; +{% endif %} +{% endif %} \ No newline at end of file diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/delete.sql b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/delete.sql new file mode 100644 index 0000000..a90db72 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/delete.sql @@ -0,0 +1,10 @@ +{% if scid and coid %} +SELECT concat(quote_ident(nspname), '.', quote_ident(collname)) AS name +FROM pg_collation c, pg_namespace n +WHERE c.collnamespace = n.oid AND + n.oid = {{ scid }}::oid AND + c.oid = {{ coid }}::oid; +{% endif %} +{% if name %} +DROP COLLATION {{ name }}{% if cascade%} CASCADE{% endif %}; +{% endif %} \ No newline at end of file diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/get_collations.sql b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/get_collations.sql new file mode 100644 index 0000000..03510da --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/get_collations.sql @@ -0,0 +1,7 @@ +SELECT --nspname, collname, + CASE WHEN length(nspname) > 0 AND length(collname) > 0 THEN + concat(quote_ident(nspname), '.', quote_ident(collname)) + ELSE '' END AS copy_collation +FROM pg_collation c, pg_namespace n +WHERE c.collnamespace=n.oid +ORDER BY nspname, collname; \ No newline at end of file diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/get_oid.sql b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/get_oid.sql new file mode 100644 index 0000000..feaa8ee --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/get_oid.sql @@ -0,0 +1,8 @@ +{# Below will provide oid for newly created collation #} +{% if data %} +SELECT c.oid +FROM pg_collation c, pg_namespace n +WHERE c.collnamespace=n.oid AND + n.nspname = {{ data.schema|qtLiteral }} AND + c.collname = {{ data.name|qtLiteral }} +{% endif %} \ No newline at end of file diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/properties.sql b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/properties.sql new file mode 100644 index 0000000..0563a12 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/properties.sql @@ -0,0 +1,8 @@ +SELECT c.oid, c.collname AS name, c.collcollate AS lc_collate, c.collctype AS lc_type, + pg_get_userbyid(c.collowner) AS owner, description, n.nspname AS schema +FROM pg_collation c + JOIN pg_namespace n ON n.oid=c.collnamespace + LEFT OUTER JOIN pg_description des ON (des.objoid=c.oid AND des.classoid='pg_collation'::regclass) +WHERE c.collnamespace = {{scid}}::oid + {% if coid %}AND c.oid = {{coid}}::oid {% endif %} + ORDER BY c.collname; diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/update.sql b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/update.sql new file mode 100644 index 0000000..d4cb719 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collation/sql/9.1_plus/update.sql @@ -0,0 +1,28 @@ +{% if data %} +{# Below will change object's owner #} +{% if data.owner and data.owner != o_data.owner %} +ALTER COLLATION {{ conn|qtIdent(o_data.schema, o_data.name) }} + OWNER TO {{ conn|qtIdent(data.owner) }}; + +{% endif %} +{# Below will change object's comment #} +{% if data.description and data.description != o_data.description %} +COMMENT ON COLLATION {{ conn|qtIdent(o_data.schema, o_data.name) }} + IS {{ data.description|qtLiteral }}; + +{% endif %} +{# Below will change object name #} +{% if data.name and data.name != o_data.name %} +ALTER COLLATION {{ conn|qtIdent(o_data.schema, o_data.name) }} + RENAME TO {{ conn|qtIdent(data.name) }}; + +{% endif %} +{### +Below will change the schema for object, +with extra if condition we will also make sure that object has correct name +###} +{% if data.schema and data.schema != o_data.schema %} +ALTER COLLATION {% if data.name and data.name != o_data.name %}{{ conn|qtIdent(o_data.schema, data.name) }}{% else %}{{ conn|qtIdent(o_data.schema, o_data.name) }}{% endif %} + SET SCHEMA {{ conn|qtIdent(data.schema) }}; +{% endif %} +{% endif %}