def dependencies(self, gid, sid, did, scid, coid, clid):
"""
This function get the dependencies and return ajax response
for the column node.
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
scid: Schema ID
coid: Catalog objects ID
clid: Column ID
"""
# Specific condition for column which we need to append
where = "WHERE dep.objid={0}::OID AND dep.objsubid={1}".format(
coid, clid
)
dependencies_result = self.get_dependencies(
self.conn, clid, where=where
)
return ajax_response(
response=dependencies_result,
status=200
)
def sql(self, gid, sid, did, eid):
"""
This function will generate sql for the sql panel
"""
SQL = render_template("/".join(
[self.template_path, 'properties.sql']
), eid=eid)
status, res = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=res)
if len(res['rows']) == 0:
return gone(
_("Could not find the extension on the server.")
)
result = res['rows'][0]
SQL = render_template("/".join(
[self.template_path, 'create.sql']
),
data=result,
conn=self.conn,
display_comments=True
)
return ajax_response(response=SQL)
def properties(self, gid, sid, did, scid, coid):
"""
This function will show the properties of the selected collation node.
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
scid: Schema ID
scid: Schema ID
coid: Collation ID
Returns:
JSON of selected collation node
"""
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))
def properties(self, gid, sid, did, etid):
"""
This function is used to list all the event trigger
nodes within that collection.
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
etid: Event trigger ID
Returns:
"""
sql = render_template(
"/".join([self.template_path, 'properties.sql']),
etid=etid, conn=self.conn
)
status, res = self.conn.execute_dict(sql)
if not status:
return internal_server_error(errormsg=res)
if len(res['rows']) == 0:
return gone(
gettext("Could not find the event trigger information.")
)
result = res['rows'][0]
result = self._formatter(result)
return ajax_response(
response=result,
status=200
)
def sql(self, gid, sid, did, scid, coid):
"""
This function will generates reverse engineered sql for collation object
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
scid: Schema ID
coid: Collation ID
"""
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};\n\n-- ".format(data['name'])
sql_header += render_template("/".join([self.template_path,
'delete.sql']),
name=data['name'])
SQL = sql_header + '\n\n' + SQL.strip('\n')
return ajax_response(response=SQL)
def properties(self, gid, sid, did, scid, pkgid, edbfnid=None):
"""
Returns the Function properties.
Args:
gid: Server Group Id
sid: Server Id
did: Database Id
scid: Schema Id
pkgid: Package Id
edbfnid: Function Id
"""
SQL = render_template("/".join([self.sql_template_path,
'properties.sql']),
pkgid=pkgid, edbfnid=edbfnid)
status, res = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=res)
if len(res['rows']) == 0:
return gone(
gettext("Could not find the function in the database.")
)
resp_data = res['rows'][0]
# Get formatted Arguments
frmtd_params, frmtd_proargs = self._format_arguments_from_db(resp_data)
resp_data.update(frmtd_params)
resp_data.update(frmtd_proargs)
return ajax_response(
response=resp_data,
status=200
)
def list(self, gid, sid):
last_system_oid = self.retrieve_last_system_oid()
db_disp_res = None
params = None
if self.manager and self.manager.db_res:
db_disp_res = ", ".join(
['%s'] * len(self.manager.db_res.split(','))
)
params = tuple(self.manager.db_res.split(','))
SQL = render_template(
"/".join([self.template_path, 'properties.sql']),
conn=self.conn,
last_system_oid=last_system_oid,
db_restrictions=db_disp_res
)
status, res = self.conn.execute_dict(SQL, params)
if not status:
return internal_server_error(errormsg=res)
return ajax_response(
response=res['rows'],
status=200
)
def list(self, gid, sid, did, scid):
"""
This function is used to list all the catalog objects
nodes within that collection.
Args:
gid: Server group ID
sid: Server ID
did: Database ID
scid: Schema ID
Returns:
JSON of available catalog objects nodes
"""
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
)
def role(rid):
"""
Args:
rid: Role id
Returns: List of pgAdmin4 users roles or single role if rid is provided.
"""
if rid:
r = Role.query.get(rid)
res = {'id': r.id, 'name': r.name}
else:
roles = Role.query.all()
roles_data = []
for r in roles:
roles_data.append({'id': r.id,
'name': r.name})
res = roles_data
return ajax_response(
response=res,
status=200
)
def properties(self, gid, sid, did, scid, coid):
"""
This function will show the properties of the selected
catalog objects node.
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
scid: Schema ID
scid: Schema ID
coid: Catalog object ID
Returns:
JSON of selected catalog objects node
"""
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)
if len(res['rows']) == 0:
return gone(
gettext("""Could not find the specified catalog object."""))
return ajax_response(
response=res['rows'][0],
status=200
)
def sql(self, gid, sid, did, scid, seid):
"""
This function will generate sql for sql panel
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
scid: Schema ID
seid: Sequence ID
"""
SQL = render_template("/".join([self.template_path, 'properties.sql']), scid=scid, seid=seid)
status, res = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=res)
for row in res['rows']:
SQL = render_template("/".join([self.template_path, 'get_def.sql']), data=row)
status, rset1 = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=rset1)
row['current_value'] = rset1['rows'][0]['last_value']
row['minimum'] = rset1['rows'][0]['min_value']
row['maximum'] = rset1['rows'][0]['max_value']
row['increment'] = rset1['rows'][0]['increment_by']
row['cache'] = rset1['rows'][0]['cache_value']
row['cycled'] = rset1['rows'][0]['is_cycled']
result = res['rows'][0]
result = self._formatter(result, scid, seid)
SQL = self.getSQL(gid, sid, did, result, scid)
SQL = SQL.strip('\n').strip(' ')
return ajax_response(response=SQL)
def properties(self, gid, sid):
"""Return list of attributes of a server"""
server = Server.query.filter_by(
user_id=current_user.id,
id=sid).first()
if server is None:
return make_json_response(
success=0,
errormsg=gettext("Couldn't find the given server")
)
sg = ServerGroup.query.filter_by(
user_id=current_user.id,
id=server.servergroup_id
).first()
return ajax_response(
response={
'id': server.id,
'name': server.name,
'host': server.host,
'port': server.port,
'db': server.maintenance_db,
'username': server.username,
'gid': server.servergroup_id,
'group-name': sg.name,
'comment': server.comment,
# TODO:: Make sure - we do have correct values here
'connected': True,
'version': 'PostgreSQL 9.3 (linux-x64)'
}
)
def list(self, gid, sid, did):
"""
This function is used to list all the foreign data wrapper
nodes within that collection.
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
"""
sql = render_template("/".join([self.template_path, 'properties.sql']),
conn=self.conn)
status, res = self.conn.execute_dict(sql)
if not status:
return internal_server_error(errormsg=res)
for row in res['rows']:
if row['fdwoptions'] is not None:
row['fdwoptions'] = tokenize_options(
row['fdwoptions'], 'fdwoption', 'fdwvalue'
)
return ajax_response(
response=res['rows'],
status=200
)
def user(uid):
"""
Args:
uid: User id
Returns: List of pgAdmin4 users or single user if uid is provided.
"""
if uid:
u = User.query.get(uid)
res = {'id': u.id,
'email': u.email,
'active': u.active,
'role': u.roles[0].id
}
else:
users = User.query.all()
users_data = []
for u in users:
users_data.append({'id': u.id,
'email': u.email,
'active': u.active,
'role': u.roles[0].id
})
res = users_data
return ajax_response(
response=res,
status=200
)
def sql(self, gid, sid, did, scid, syid):
"""
This function will generates reverse engineered sql for synonym object
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
scid: Schema ID
syid: Synonym ID
"""
SQL = render_template("/".join([self.template_path,
'properties.sql']),
scid=scid, syid=syid)
status, res = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=res)
if len(res['rows']) > 0:
data = res['rows'][0]
else:
return gone(
gettext('The specified synonym could not be found.')
)
SQL = render_template("/".join([self.template_path,
'create.sql']),
data=data, conn=self.conn, comment=True)
return ajax_response(response=SQL)
def properties(self, gid, sid, did, fid, fsid, umid):
"""
This function will show the properties of the selected user mapping node.
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
fid: Foreign data wrapper ID
fsid: Foreign server ID
umid: User mapping ID
"""
sql = render_template("/".join([self.template_path, 'properties.sql']), umid=umid, conn=self.conn)
status, res = self.conn.execute_dict(sql)
if not status:
return internal_server_error(errormsg=res)
if res['rows'][0]['umoptions'] is not None:
res['rows'][0]['umoptions'] = self.tokenizeOptions(res['rows'][0]['umoptions'])
return ajax_response(
response=res['rows'][0],
status=200
)
def select_sql(self, gid, sid, did, scid, foid):
"""
SELECT script sql for the object
Args:
gid: Server Group Id
sid: Server Id
did: Database Id
scid: Schema Id
foid: Foreign Table Id
Returns:
SELECT Script sql for the object
"""
data = self._fetch_properties(gid, sid, did, scid, foid)
if data is False:
return gone(
gettext("Could not find the foreign table on the server.")
)
columns = []
for c in data['columns']:
columns.append(self.qtIdent(self.conn, c['attname']))
if len(columns) > 0:
columns = ", ".join(columns)
else:
columns = '*'
sql = u"SELECT {0}\n\tFROM {1};".format(
columns,
self.qtIdent(self.conn, data['basensp'], data['name'])
)
return ajax_response(response=sql)
def get_data(sid, did, template):
"""
Generic function to get server stats based on an SQL template
Args:
sid: The server ID
did: The database ID
template: The SQL template name
Returns:
"""
# Allow no server ID to be specified (so we can generate a route in JS)
# but throw an error if it's actually called.
if not sid:
return internal_server_error(errormsg='Server ID not specified.')
sql = render_template(
"/".join([g.template_path, template]), did=did
)
status, res = g.conn.execute_dict(sql)
if not status:
return internal_server_error(errormsg=res)
return ajax_response(
response=res['rows'],
status=200
)
def delete_sql(self, gid, sid, did, scid, foid):
"""
DELETE script sql for the object
Args:
gid: Server Group Id
sid: Server Id
did: Database Id
scid: Schema Id
foid: Foreign Table Id
Returns:
DELETE Script sql for the object
"""
data = self._fetch_properties(gid, sid, did, scid, foid)
if data is False:
return gone(
gettext("Could not find the foreign table on the server.")
)
sql = u"DELETE FROM {0}\n\tWHERE <condition>;".format(
self.qtIdent(self.conn, data['basensp'], data['name'])
)
return ajax_response(response=sql)
def properties(self, gid, sid, jid, jscid):
"""
This function will show the properties of the selected language node.
Args:
gid: Server Group ID
sid: Server ID
jid: Job ID
jscid: JobSchedule ID
"""
sql = render_template(
"/".join([self.template_path, 'properties.sql']),
jscid=jscid, jid=jid
)
status, res = self.conn.execute_dict(sql)
if not status:
return internal_server_error(errormsg=res)
if len(res['rows']) == 0:
return gone(
errormsg=gettext("Could not find the specified job step.")
)
return ajax_response(
response=res['rows'][0],
status=200
)
def properties(self, gid, sid, did, fid):
"""
This function will show the properties of the selected foreign data wrapper node.
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
fid: foreign data wrapper ID
"""
sql = render_template("/".join([self.template_path, 'properties.sql']), fid=fid, conn=self.conn)
status, res = self.conn.execute_dict(sql)
if not status:
return internal_server_error(errormsg=res)
if res['rows'][0]['fdwoptions'] is not None:
res['rows'][0]['fdwoptions'] = self.tokenize_options(res['rows'][0]['fdwoptions'])
sql = render_template("/".join([self.template_path, 'acl.sql']), fid=fid)
status, fdw_acl_res = self.conn.execute_dict(sql)
if not status:
return internal_server_error(errormsg=fdw_acl_res)
for row in fdw_acl_res['rows']:
privilege = parse_priv_from_db(row)
if row['deftype'] in res['rows'][0]:
res['rows'][0][row['deftype']].append(privilege)
else:
res['rows'][0][row['deftype']] = [privilege]
return ajax_response(
response=res['rows'][0],
status=200
)
def sql(self, gid, sid, did, cid):
"""
This function will generate sql for sql panel
:param gid: group id
:param sid: server id
:param did: database id
:param cid: cast id
:return:
"""
try:
sql = render_template(
"/".join([self.template_path, 'sql.sql']),
cid=cid,
conn=self.conn
)
status, res = self.conn.execute_scalar(sql)
if not status:
return internal_server_error(
_("Could not generate reversed engineered SQL for the cast.\n\n{0}").format(
res
)
)
if res is None:
return gone(
_("Could not generate reversed engineered SQL for the cast node.\n")
)
return ajax_response(response=res)
except Exception as e:
return internal_server_error(errormsg=str(e))
def properties(self, gid, sid, did, cid):
"""
This function will show the properties of the selected cast node
:param gid: group id
:param sid: server id
:param did: database id
:param cid: cast id
:return:
"""
sql = render_template(
"/".join([self.template_path, 'properties.sql']),
cid=cid,
datlastsysoid=self.manager.db_info[did]['datlastsysoid'],
showsysobj=self.blueprint.show_system_objects
)
status, res = self.conn.execute_dict(sql)
if not status:
return internal_server_error(errormsg=res)
result = res['rows'][0]
return ajax_response(
response=res['rows'][0],
status=200
)
def list(self, gid, sid, did):
"""
This function is used to list all the schema nodes within the collection.
Args:
gid: Server group ID
sid: Server ID
did: Database ID
Returns:
JSON of available schema nodes
"""
SQL = render_template(
"/".join([self.template_path, 'sql/properties.sql']),
_=gettext,
show_sysobj=self.blueprint.show_system_objects
)
status, res = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=res)
return ajax_response(
response=res['rows'],
status=200
)
def dependents(self, gid, sid, did, fid, fsid):
"""
This function get the dependents and return ajax response
for the foreign server node.
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
fid: foreign data wrapper ID
fsid: Foreign server ID
"""
dependents_result = self.get_dependents(self.conn, fsid)
# Fetching dependents of foreign servers
query = render_template("/".join([self.template_path, 'dependents.sql']), fsid=fsid)
status, result = self.conn.execute_dict(query)
if not status:
internal_server_error(errormsg=result)
for row in result['rows']:
dependents_result.append(
{'type': 'user_mapping', 'name': row['name'], 'field': 'normal' if (row['deptype'] == 'n') else ''})
return ajax_response(
response=dependents_result,
status=200
)
def list(self, gid, sid, did):
"""
This function is used to list all the cast nodes within the collection.
:param gid: group id
:param sid: server id
:param did: database id
:return:
"""
sql = render_template(
"/".join([self.template_path, 'properties.sql']),
datlastsysoid=self.manager.db_info[did]['datlastsysoid'],
showsysobj=self.blueprint.show_system_objects
)
status, res = self.conn.execute_dict(sql)
if not status:
return internal_server_error(errormsg=res)
for row in res['rows']:
row['castcontext'] = True if row['castcontext'] == 'IMPLICIT' else False
return ajax_response(
response=res['rows'],
status=200
)
def exec_sql(self, gid, sid, did, scid, fnid):
"""
This function returns sql for exec script call.
Args:
gid: Server Group Id
sid: Server Id
did: Database Id
scid: Schema Id
doid: Function Id
"""
resp_data = self._fetch_properties(gid, sid, did, scid, fnid)
# Fetch the schema name from OID
if 'pronamespace' in resp_data:
resp_data['pronamespace'] = self._get_schema(
resp_data['pronamespace']
)
name = resp_data['pronamespace'] + "." + resp_data['name_with_args']
# Fetch only arguments
args = name[name.rfind('('):].strip('(').strip(')').split(',')
# Remove unwanted spaces from arguments
args = [arg.strip(' ') for arg in args]
# Remove duplicate and then format arguments
for arg in list(set(args)):
formatted_arg = '\n\t<' + arg + '>'
name = name.replace(arg, formatted_arg)
name = name.replace(')', '\n)')
sql = "EXEC {0}".format(name)
return ajax_response(response=sql)
def properties(self, gid, sid, did, scid, doid, coid):
"""
Returns the Domain Constraints property.
Args:
gid: Server Group Id
sid: Server Id
did: Database Id
scid: Schema Id
doid: Domain Id
coid: Domain Constraint Id
"""
SQL = render_template("/".join([self.template_path,
'properties.sql']),
doid=doid, coid=coid)
status, res = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=res)
data = res['rows'][0]
return ajax_response(
response=data,
status=200
)
def sql(self, gid, sid, did, scid, tid):
"""
This function will reverse generate sql for sql panel
:param gid: group id
:param sid: server id
:param did: database id
:param scid: schema id
:param tid: fts tempate id
"""
sql = render_template(
"/".join([self.template_path, 'sql.sql']),
tid=tid,
scid=scid,
conn=self.conn
)
status, res = self.conn.execute_scalar(sql)
if not status:
return internal_server_error(
gettext(
"Could not generate reversed engineered query for the "
"FTS Template.\n{0}").format(res)
)
if res is None:
return gone(
gettext(
"Could not generate reversed engineered query for "
"FTS Template node.")
)
return ajax_response(response=res)
def delete_sql(self, gid, sid, did, scid, tid):
"""
DELETE script sql for the object
Args:
gid: Server Group Id
sid: Server Id
did: Database Id
scid: Schema Id
tid: Table Id
Returns:
DELETE Script sql for the object
"""
SQL = render_template(
"/".join([self.table_template_path, 'properties.sql']),
did=did, scid=scid, tid=tid,
datlastsysoid=self.datlastsysoid
)
status, res = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=res)
data = res['rows'][0]
sql = u"DELETE FROM {0}\n\tWHERE <condition>;".format(
self.qtIdent(self.conn, data['schema'], data['name'])
)
return ajax_response(response=sql)
def properties(self, gid, sid, jid, jstid):
"""
This function will show the properties of the selected job step node.
Args:
gid: Server Group ID
sid: Server ID
jid: Job ID
jstid: JobStep ID
"""
sql = render_template(
"/".join([self.template_path, 'properties.sql']),
jstid=jstid,
jid=jid,
has_connstr=self.manager.db_info['pgAgent']['has_connstr'])
status, res = self.conn.execute_dict(sql)
if not status:
return internal_server_error(errormsg=res)
if len(res['rows']) == 0:
return gone(errormsg="Could not find the specified job step.")
return ajax_response(response=res['rows'][0], status=200)
def list(self, gid, sid, did, scid, tid):
"""
This function is used to list all the trigger nodes within that
collection.
Args:
gid: Server group ID
sid: Server ID
did: Database ID
scid: Schema ID
tid: Table ID
Returns:
JSON of available trigger nodes
"""
SQL = render_template("/".join(
[self.template_path, self._PROPERTIES_SQL]),
tid=tid)
status, res = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=res)
return ajax_response(response=res['rows'], status=200)
def sql(self, gid, sid, did, scid, pid):
"""
This function will reverse generate sql for sql panel
:param gid: group id
:param sid: server id
:param did: database id
:param scid: schema id
:param pid: fts tempate id
"""
try:
sql = render_template(
"/".join([self.template_path, 'sql.sql']),
pid=pid,
scid=scid,
conn=self.conn
)
status, res = self.conn.execute_scalar(sql)
if not status:
return internal_server_error(
_(
"Could not generate reversed engineered query for the FTS Parser.\n{0}"
).format(res)
)
if res is None:
return gone(
_(
"Could not generate reversed engineered query for FTS Parser node"
)
)
return ajax_response(response=res)
except Exception as e:
current_app.logger.exception(e)
return internal_server_error(errormsg=str(e))
def properties(self, gid, sid, did, scid):
"""
This function will show the properties of the selected schema node.
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
scid: Schema ID
Returns:
JSON of selected schema node
"""
SQL = render_template("/".join(
[self.template_path, self._SQL_PREFIX + self._PROPERTIES_SQL]),
scid=scid,
_=gettext,
show_sysobj=self.blueprint.show_system_objects)
status, res = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=res)
if len(res['rows']) == 0:
return gone(
gettext("Could not find the schema in the database. "
"It may have been removed by another user."))
# Making copy of output for future use
copy_data = dict(res['rows'][0])
copy_data['is_sys_obj'] = (copy_data['oid'] <= self.datlastsysoid
or self.datistemplate)
copy_data = self._formatter(copy_data, scid)
return ajax_response(response=copy_data, status=200)
def properties(self, gid, sid, jid, jscid):
"""
This function will show the properties of the selected language node.
Args:
gid: Server Group ID
sid: Server ID
jid: Job ID
jscid: JobSchedule ID
"""
sql = render_template("/".join(
[self.template_path, self._PROPERTIES_SQL]),
jscid=jscid,
jid=jid)
status, res = self.conn.execute_dict(sql)
if not status:
return internal_server_error(errormsg=res)
if len(res['rows']) == 0:
return gone(
errormsg=gettext("Could not find the specified job step."))
return ajax_response(response=res['rows'][0], status=200)
def properties(self, gid, sid, did, scid, tid, idx):
"""
This function will show the properties of the selected schema node.
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
scid: Schema ID
scid: Schema ID
tid: Table ID
idx: Index ID
Returns:
JSON of selected schema node
"""
status, data = self._fetch_properties(did, tid, idx)
if not status:
return data
return ajax_response(
response=data,
status=200
)
def sql(self, gid, sid, did, scid, foid=None):
"""
Returns the SQL for the Foreign Table object.
Args:
gid: Server Group Id
sid: Server Id
did: Database Id
scid: Schema Id
foid: Foreign Table Id
"""
data = self._fetch_properties(gid, sid, did, scid, foid, inherits=True)
if data == False:
return gone(
gettext("Could not find the foreign table on the server."))
col_data = []
for c in data['columns']:
if (not 'inheritedfrom' in c) or (c['inheritedfrom'] is None):
col_data.append(c)
data['columns'] = col_data
SQL = render_template("/".join([self.template_path, 'create.sql']),
data=data,
is_sql=True)
sql_header = u"""-- FOREIGN TABLE: {0}
-- DROP FOREIGN TABLE {0};
""".format(self.qtIdent(self.conn, data['basensp'], data['name']))
SQL = sql_header + SQL
return ajax_response(response=SQL.strip('\n'))
def properties(self, gid, sid, did, scid, tid, exid=None):
"""
This function is used to list all the Exclusion constraint
nodes within that collection.
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
scid: Schema ID
tid: Table ID
exid: Exclusion constraint ID
Returns:
"""
status, res = exclusion_utils.get_exclusion_constraints(
self.conn, did, tid, exid)
if not status:
return res
if len(res) == 0:
return gone(_(
"""Could not find the exclusion constraint in the table."""
))
result = res
if exid:
result = res[0]
result['is_sys_obj'] = (
result['oid'] <= self.datlastsysoid)
return ajax_response(
response=result,
status=200
)
def list(self, gid, sid, did, scid, tid, exid=None):
"""
This function returns all exclusion constraints
nodes within that collection as a http response.
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
scid: Schema ID
tid: Table ID
exid: Exclusion constraint ID
Returns:
"""
try:
res = self.get_node_list(gid, sid, did, scid, tid, exid)
return ajax_response(
response=res,
status=200
)
except Exception as e:
return internal_server_error(errormsg=str(e))
def sql(self, gid, sid, did, scid, coid):
"""
This function will generates reverse engineered sql for collation object
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
scid: Schema ID
coid: Collation ID
"""
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)
if len(res['rows']) == 0:
return gone(
gettext(
"Could not find the collation object in the database."))
data = res['rows'][0]
SQL = render_template("/".join([self.template_path, 'create.sql']),
data=data,
conn=self.conn)
sql_header = u"-- Collation: {0};\n\n-- ".format(data['name'])
sql_header += render_template("/".join(
[self.template_path, 'delete.sql']),
name=data['name'])
SQL = sql_header + '\n\n' + SQL.strip('\n')
return ajax_response(response=SQL)
def list(self, gid, sid, did, scid):
"""
This function is used to list all the sequence nodes within the
collection.
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
scid: Schema ID
Returns:
"""
SQL = render_template("/".join(
[self.template_path, self._PROPERTIES_SQL]),
scid=scid)
status, res = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=res)
sequence_nodes = self._get_sequence_nodes(res['rows'])
return ajax_response(response=sequence_nodes, status=200)
def list(self, gid, sid, did, scid):
"""
This function is used to list all the package nodes within the
collection.
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
scid: Schema ID
Returns:
"""
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
)
def properties(self, gid, sid, did, scid, coid):
"""
This function will show the properties of the selected
catalog objects node.
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
scid: Schema ID
scid: Schema ID
coid: Catalog object ID
Returns:
JSON of selected catalog objects node
"""
SQL = render_template(
"/".join([self.template_path, self._PROPERTIES_SQL]),
scid=scid, coid=coid
)
status, res = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=res)
if len(res['rows']) == 0:
return gone(
gettext("""Could not find the specified catalog object."""))
res['rows'][0]['is_sys_obj'] = (
res['rows'][0]['oid'] <= self.datlastsysoid)
return ajax_response(
response=res['rows'][0],
status=200
)
def properties(self, gid, sid, rid):
status, res = self.conn.execute_dict(
render_template(
self.sql_path + 'properties.sql',
rid=rid
)
)
if not status:
return internal_server_error(
_(
"Error retrieving roles from the database server.\n{0}"
).format(res)
)
self.transform(res)
if len(res['rows']) == 0:
return gone(_("Could not find the role information."))
return ajax_response(
response=res['rows'][0],
status=200
)
def sql(self, gid, sid, did, eid, json_resp=True):
"""
This function will generate sql for the sql panel
"""
SQL = render_template("/".join(
[self.template_path, self._PROPERTIES_SQL]),
eid=eid)
status, res = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=res)
if len(res['rows']) == 0:
return gone(gettext("Could not find the extension on the server."))
result = res['rows'][0]
SQL = render_template("/".join([self.template_path, self._CREATE_SQL]),
data=result,
conn=self.conn,
display_comments=True)
if not json_resp:
return SQL
return ajax_response(response=SQL)
def list(self, gid, sid, did, scid):
"""
List all FTS Dictionary nodes.
Args:
gid: Server Group Id
sid: Server Id
did: Database Id
scid: Schema Id
"""
sql = render_template("/".join(
[self.template_path, self._PROPERTIES_SQL]),
scid=scid)
status, res = self.conn.execute_dict(sql)
if not status:
return internal_server_error(errormsg=res)
for row in res['rows']:
if row['options'] is not None:
row['options'] = self.tokenize_options(row['options'])
return ajax_response(response=res['rows'], status=200)
def sql(self, gid, sid, did, cid, json_resp=True):
"""
This function will generate sql for sql panel
:param gid: group id
:param sid: server id
:param did: database id
:param cid: cast id
:param json_resp:
:return:
"""
try:
sql = render_template(
"/".join([self.template_path, 'sql.sql']),
cid=cid,
conn=self.conn
)
status, res = self.conn.execute_scalar(sql)
if not status:
return internal_server_error(gettext(
"Could not generate reversed engineered SQL for the cast."
) + "\n\n{0}".format(res))
if res is None:
return gone(gettext(
"Could not generate reversed engineered SQL for the "
"cast node."
))
if not json_resp:
return res
return ajax_response(response=res)
except Exception as e:
return internal_server_error(errormsg=str(e))
def properties(self, gid, sid, did, scid, tid, cid):
"""
Returns the Check Constraints property.
Args:
gid: Server Group Id
sid: Server Id
did: Database Id
scid: Schema Id
tid: Check Id
cid: Check Constraint Id
"""
SQL = render_template("/".join([self.template_path, 'properties.sql']),
tid=tid,
cid=cid)
status, res = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=res)
if len(res['rows']) == 0:
return gone(_("Could not find the object on the server."))
data = res['rows'][0]
return ajax_response(response=data, status=200)
def sql(self, gid, sid, did, scid, syid, diff_schema=None, json_resp=True):
"""
This function will generates reverse engineered sql for synonym object
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
scid: Schema ID
syid: Synonym ID
diff_schema:
json_resp:
"""
SQL = render_template("/".join([self.template_path, 'properties.sql']),
scid=scid,
syid=syid)
status, res = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=res)
if len(res['rows']) > 0:
data = res['rows'][0]
else:
return gone(gettext('The specified synonym could not be found.'))
if diff_schema:
data['schema'] = diff_schema
SQL = render_template("/".join([self.template_path, 'create.sql']),
data=data,
conn=self.conn,
comment=True)
if not json_resp:
return SQL
return ajax_response(response=SQL)
def properties(self, gid, sid, tsid):
SQL = render_template(
"/".join([self.template_path, self._PROPERTIES_SQL]),
tsid=tsid, conn=self.conn
)
status, res = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=res)
if len(res['rows']) == 0:
return gone(
gettext("""Could not find the tablespace information.""")
)
# Making copy of output for future use
copy_data = dict(res['rows'][0])
copy_data['is_sys_obj'] = (
copy_data['oid'] <= self.datlastsysoid or self.datistemplate)
copy_data = self._formatter(copy_data, tsid)
return ajax_response(
response=copy_data,
status=200
)
def sql(self, gid, sid, did, scid, tid, idx):
"""
This function will generates reverse engineered sql for schema object
Args:
gid: Server Group ID
sid: Server ID
did: Database ID
scid: Schema ID
tid: Table ID
idx: Index ID
"""
SQL = index_utils.get_reverse_engineered_sql(
self.conn,
schema=self.schema,
table=self.table,
did=did,
tid=tid,
idx=idx,
datlastsysoid=self.datlastsysoid,
add_not_exists_clause=True)
return ajax_response(response=SQL)
def properties(self, gid, sid, jid=None):
SQL = render_template("/".join(
[self.template_path, self._PROPERTIES_SQL]),
jid=jid,
conn=self.conn)
status, rset = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=rset)
if jid is not None:
if len(rset['rows']) != 1:
return gone(errormsg=_(
"Could not find the pgAgent job on the server."))
res = rset['rows'][0]
status, rset = self.conn.execute_dict(
render_template("/".join([self.template_path, 'steps.sql']),
jid=jid,
conn=self.conn,
has_connstr=self.manager.db_info['pgAgent']
['has_connstr']))
if not status:
return internal_server_error(errormsg=rset)
res['jsteps'] = rset['rows']
status, rset = self.conn.execute_dict(
render_template("/".join([self.template_path,
'schedules.sql']),
jid=jid,
conn=self.conn))
if not status:
return internal_server_error(errormsg=rset)
res['jschedules'] = rset['rows']
else:
res = rset['rows']
return ajax_response(response=res, status=200)
def properties(self, gid, sid, did, scid, pkgid, edbfnid=None):
"""
Returns the Function properties.
Args:
gid: Server Group Id
sid: Server Id
did: Database Id
scid: Schema Id
pkgid: Package Id
edbfnid: Function Id
"""
SQL = render_template("/".join([self.sql_template_path,
'properties.sql']),
pkgid=pkgid, edbfnid=edbfnid)
status, res = self.conn.execute_dict(SQL)
if not status:
return internal_server_error(errormsg=res)
if len(res['rows']) == 0:
return gone(gettext("""
Could not find the function in the database.\n
It may have been removed by another user or moved to another schema.
"""))
resp_data = res['rows'][0]
# Get formatted Arguments
frmtd_params, frmtd_proargs = self._format_arguments_from_db(resp_data)
resp_data.update(frmtd_params)
resp_data.update(frmtd_proargs)
return ajax_response(
response=resp_data,
status=200
)
