class TriggerFunction(FunctionBase): TEMPLATE_ROOT = templating.get_template_root(__file__, 'templates_trigger_funcs') @classmethod def _template_root(cls, server: 's.Server'): return path.join(cls.TEMPLATE_ROOT, server.server_type)
class View(ViewBase): TEMPLATE_ROOT = templating.get_template_root(__file__, 'view_templates') @classmethod def _template_root(cls, server: 's.Server'): return os.path.join(cls.TEMPLATE_ROOT, server.server_type) def __init__(self, server: 's.Server', parent: NodeObject, name: str): ViewBase.__init__(self, server, parent, name) self._rules: NodeCollection[Rule] = self._register_child_collection( Rule) self._triggers: NodeCollection[ Trigger] = self._register_child_collection(Trigger) @property def rules(self) -> NodeCollection[Rule]: return self._rules @property def triggers(self) -> NodeCollection[Trigger]: return self._triggers
class Schema(NodeObject, ScriptableCreate, ScriptableDelete, ScriptableUpdate): TEMPLATE_ROOT = templating.get_template_root(__file__, 'templates') MACRO_ROOT = templating.get_template_root(__file__, 'macros') GLOBAL_MACRO_ROOT = templating.get_template_root(__file__, '../global_macros') @classmethod def _from_node_query(cls, server: 's.Server', parent: NodeObject, **kwargs) -> 'Schema': """ Creates an instance of a schema object from the results of a nodes query :param server: Server that owns the schema :param parent: Parent object of the schema. Should be a Database :param kwargs: A row from the nodes query Kwargs: name str: Name of the schema oid int: Object ID of the schema can_create bool: Whether or not the schema can be created by the current user has_usage bool: Whether or not the schema can be used(?) :return: """ schema = cls(server, parent, kwargs['name']) schema._oid = kwargs['oid'] schema._can_create = kwargs['can_create'] schema._has_usage = kwargs['has_usage'] schema._is_system = kwargs['is_system'] return schema def __init__(self, server: 's.Server', parent: NodeObject, name: str): NodeObject.__init__(self, server, parent, name) ScriptableCreate.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableDelete.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableUpdate.__init__(self, self._template_root(server), self._macro_root(), server.version) # Declare the optional parameters self._can_create: Optional[bool] = None self._has_usage: Optional[bool] = None # PROPERTIES ########################################################### @property def nsptyp(self): return self._full_properties.get("nsptyp", "") @property def acl(self): return self._full_properties.get("acl", "") @property def is_sys_object(self): return self._full_properties.get("is_sys_object", "") @property def tblacl(self): return self._full_properties.get("tblacl", "") @property def seqacl(self): return self._full_properties.get("seqacl", "") @property def funcacl(self): return self._full_properties.get("funcacl", "") @property def typeacl(self): return self._full_properties.get("typeacl", "") @property def can_create(self) -> Optional[bool]: return self._can_create @property def has_usage(self) -> Optional[bool]: return self._has_usage # -CHILD OBJECTS ####################################################### @property def collations(self) -> NodeCollection: return [ collation for collation in self.parent.collations if collation.scid == self.oid ] @property def datatypes(self) -> NodeCollection: return [ datatype for datatype in self.parent.datatypes if datatype.scid == self.oid ] @property def functions(self) -> NodeCollection: return [ function for function in self.parent.functions if function.scid == self.oid ] @property def sequences(self) -> NodeCollection: return [ sequence for sequence in self.parent.sequences if sequence.scid == self.oid ] @property def tables(self) -> NodeCollection: return [ table for table in self.parent.tables if table.scid == self.oid ] @property def trigger_functions(self) -> NodeCollection: return [ trigger for trigger in self.parent.trigger_functions if trigger.scid == self.oid ] @property def views(self) -> NodeCollection: return [view for view in self.parent.views if view.scid == self.oid] @property def materialized_views(self) -> NodeCollection: return [ view for view in self.parent.materialized_views if view.scid == self.oid ] @property def extensions(self) -> NodeCollection: return [ extension for extension in self.parent.extensions if extension.scid == extension.oid ] @property def namespaceowner(self): return self._full_properties.get("namespaceowner", "") @property def description(self): return self._full_properties.get("description", "") @property def nspacl(self): return self._full_properties.get("nspacl", "") @property def seclabels(self): return self._full_properties.get("seclabels", "") @property def cascade(self): return self._full_properties.get("cascade", "") @property def defacl(self): return self._full_properties.get("defacl", "") # IMPLEMENTATION DETAILS ############################################### @classmethod def _macro_root(cls) -> List[str]: return [cls.MACRO_ROOT, cls.GLOBAL_MACRO_ROOT] @classmethod def _template_root(cls, server: 's.Server') -> str: return path.join(cls.TEMPLATE_ROOT, server.server_type) def _create_query_data(self) -> dict: """ Function that returns data for create script """ return { "data": { "name": self.name, "namespaceowner": self.namespaceowner, "description": self.description, "nspacl": self.nspacl, "seclabels": self.seclabels } } def _delete_query_data(self) -> dict: """ Function that returns data for delete script """ return {"name": self.name, "cascade": self.cascade} def _update_query_data(self) -> dict: """ Function that returns data for update script """ return { "data": { "name": '<New Name>', "namespaceowner": '<New Owner>', "description": '<New Description>', "nspacl": self.nspacl, "defacl": self.defacl, "seclabels": self.seclabels }, "o_data": { "name": self.name, "namespaceowner": self.namespaceowner, "description": self.description } }
class Sequence(NodeObject, ScriptableCreate, ScriptableDelete, ScriptableUpdate): TEMPLATE_ROOT = templating.get_template_root(__file__, 'templates') MACRO_ROOT = templating.get_template_root(__file__, 'macros') GLOBAL_MACRO_ROOT = templating.get_template_root(__file__, '../global_macros') @classmethod def _from_node_query(cls, server: 's.Server', parent: NodeObject, **kwargs) -> 'Sequence': """ Creates a Sequence object from the result of a sequence node query :param server: Server that owns the sequence :param parent: Parent object of the sequence :param kwargs: Row from a sequence node query Kwargs: oid int: Object ID of the sequence name str: Name of the sequence :return: A Sequence instance """ seq = cls(server, parent, kwargs['name']) seq._oid = kwargs['oid'] seq._schema = kwargs['schema'] seq._scid = kwargs['schemaoid'] seq._is_system = kwargs['is_system'] return seq def __init__(self, server: 's.Server', parent: NodeObject, name: str): NodeObject.__init__(self, server, parent, name) ScriptableCreate.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableDelete.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableUpdate.__init__(self, self._template_root(server), self._macro_root(), server.version) self._schema: str = None self._scid: int = None # PROPERTIES ########################################################### @property def schema(self): return self._schema @property def scid(self): return self._scid # -FULL OBJECT PROPERTIES ############################################## @property def cycled(self): return self._full_properties.get("cycled", "") @property def increment(self): return self._full_properties.get("increment", "") @property def start(self): return self._full_properties.get("start", "") @property def current_value(self): return self._full_properties.get("current_value", "") @property def minimum(self): return self._full_properties.get("minimum", "") @property def maximum(self): return self._full_properties.get("maximum", "") @property def cache(self): return self._full_properties.get("cache", "") @property def cascade(self): return self._full_properties.get("cascade", "") @property def seqowner(self): return self._full_properties.get("seqowner", "") @property def comment(self): return self._full_properties.get("comment", "") # IMPLEMENTATION DETAILS ############################################### @classmethod def _macro_root(cls) -> List[str]: return [cls.MACRO_ROOT, cls.GLOBAL_MACRO_ROOT] @classmethod def _template_root(cls, server: 's.Server') -> str: return cls.TEMPLATE_ROOT # HELPER METHODS ################################################################## def _create_query_data(self): """ Gives the data object for create query """ return { "data": { "schema": self.schema, "name": self.name, "cycled": self.cycled, "increment": self.increment, "start": self.start, "current_value": self.current_value, "minimum": self.minimum, "maximum": self.maximum, "cache": self.cache } } def _update_query_data(self): """ Gives the data object for update query """ return { "data": { "schema": self.schema, "name": self.name, "cycled": self.cycled, "increment": self.increment, "start": self.start, "current_value": self.current_value, "minimum": self.minimum, "maximum": self.maximum, "cache": self.cache }, "o_data": { "schema": self.schema, "name": self.name, "seqowner": self.seqowner, "comment": self.comment } } def _delete_query_data(self): """ Gives the data object for update query """ return { "data": { "schema": self.schema, "name": self.name, "cycled": self.cycled, "increment": self.increment, "start": self.start, "current_value": self.current_value, "minimum": self.minimum, "maximum": self.maximum, "cache": self.cache }, "cascade": self.cascade }
# -------------------------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. # -------------------------------------------------------------------------------------------- from typing import Optional, List, Any from pgsmo.objects.node_object import NodeObject, NodeLazyPropertyCollection # noqa from pgsmo.objects.scripting_mixins import ScriptableCreate, ScriptableDelete, ScriptableUpdate from pgsmo.objects.server import server as s # noqa import pgsmo.utils.templating as templating TEMPLATE_ROOT = templating.get_template_root(__file__, 'templates') MACRO_ROOT = templating.get_template_root(__file__, 'macros') GLOBAL_MACRO_ROOT = templating.get_template_root(__file__, '../global_macros') class DataType(NodeObject, ScriptableCreate, ScriptableDelete, ScriptableUpdate): """Represents a data type""" @classmethod def _from_node_query(cls, server: 's.Server', parent: NodeObject, **kwargs) -> 'DataType': """ Creates a Type object from the result of a DataType node query :param server: Server that owns the DataType :param parent: Parent object of the DataType :param kwargs: Row from a DataType node query Kwargs: name str: Name of the DataType oid int: Object ID of the DataType
class Role(NodeObject, ScriptableCreate, ScriptableUpdate): TEMPLATE_ROOT = templating.get_template_root(__file__, 'templates') MACRO_ROOT = templating.get_template_root(__file__, 'macros') @classmethod def _from_node_query(cls, server: 's.Server', parent: None, **kwargs) -> 'Role': """ Creates a Role object from the result of a role node query :param server: Server that owns the role :param parent: Parent object of the role :param kwargs: Row from a role node query Kwargs: name str: Name of the role oid int: Object ID of the role rolcanlogin bool: Whether or not the role can login rolsuper bool: Whether or not the role is a super user :return: A Role instance """ role = cls(server, kwargs['name']) # Define values from node query role._oid = kwargs['oid'] role._can_login = kwargs['rolcanlogin'] role._is_super = kwargs['rolsuper'] return role def __init__(self, server: 's.Server', name: str): """ Initializes internal state of a Role object """ NodeObject.__init__(self, server, None, name) ScriptableCreate.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableUpdate.__init__(self, self._template_root(server), self._macro_root(), server.version) # Declare basic properties self._can_login: Optional[bool] = None self._is_super: Optional[bool] = None # PROPERTIES ########################################################### # -BASIC PROPERTIES #################################################### @property def can_login(self) -> Optional[bool]: """Whether or not the role can login to the server""" return self._can_login @property def is_super(self) -> Optional[bool]: """Whether or not the role is a super user""" return self._is_super # -FULL OBJECT PROPERTIES ############################################## @property def createdb(self): return self._full_properties.get("createdb", "") @property def createrole(self): return self._full_properties.get("createrole", "") @property def inherit(self): return self._full_properties.get("inherit", "") @property def replication(self): return self._full_properties.get("replication", "") @property def connlimit(self): return self._full_properties.get("connlimit", "") @property def validuntil(self): return self._full_properties.get("validuntil", "") @property def password(self): return self._full_properties.get("password", "") @property def catupdate(self): return self._full_properties.get("catupdate", "") @property def members(self): return self._full_properties.get("members", "") @property def admins(self): return self._full_properties.get("admins", "") @property def variables(self): return self._full_properties.get("variables", "") @property def description(self): return self._full_properties.get("description", "") @property def revoked_admins(self): return self._full_properties.get("revoked_admins", "") @property def revoked(self): return self._full_properties.get("revoked", "") # IMPLEMENTATION DETAILS ############################################### @classmethod def _macro_root(cls) -> List[str]: return [cls.MACRO_ROOT] @classmethod def _template_root(cls, server: 's.Server') -> str: return cls.TEMPLATE_ROOT def _create_query_data(self): """ Gives the data object for create query """ return { "data": { "rolcanlogin": self.can_login, "rolsuper": self.is_super, "rolcreatedb": self.createdb, "rolcreaterole": self.createrole, "rolinherit": self.inherit, "rolreplication": self.replication, "rolconnlimit": self.connlimit, "rolvaliduntil": self.validuntil, "rolpassword": self.password, "rolcatupdate": self.catupdate, "rolname": self.name, "members": self.members, "admins": self.admins, "variables": self.variables, "description": self.description } } def _update_query_data(self): """ Gives the data object for update query """ return { "data": { "rolname": self.name, "rolcanlogin": self.can_login, "rolsuper": self.is_super, "rolcreatedb": self.createdb, "rolcreaterole": self.createrole, "rolinherit": self.inherit, "rolreplication": self.replication, "rolconnlimit": self.connlimit, "rolvaliduntil": self.validuntil, "rolpassword": self.password, "rolcatupdate": self.catupdate, "revoked_admins": self.revoked_admins, "revoked": self.revoked, "admins": self.admins, "members": self.members, "variables": self.variables, "description": self.description }, "rolCanLogin": self.can_login }
class Index(NodeObject, ScriptableCreate, ScriptableDelete, ScriptableUpdate): TEMPLATE_ROOT = templating.get_template_root(__file__, 'index') @classmethod def _from_node_query(cls, server: 's.Server', parent: NodeObject, **kwargs) -> 'Index': """ Creates a new Index object based on the results of a nodes query :param server: Server that owns the index :param parent: Parent object of the Index. Should be Table/View :param kwargs: Parameters for the index Kwargs: name str: The name of the index oid int: Object ID of the index :return: Instance of the Index """ idx = cls(server, parent, kwargs['name']) idx._oid = kwargs['oid'] idx._is_clustered = kwargs['indisclustered'] idx._is_primary = kwargs['indisprimary'] idx._is_unique = kwargs['indisunique'] idx._is_valid = kwargs['indisvalid'] return idx def __init__(self, server: 's.Server', parent: NodeObject, name: str): """ Initializes a new instance of an Index :param server: Server that owns the index :param parent: Parent object of the index. Should be Table/View :param name: Name of the index """ NodeObject.__init__(self, server, parent, name) ScriptableCreate.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableDelete.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableUpdate.__init__(self, self._template_root(server), self._macro_root(), server.version) # Object Properties self._is_clustered: Optional[bool] = None self._is_primary: Optional[bool] = None self._is_unique: Optional[bool] = None self._is_valid: Optional[bool] = None self._is_concurrent: Optional[bool] = None # PROPERTIES ########################################################### # -FULL OBJECT PROPERTIES ############################################## @property def is_clustered(self): return self._is_clustered @property def is_valid(self) -> Optional[bool]: return self._is_valid @property def is_unique(self): return self._is_unique @property def is_primary(self): return self._is_primary @property def is_concurrent(self): return self._is_concurrent @property def amname(self): return self._full_properties["amname"] @property def columns(self): return self._full_properties["columns"] @property def fillfactor(self): return self._full_properties["fillfactor"] @property def spcname(self): return self._full_properties["spcname"] @property def indconstraint(self): return self._full_properties["indconstraint"] @property def mode(self): return self._full_properties["mode"] @property def index(self): return self._full_properties["index"] @property def cascade(self): return self._full_properties["cascade"] @property def description(self): return self._full_properties["description"] @property def extended_vars(self): return { 'tid': self.parent.oid # Table/view OID } # IMPLEMENTATION DETAILS ############################################### @classmethod def _template_root(cls, server: 's.Server') -> str: return cls.TEMPLATE_ROOT def _create_query_data(self) -> dict: """ Provides data input for create script """ return { "data": { "indisunique": self.is_unique, "isconcurrent": self.is_concurrent, "name": self.name, "schema": self.parent.schema, "table": self.parent.name, "amname": self.amname, "columns": self.columns, "fillfactor": self.fillfactor, "spcname": self.spcname, "indconstraint": self.indconstraint }, "mode": "create" } def _delete_query_data(self) -> dict: """ Provides data input for delete script """ return { "data": { "nspname": self.parent.schema, "name": self.name }, "cascade": self.cascade } def _update_query_data(self) -> dict: """ Function that returns data for update script """ return { "data": { "name": self.name, "schema": self.parent.schema, "fillfactor": self.fillfactor, "spcname": self.spcname, "indisclustered": self.is_clustered, "table": self.parent.name, "description": self.description }, "o_data": { "name": "", "fillfactor": "", "spcname": "", "indisclustered": "", "description": "" } }
class Trigger(NodeObject, ScriptableCreate, ScriptableDelete, ScriptableUpdate): TEMPLATE_ROOT = templating.get_template_root(__file__, 'trigger') @classmethod def _from_node_query(cls, server: 's.Server', parent: NodeObject, **kwargs) -> 'Trigger': """ Creates a new Trigger object based on the results of a nodes query :param server: Server that owns the trigger :param parent: Parent object of the Trigger. Should be Table/View :param kwargs: Parameters for the trigger Kwargs: oid int: Object ID of the trigger name str: Name of the trigger is_enable_trigger bool: Whether or not the trigger is enabled :return: Instance of a Trigger """ trigger = cls(server, parent, kwargs['name']) trigger._oid = kwargs['oid'] # Basic properties trigger._is_enabled = kwargs['is_enable_trigger'] return trigger def __init__(self, server: 's.Server', parent: NodeObject, name: str): """ Initializes a new instance of a trigger :param server: Connection the trigger belongs to :param parent: Parent object of the trigger. Should be Table/View :param name: Name of the trigger """ NodeObject.__init__(self, server, parent, name) ScriptableCreate.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableDelete.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableUpdate.__init__(self, self._template_root(server), self._macro_root(), server.version) # Declare Trigger-specific basic properties self._is_enabled: Optional[bool] = None # PROPERTIES ########################################################### # -BASIC PROPERTIES #################################################### @property def is_enabled(self) -> Optional[bool]: """Whether or not the trigger is enabled""" return self._is_enabled # -FULL OBJECT PROPERTIES ############################################## @property def lanname(self): return self._full_properties["lanname"] @property def tfunction(self): return self._full_properties["tfunction"] @property def is_constraint_trigger(self): return self._full_properties["is_constraint_trigger"] @property def fires(self): return self._full_properties["fires"] @property def evnt_insert(self): return self._full_properties["evnt_insert"] @property def evnt_delete(self): return self._full_properties["evnt_delete"] @property def evnt_truncate(self): return self._full_properties["evnt_truncate"] @property def evnt_update(self): return self._full_properties["evnt_update"] @property def columns(self): return self._full_properties["columns"] @property def deferrable(self): return self._full_properties["deferrable"] @property def initdeferred(self): return self._full_properties["initdeferred"] @property def is_row_trigger(self): return self._full_properties["is_row_trigger"] @property def whenclause(self): return self._full_properties["whenclause"] @property def prosrc(self): return self._full_properties["prosrc"] @property def args(self): return self._full_properties["args"] @property def description(self): return self._full_properties["description"] @property def cascade(self): return self._full_properties["cascade"] @property def is_enable_trigger(self): return self._full_properties["is_enable_trigger"] # IMPLEMENTATION DETAILS ############################################### @classmethod def _template_root(cls, server: 's.Server') -> str: return cls.TEMPLATE_ROOT def _create_query_data(self) -> dict: """ Provides data input for create script """ return { "data": { "lanname": self.lanname, "tfunction": self.tfunction, "name": self.name, "is_constraint_trigger": self.is_constraint_trigger, "fires": self.fires, "evnt_insert": self.evnt_insert, "evnt_delete": self.evnt_delete, "evnt_truncate": self.evnt_truncate, "evnt_update": self.evnt_update, "columns": self.columns, "schema": self.parent.schema, "table": self.parent.name, "tgdeferrable": self.deferrable, "tginitdeferred": self.initdeferred, "is_row_trigger": self.is_row_trigger, "whenclause": self.whenclause, "prosrc": self.prosrc, "tgargs": self.args, "description": self.description, } } def _delete_query_data(self) -> dict: """ Provides data input for delete script """ return { "data": { "name": self.name, "nspname": self.parent.schema, "relname": self.parent.name }, "cascade": self.cascade } def _update_query_data(self) -> dict: """ Function that returns data for update script """ return { "data": { "name": self.name, "prosrc": self.prosrc, "is_row_trigger": self.is_row_trigger, "evnt_insert": self.evnt_insert, "evnt_delete": self.evnt_delete, "evnt_update": self.evnt_update, "fires": self.fires, "evnt_truncate": self.evnt_truncate, "schema": self.parent.schema, "table": self.parent.name, "description": self.description, "is_enable_trigger": self.is_enable_trigger }, "o_data": { "name": "", "nspname": "", "relname": "", "lanname": "", "prosrc": "", "is_row_trigger": "", "evnt_insert": "", "evnt_delete": "", "evnt_update": "", "fires": "", "evnt_truncate": "", "columns": "", "tgdeferrable": "", "tginitdeferred": "", "whenclause": "", "description": "", "is_enable_trigger": "" } }
class FunctionBase(NodeObject, ScriptableCreate, ScriptableDelete, ScriptableUpdate, metaclass=ABCMeta): """Base class for Functions. Provides basic properties for all Function types""" MACRO_ROOT = templating.get_template_root(__file__, 'macros') GLOBAL_MACRO_ROOT = templating.get_template_root(__file__, '../global_macros') @classmethod def _from_node_query(cls, server: 's.Server', parent: NodeObject, **kwargs) -> 'FunctionBase': """ Creates a Function instance from the results of a node query :param server: Server that owns the function :param parent: Parent object of the function :param kwargs: A row from the node query Kwargs: oid int: Object ID of the function name str: Signature of the function lanname str: Name of the language the function is written in funcowner str: Name of the owner of the function description str: Description of the function :return: A Function instance """ func = cls(server, parent, kwargs['name']) func._oid = kwargs['oid'] func._language_name = kwargs['lanname'] func._owner = kwargs['funcowner'] func._description = kwargs['description'] func._schema = kwargs['schema'] func._scid = kwargs['schemaoid'] func._is_system = kwargs['is_system'] return func def __init__(self, server: 's.Server', parent: NodeObject, name: str): NodeObject.__init__(self, server, parent, name) ScriptableCreate.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableDelete.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableUpdate.__init__(self, self._template_root(server), self._macro_root(), server.version) # Declare the basic properties self._description: Optional[str] = None self._language_name: Optional[str] = None self._owner: Optional[str] = None self._schema: str = None self._scid: int = None # PROPERTIES ########################################################### @property def extended_vars(self): template_vars = { 'scid': self.scid, 'fnid': self.oid } return template_vars # -BASIC PROPERTIES #################################################### @property def schema(self): return self._schema @property def scid(self): return self._scid @property def description(self) -> Optional[str]: return self._description @property def language_name(self) -> Optional[str]: return self._language_name @property def owner(self) -> Optional[str]: return self._owner # -FULL OBJECT PROPERTIES ############################################## @property def xmin(self): return self._full_properties.get("xmin", "") @property def proname(self): return self._full_properties.get("proname", "") @property def pronamespace(self): return self._full_properties.get("pronamespace", "") @property def proowner(self): return self._full_properties.get("proowner", "") @property def prolang(self): return self._full_properties.get("prolang", "") @property def provariadic(self): return self._full_properties.get("provariadic", "") @property def protransform(self): return self._full_properties.get("protransform", "") @property def proisagg(self): return self._full_properties.get("proisagg", "") @property def pronargs(self): return self._full_properties.get("pronargs", "") @property def pronargdefaults(self): return self._full_properties.get("pronargdefaults", "") @property def prorettype(self): return self._full_properties.get("prorettype", "") @property def proargtypes(self): return self._full_properties.get("proargtypes", "") @property def proallargtypes(self): return self._full_properties.get("proallargtypes", "") @property def proargmodes(self): return self._full_properties.get("proargmodes", "") @property def proargdefaults(self): return self._full_properties.get("proargdefaults", "") @property def protrftypes(self): return self._full_properties.get("protrftypes", "") @property def proconfig(self): return self._full_properties.get("proconfig", "") @property def proacl(self): return self._full_properties.get("proacl", "") @property def typnsp(self): return self._full_properties.get("typnsp", "") @property def arguments(self) -> Optional[str]: return self._full_properties.get("arguments", "") @property def proargdefaultvals(self) -> Optional[str]: return self._full_properties.get("proargdefaultvals", "") @property def proargnames(self) -> Optional[str]: return self._full_properties.get("proargnames", "") @property def proargtypenames(self) -> Optional[str]: return self._full_properties.get("proargtypenames", "") @property def proretset(self): return self._full_properties.get("proretset", "") @property def prorettypename(self): return self._full_properties.get("prorettypename", "") @property def procost(self): return self._full_properties.get("procost", "") @property def provolatile(self): return self._full_properties.get("provolatile", "") @property def proleakproof(self): return self._full_properties.get("proleakproof", "") @property def proisstrict(self): return self._full_properties.get("proisstrict", "") @property def prosecdef(self): return self._full_properties.get("prosecdef", "") @property def proiswindow(self): return self._full_properties.get("proiswindow", "") @property def proparallel(self): return self._full_properties.get("proparallel", "") @property def prorows(self): return self._full_properties.get("prorows", "") @property def variables(self): return self._full_properties.get("variables", "") @property def probin(self): return self._full_properties.get("probin", "") @property def prosrc_c(self): return self._full_properties.get("prosrc_c", "") @property def prosrc(self): return self._full_properties.get("prosrc", "") @property def func_args_without(self): return self._full_properties.get("func_args_without", "") @property def acl(self): return self._full_properties.get("acl", "") @property def seclabels(self): return self._full_properties.get("seclabels", "") @property def change_func(self): return self._full_properties.get("change_func", "") @property def merged_variables(self): return self._full_properties.get("merged_variables", "") @property def cascade(self): return self._full_properties.get("cascade", "") # IMPLEMENTATION DETAILS ############################################### @classmethod def _macro_root(cls) -> List[str]: return [cls.MACRO_ROOT, cls.GLOBAL_MACRO_ROOT] def _create_query_data(self) -> dict: """ Provides data input for create script """ return {"data": { "name": self.name, "pronamespace": self.schema, "arguments": self.arguments, "proretset": self.proretset, "prorettypename": self.prorettypename, "lanname": self.language_name, "procost": self.procost, "provolatile": self.provolatile, "proleakproof": self.proleakproof, "proisstrict": self.proisstrict, "prosecdef": self.prosecdef, "proiswindow": self.proiswindow, "proparallel": self.proparallel, "prorows": self.prorows, "variables": self.variables, "probin": self.probin, "prosrc_c": self.prosrc_c, "prosrc": self.prosrc, "funcowner": self.owner, "func_args_without": self.func_args_without, "description": self.description, "acl": self.acl, "seclabels": self.seclabels }} def _delete_query_data(self) -> dict: """ Provides data input for delete script """ return { "name": self.name, "nspname": self.schema, "cascade": self.cascade } def _update_query_data(self) -> dict: """ Function that returns data for update script """ return { "data": { "name": self.name, "pronamespace": self.schema, "arguments": self.arguments, "lanname": self.language_name, "procost": self.procost, "provolatile": self.provolatile, "proisstrict": self.proisstrict, "prosecdef": self.prosecdef, "proiswindow": self.proiswindow, "prorows": self.prorows, "variables": self.variables, "probin": self.probin, "prosrc": self.prosrc, "funcowner": self.owner, "description": self.description, "acl": self.acl, "seclabels": self.seclabels, "change_func": self.change_func, "merged_variables": self.merged_variables }, "o_data": { "name": "", "pronamespace": "", "proargtypenames": "", "lanname": "", "provolatile": "", "proisstrict": "", "prosecdef": "", "proiswindow": "", "procost": "", "prorows": "", "probin": "", "prosrc_c": "", "prosrc": "" } }
class Tablespace(NodeObject, ScriptableCreate, ScriptableDelete, ScriptableUpdate): TEMPLATE_ROOT = templating.get_template_root(__file__, 'templates') MACRO_ROOT = templating.get_template_root(__file__, 'macros') @classmethod def _from_node_query(cls, server: 's.Server', parent: None, **kwargs) -> 'Tablespace': """ Creates a tablespace from a row of a nodes query result :param server: Server that owns the tablespace :param parent: Parent object of the tablespace. Must be None :param kwargs: Row from a node query for a list of :return: A Tablespace instance """ tablespace = cls(server, kwargs['name']) tablespace._oid = kwargs['oid'] tablespace._owner = kwargs['owner'] return tablespace def __init__(self, server: 's.Server', name: str): """ Initializes internal state of a Role object """ NodeObject.__init__(self, server, None, name) ScriptableCreate.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableDelete.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableUpdate.__init__(self, self._template_root(server), self._macro_root(), server.version) # Declare basic properties self._owner: Optional[int] = None # PROPERTIES ########################################################### # -BASIC PROPERTIES #################################################### @property def owner(self) -> Optional[int]: """Object ID of the user that owns the tablespace""" return self._owner # -FULL OBJECT PROPERTIES ############################################## @property def user(self): return self._full_properties.get("user", "") @property def location(self): return self._full_properties.get("location", "") @property def description(self): return self._full_properties.get("description", "") @property def options(self): return self._full_properties.get("options", "") @property def acl(self): return self._full_properties.get("acl", "") # IMPLEMENTATION DETAILS ############################################### @classmethod def _macro_root(cls) -> List[str]: return [cls.MACRO_ROOT] @classmethod def _template_root(cls, server: 's.Server') -> str: return cls.TEMPLATE_ROOT def _create_query_data(self): """ Returns the data needed for create query """ return { "data": { "name": self.name, "spcuser": self.user, "spclocation": self.location } } def _delete_query_data(self): """ Returns the data needed for delete query """ return {"tsname": self.name} def _update_query_data(self): """ Returns the data needed for update query """ return { "data": { "name": self.name, "spcuser": self.user, "spclocation": self.location, "description": self.description, "spcoptions": self.options, "spcacl": self.acl }, "o_data": { "name": "", "spcuser": "", "description": "" } }
class ViewBase(NodeObject, ScriptableCreate, ScriptableDelete, ScriptableUpdate, ScriptableSelect): TEMPLATE_ROOT = templating.get_template_root(__file__, 'view_templates') MACRO_ROOT = templating.get_template_root(__file__, 'macros') GLOBAL_MACRO_ROOT = templating.get_template_root(__file__, '../global_macros') @classmethod def _from_node_query(cls, server: 's.Server', parent: NodeObject, **kwargs) -> 'View': """ Creates a view object from the results of a node query :param server: Server that owns the view :param parent: Object that is the parent of the view. Should be a Schema :param kwargs: A row from the nodes query Kwargs: name str: Name of the view oid int: Object ID of the view :return: A view instance """ view = cls(server, parent, kwargs['name']) view._oid = kwargs['oid'] view._schema = kwargs['schema'] view._scid = kwargs['schemaoid'] view._is_system = kwargs['is_system'] return view def __init__(self, server: 's.Server', parent: NodeObject, name: str): NodeObject.__init__(self, server, parent, name) ScriptableCreate.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableDelete.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableUpdate.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableSelect.__init__(self, self._template_root(server), self._macro_root(), server.version) self._schema: str = None self._scid: int = None self._database = self.get_database_node() # Declare child items self._columns: NodeCollection[ Column] = self._register_child_collection(Column) # PROPERTIES ########################################################### @property def extended_vars(self): template_vars = { 'scid': self.scid, 'datlastsysoid': self._database.datlastsysoid } return template_vars # -CHILD OBJECTS ####################################################### @property def columns(self) -> NodeCollection[Column]: return self._columns # -FULL OBJECT PROPERTIES ############################################## @property def xmin(self): return self._full_properties.get("xmin", "") @property def relkind(self): return self._full_properties.get("relkind", "") @property def spcname(self): return self._full_properties.get("spcname", "") @property def spcoid(self): return self._full_properties.get("spcoid", "") @property def ispopulated(self): return self._full_properties.get("ispopulated", "") @property def acl(self): return self._full_properties.get("acl", "") @property def seclabels(self): return self._full_properties.get("seclabels", "") @property def schema(self): return self._schema @property def definition(self): return self._full_properties.get("definition", "") @property def scid(self): return self._scid @property def owner(self): return self._full_properties.get("owner", "") @property def comment(self): return self._full_properties.get("comment", "") @property def nspname(self): return self._full_properties.get("nspname", "") @property def check_option(self): result = self._full_properties.get("check_option", " ") if result is not None: return result return "no" @property def security_barrier(self): result = self._full_properties.get("security_barrier", " ") if result is not None: return result # IMPLEMENTATION DETAILS ################################################ @classmethod def _macro_root(cls) -> List[str]: return [cls.MACRO_ROOT, cls.GLOBAL_MACRO_ROOT] @classmethod def _template_root(cls, server: 's.Server') -> str: return cls.TEMPLATE_ROOT def _create_query_data(self) -> dict: """ Provides data input for create script """ return { "data": { "name": self.name, "schema": self.schema, "definition": self.definition, "check_option": self.check_option, "security_barrier": self.security_barrier, "owner": self.owner, "comment": self.comment, }, "display_comments": True } def _delete_query_data(self) -> dict: """ Provides data input for delete script """ return {"name": self.name, "nspname": self.schema} def _update_query_data(self) -> dict: """ Provides data input for update script """ return {"data": {}} def _select_query_data(self) -> dict: """Provides data input for select script""" return { "data": { "name": self.name, "schema": self.schema, "columns": self.columns } }
class Column(NodeObject, ScriptableCreate, ScriptableDelete, ScriptableUpdate): TEMPLATE_ROOT = templating.get_template_root(__file__, 'column') MACRO_ROOT = templating.get_template_root(__file__, '../table/macros') @classmethod def _from_node_query(cls, server: 's.Server', parent: NodeObject, **kwargs) -> 'Column': """ Creates a new Column object based on the the results from the column nodes query :param server: Server that owns the column :param parent: Parent object of the column. Should be a Table/View :param kwargs: Optional parameters for the column Kwargs: name str: Name of the column datatype str: Name of the type of the column oid int: Object ID of the column not_null bool: Whether or not null is allowed for the column has_default_value bool: Whether or not the column has a default value constraint :return: Instance of the Column """ col = cls(server, parent, kwargs['name'], kwargs['datatype']) col._oid = kwargs['oid'] col._has_default_value = kwargs['has_default_val'] col._not_null = kwargs['not_null'] col._column_ordinal = kwargs['oid'] - 1 col._is_key = kwargs['isprimarykey'] col._is_readonly = kwargs['is_updatable'] is False col._is_unique = kwargs['isunique'] col._type_oid = kwargs['typoid'] col._default_value = kwargs[ 'default'] if col._has_default_value is True else None col._is_auto_increment = col._default_value is not None and col._default_value.startswith( 'nextval(') return col def __init__(self, server: 's.Server', parent: NodeObject, name: str, datatype: str): """ Initializes a new instance of a Column :param server: Connection to the server/database that this object will belong to :param parent: Parent object of the column, should be a Table/View :param name: Name of the column :param datatype: Type of the column """ NodeObject.__init__(self, server, parent, name) ScriptableCreate.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableDelete.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableUpdate.__init__(self, self._template_root(server), self._macro_root(), server.version) self._datatype: str = datatype self._has_default_value: Optional[bool] = None self._not_null: Optional[bool] = None self._column_ordinal: int = None self._is_key: bool = None self._is_readonly: bool = None self._is_unique: bool = None self._type_oid: int = None self._default_value: Optional[str] = None self._is_auto_increment = None # PROPERTIES ########################################################### @property def datatype(self) -> str: return self._datatype @property def has_default_value(self) -> Optional[bool]: return self._has_default_value @property def not_null(self) -> Optional[bool]: return self._not_null @property def column_ordinal(self) -> int: return self._column_ordinal @property def is_key(self) -> bool: return self._is_key @property def is_readonly(self) -> bool: return self._is_readonly @property def is_unique(self) -> bool: return self._is_unique @property def type_oid(self) -> int: return self._type_oid @property def default_value(self) -> Optional[str]: return self._default_value @property def is_auto_increment(self) -> bool: return self._is_auto_increment @property def cltype(self): return self._full_properties["cltype"] @property def schema(self): return self._full_properties["schema"] @property def table(self): return self._full_properties["table"] @property def displaytypname(self): return self._full_properties["displaytypname"] @property def attlen(self): length, precision = self.get_length_precision(self.elemoid) if length: matchObj = re.search(r'(\d+)', self.fulltype) if matchObj: return matchObj.group(1) return None @property def elemoid(self): return self._full_properties["elemoid"] @property def attprecision(self): length, precision = self.get_length_precision(self.elemoid) if precision: matchObj = re.search(r'(\d+),(\d+)', self.fulltype) if matchObj: return matchObj.group(2) return precision @property def hasSqrBracket(self): if '[]' in self.cltype: return True else: return False @property def fulltype(self): fulltype = self.get_full_type(self._full_properties['typnspname'], self._full_properties['typname'], self._full_properties['isdup'], self._full_properties['attndims'], self._full_properties['atttypmod']) return fulltype @property def collspcname(self): return self._full_properties["collspcname"] @property def attnotnull(self): return self._full_properties["attnotnull"] @property def defval(self): return self._full_properties["defval"] @property def description(self): return self._full_properties["description"] @property def attoptions(self): return self._full_properties["attoptions"] @property def attacl(self): return self._full_properties["attacl"] @property def seclabels(self): return self._full_properties["seclabels"] @property def attstattarget(self): return self._full_properties["attstattarget"] @property def attstorage(self): return self._full_properties["attstorage"] @property def is_sql(self): return True # IMPLEMENTATION DETAILS ############################################### @classmethod def _macro_root(cls) -> List[str]: return [cls.MACRO_ROOT] @classmethod def _template_root(cls, server: 's.Server') -> str: return cls.TEMPLATE_ROOT @property def extended_vars(self): return {'tid': self.parent.oid} def _create_query_data(self) -> dict: """ Provides data input for create script """ return { "data": { "name": self.name, "cltype": self.cltype, "schema": self.schema, "table": self.table, "displaytypname": self.displaytypname, "attlen": self.attlen, "attprecision": self.attprecision, "hasSqrBracket": self.hasSqrBracket, "collspcname": self.collspcname, "attnotnull": self.attnotnull, "defval": self.defval, "description": self.description, "attoptions": self.attoptions, "attacl": self.attacl, "seclabels": self.seclabels }, "is_sql": self.is_sql } def _delete_query_data(self) -> dict: """ Provides data input for delete script """ return { "data": { "schema": self.schema, "table": self.table, "name": self.name } } def _update_query_data(self) -> dict: """ Function that returns data for update script """ return { "data": { "name": self.name, "schema": self.schema, "table": self.table, "cltype": self.cltype, "attlen": self.attlen, "attprecision": self.attprecision, "collspcname": self.collspcname, "defval": self.defval, "attnotnull": self.attnotnull, "attstattarget": self.attstattarget, "attstorage": self.attstorage, "description": self.description, "attoptions": self.attoptions, "attacl": self.attacl, "seclabels": self.seclabels }, "o_data": { "name": "", "cltype": "", "attlen": "", "attprecision": "", "collspcname": "", "defval": "", "attnotnull": "", "attstattarget": "", "attstorage": "" } } def get_length_precision(self, elemoid): precision = False length = False typeval = '' # Check against PGOID for specific type if elemoid: if elemoid in (1560, 1561, 1562, 1563, 1042, 1043, 1014, 1015): typeval = 'L' elif elemoid in (1083, 1114, 1115, 1183, 1184, 1185, 1186, 1187, 1266, 1270): typeval = 'D' elif elemoid in (1231, 1700): typeval = 'P' else: typeval = ' ' # Set precision & length/min/max values if typeval == 'P': precision = True if precision or typeval in ('L', 'D'): length = True return length, precision
class Extension(NodeObject, ScriptableCreate, ScriptableDelete): TEMPLATE_ROOT = templating.get_template_root(__file__, 'templates') MACRO_ROOT = templating.get_template_root(__file__, 'macros') GLOBAL_MACRO_ROOT = templating.get_template_root(__file__, '../global_macros') @classmethod def _from_node_query(cls, server: 's.Server', parent: NodeObject, **kwargs) -> 'Extension': """ Creates a table instance from the results of a node query :param server: Server that owns the table :param parent: Parent object of the table. Should be a Schema :param kwargs: A row from the node query Kwargs: oid int: Object ID of the table name str: Name of the table :return: A table instance """ extension = cls(server, parent, kwargs['name']) extension._oid = kwargs['oid'] extension._schema = kwargs['schema'] extension._scid = kwargs['schemaoid'] extension._is_system = kwargs['is_system'] return extension def __init__(self, server: 's.Server', parent: NodeObject, name: str): NodeObject.__init__(self, server, parent, name) ScriptableCreate.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableDelete.__init__(self, self._template_root(server), self._macro_root(), server.version) self._schema: str = None self._scid: int = None # PROPERTIES ########################################################### @property def schema(self): return self._schema @property def scid(self): return self._scid @property def extended_vars(self): template_vars = {'scid': self.scid, 'did': self.parent.oid} return template_vars # -FULL OBJECT PROPERTIES ############################################## @property def owner(self): return self._full_properties.get("owner", "") @property def relocatable(self): return self._full_properties.get("relocatable", "") @property def version(self): return self._full_properties.get("version", "") # IMPLEMENTATION DETAILS ############################################### @classmethod def _macro_root(cls) -> List[str]: return [cls.MACRO_ROOT, cls.GLOBAL_MACRO_ROOT] @classmethod def _template_root(cls, server: 's.Server') -> str: return path.join(cls.TEMPLATE_ROOT, server.server_type) def _create_query_data(self) -> dict: """ Provides data input for create script """ return {"data": {"name": self.name, "schema": self.schema}} def _delete_query_data(self) -> dict: """ Provides data input for delete script """ return { "data": { "name": self.name, "schema": self.schema }, }
class Collation(NodeObject, ScriptableCreate, ScriptableDelete, ScriptableUpdate): TEMPLATE_ROOT = templating.get_template_root(__file__, 'templates') MACRO_ROOT = templating.get_template_root(__file__, 'macros') GLOBAL_MACRO_ROOT = templating.get_template_root(__file__, '../global_macros') @classmethod def _from_node_query(cls, server: 's.Server', parent: NodeObject, **kwargs) -> 'Collation': """ Creates a Collation object from the results of a node query :param server: Server that owns the collation :param parent: Parent object of this object :param kwargs: A row from the node query Kwargs: oid int: Object ID of the collation name str: Name of the collation :return: A Collation instance """ collation = cls(server, parent, kwargs['name']) collation._oid = kwargs['oid'] collation._schema = kwargs['schema'] collation._scid = kwargs['schemaoid'] collation._is_system = kwargs['is_system'] return collation def __init__(self, server: 's.Server', parent: NodeObject, name: str): NodeObject.__init__(self, server, parent, name) ScriptableCreate.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableDelete.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableUpdate.__init__(self, self._template_root(server), self._macro_root(), server.version) self._schema: str = None self._scid: int = None # PROPERTIES ########################################################### @property def schema(self): return self._schema @property def scid(self): return self._scid # -FULL OBJECT PROPERTIES ############################################## @property def owner(self): return self._full_properties.get("owner", "") @property def description(self): return self._full_properties.get("description", "") @property def lc_collate(self): return self._full_properties.get("lc_collate", "") @property def lc_type(self): return self._full_properties.get("lc_type", "") @property def locale(self): return self._full_properties.get("locale", "") @property def copy_collation(self): return self._full_properties.get("copy_collation", "") @property def cascade(self): return self._full_properties.get("cascade", "") # IMPLEMENTATION DETAILS ############################################### @classmethod def _template_root(cls, server: 's.Server') -> str: return cls.TEMPLATE_ROOT @classmethod def _macro_root(cls) -> List[str]: return [cls.MACRO_ROOT, cls.GLOBAL_MACRO_ROOT] def _create_query_data(self) -> dict: """ Provides data input for create script """ return {"data": { "name": self.name, "pronamespace": self.schema, "owner": self.owner, "schema": self.schema, "description": self.description, "lc_collate": self.lc_collate, "lc_type": self.lc_type, "locale": self.locale, "copy_collation": self.copy_collation }} def _delete_query_data(self) -> dict: """ Provides data input for delete script """ return { "data": { "name": self.name, "schema": self.schema }, "cascade": self.cascade } def _update_query_data(self) -> dict: """ Provides data input for update script """ return { "data": { "name": self.name, "owner": self.owner, "description": self.description, "schema": self.schema }, "o_data": { "name": "", "owner": "", "description": "", "schema": "" } }
class Table(NodeObject, ScriptableCreate, ScriptableDelete, ScriptableUpdate, ScriptableSelect): TEMPLATE_ROOT = templating.get_template_root(__file__, 'templates') MACRO_ROOT = templating.get_template_root(__file__, 'macros') GLOBAL_MACRO_ROOT = templating.get_template_root(__file__, '../global_macros') @classmethod def _from_node_query(cls, server: 's.Server', parent: NodeObject, **kwargs) -> 'Table': """ Creates a table instance from the results of a node query :param server: Server that owns the table :param parent: Parent object of the table. Should be a Schema :param kwargs: A row from the node query Kwargs: oid int: Object ID of the table name str: Name of the table :return: A table instance """ table = cls(server, parent, kwargs['name']) table._oid = kwargs['oid'] table._schema = kwargs['schema'] table._scid = kwargs['schemaoid'] table._is_system = kwargs['is_system'] return table def __init__(self, server: 's.Server', parent: NodeObject, name: str): NodeObject.__init__(self, server, parent, name) ScriptableCreate.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableDelete.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableUpdate.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableSelect.__init__(self, self._template_root(server), self._macro_root(), server.version) self._schema: str = None self._scid: int = None # Declare child items self._check_constraints: NodeCollection[ CheckConstraint] = self._register_child_collection(CheckConstraint) self._columns: NodeCollection[ Column] = self._register_child_collection(Column) self._exclusion_constraints: NodeCollection[ ExclusionConstraint] = self._register_child_collection( ExclusionConstraint) self._foreign_key_constraints: NodeCollection[ ForeignKeyConstraint] = self._register_child_collection( ForeignKeyConstraint) self._index_constraints: NodeCollection[ IndexConstraint] = self._register_child_collection(IndexConstraint) self._indexes: NodeCollection[Index] = self._register_child_collection( Index) self._rules: NodeCollection[Rule] = self._register_child_collection( Rule) self._triggers: NodeCollection[ Trigger] = self._register_child_collection(Trigger) # PROPERTIES ########################################################### @property def schema(self): return self._schema @property def scid(self): return self._scid @property def extended_vars(self): template_vars = { 'scid': self.scid, 'did': self.parent.oid, 'datlastsysoid': 0 # temporary until implemented } return template_vars # -CHILD OBJECTS ####################################################### @property def check_constraints(self) -> NodeCollection[CheckConstraint]: return self._check_constraints @property def columns(self) -> NodeCollection: return self._columns @property def exclusion_constraints(self) -> NodeCollection[ExclusionConstraint]: return self._exclusion_constraints @property def foreign_key_constraints(self) -> NodeCollection[ForeignKeyConstraint]: return self._foreign_key_constraints @property def index_constraints(self) -> NodeCollection[IndexConstraint]: return self._index_constraints @property def indexes(self) -> NodeCollection[Index]: return self._indexes @property def rules(self) -> NodeCollection[Rule]: return self._rules @property def triggers(self) -> NodeCollection[Trigger]: return self._triggers # -FULL OBJECT PROPERTIES ############################################## @property def spcoid(self): return self._full_properties.get("spcoid", "") @property def relacl_str(self): return self._full_properties.get("relacl_str", "") @property def relhasoids(self): return self._full_properties.get("relhasoids", "") @property def relhassubclass(self): return self._full_properties.get("relhassubclass", "") @property def reltuples(self): return self._full_properties.get("reltuples", "") @property def conname(self): return self._full_properties.get("conname", "") @property def conkey(self): return self._full_properties.get("conkey", "") @property def isrepl(self): return self._full_properties.get("isrepl", "") @property def triggercount(self): return self._full_properties.get("triggercount", "") @property def coll_inherits(self): return self._full_properties.get("coll_inherits", "") @property def inherited_tables_cnt(self): return self._full_properties.get("inherited_tables_cnt", "") @property def relpersistence(self): return self._full_properties.get("relpersistence", "") @property def autovacuum_vacuum_threshold(self): return self._full_properties.get("autovacuum_vacuum_threshold", "") @property def autovacuum_vacuum_scale_factor(self): return self._full_properties.get("autovacuum_vacuum_scale_factor", "") @property def autovacuum_analyze_threshold(self): return self._full_properties.get("autovacuum_analyze_threshold", "") @property def autovacuum_analyze_scale_factor(self): return self._full_properties.get("autovacuum_analyze_scale_factor", "") @property def autovacuum_vacuum_cost_delay(self): return self._full_properties.get("autovacuum_vacuum_cost_delay", "") @property def autovacuum_vacuum_cost_limit(self): return self._full_properties.get("autovacuum_vacuum_cost_limit", "") @property def autovacuum_freeze_min_age(self): return self._full_properties.get("autovacuum_freeze_min_age", "") @property def autovacuum_freeze_max_age(self): return self._full_properties.get("autovacuum_freeze_max_age", "") @property def autovacuum_freeze_table_age(self): return self._full_properties.get("autovacuum_freeze_table_age", "") @property def toast_autovacuum_vacuum_threshold(self): return self._full_properties.get("toast_autovacuum_vacuum_threshold", "") @property def toast_autovacuum_vacuum_scale_factor(self): return self._full_properties.get( "toast_autovacuum_vacuum_scale_factor", "") @property def toast_autovacuum_analyze_threshold(self): return self._full_properties.get("toast_autovacuum_analyze_threshold", "") @property def toast_autovacuum_analyze_scale_factor(self): return self._full_properties.get( "toast_autovacuum_analyze_scale_factor", "") @property def toast_autovacuum_vacuum_cost_delay(self): return self._full_properties.get("toast_autovacuum_vacuum_cost_delay", "") @property def toast_autovacuum_vacuum_cost_limit(self): return self._full_properties.get("toast_autovacuum_vacuum_cost_limit", "") @property def toast_autovacuum_freeze_min_age(self): return self._full_properties.get("toast_autovacuum_freeze_min_age", "") @property def toast_autovacuum_freeze_max_age(self): return self._full_properties.get("toast_autovacuum_freeze_max_age", "") @property def toast_autovacuum_freeze_table_age(self): return self._full_properties.get("toast_autovacuum_freeze_table_age", "") @property def table_vacuum_settings_str(self): return self._full_properties.get("table_vacuum_settings_str", "") @property def toast_table_vacuum_settings_str(self): return self._full_properties.get("toast_table_vacuum_settings_str", "") @property def reloptions(self): return self._full_properties.get("reloptions", "") @property def toast_reloptions(self): return self._full_properties.get("toast_reloptions", "") @property def reloftype(self): return self._full_properties.get("reloftype", "") @property def typname(self): return self._full_properties.get("typname", "") @property def hastoasttable(self): return self._full_properties.get("hastoasttable", "") @property def like_relation(self): return f'{self.schema}.{self.name}' @property def primary_key(self): return self._full_properties.get("primary_key", "") @property def unique_constraint(self): return self._full_properties.get("unique_constraint", "") @property def foreign_key(self): return self._full_properties.get("foreign_key", "") @property def check_constraint(self): return self._full_properties.get("check_constraint", "") @property def exclude_constraint(self): return self._full_properties.get("exclude_constraint", "") @property def fillfactor(self): return self._full_properties.get("fillfactor", "") @property def spcname(self): return self._full_properties.get("spcname", "") @property def relowner(self): return self._full_properties.get("relowner", "") @property def cascade(self): return self._full_properties.get("cascade", "") @property def coll_inherits_added(self): return self._full_properties.get("coll_inherits_added", "") @property def coll_inherits_removed(self): return self._full_properties.get("coll_inherits_removed", "") @property def autovacuum_custom(self): return self._full_properties.get("autovacuum_custom", "") @property def autovacuum_enabled(self): return self._full_properties.get("autovacuum_enabled", "") @property def vacuum_table(self): return self._full_properties.get("vacuum_table", "") @property def toast_autovacuum(self): return self._full_properties.get("toast_autovacuum", "") @property def toast_autovacuum_enabled(self): return self._full_properties.get("toast_autovacuum_enabled", "") @property def vacuum_toast(self): return self._full_properties.get("vacuum_toast", "") @property def description(self): return self._full_properties.get("description", "") @property def acl(self): return self._full_properties.get("acl", "") @property def seclabels(self): return self._full_properties.get("seclabels", "") @property def hasoids(self): return self._full_properties.get("hasoids", "") @property def is_sys_table(self): return self._full_properties.get("is_sys_table", "") # IMPLEMENTATION DETAILS ############################################### @classmethod def _macro_root(cls) -> List[str]: return [cls.MACRO_ROOT, cls.GLOBAL_MACRO_ROOT] @classmethod def _template_root(cls, server: 's.Server') -> str: return cls.TEMPLATE_ROOT def _create_query_data(self) -> dict: """ Provides data input for create script """ return { "data": { "name": self.name, "coll_inherits": self.coll_inherits, "columns": self.columns, "typname": self.typname, "primary_key": self.primary_key, "unique_constraint": self.unique_constraint, "foreign_key": self.foreign_key, "check_constraint": self.check_constraint, "exclude_constraint": self.exclude_constraint, "relpersistence": self.relpersistence, "relhasoids": self.relhasoids, "fillfactor": self.fillfactor, "autovacuum_custom": self.autovacuum_custom, "autovacuum_enabled": self.autovacuum_enabled, "toast_autovacuum": self.toast_autovacuum, "toast_autovacuum_enabled": self.toast_autovacuum_enabled, "autovacuum_analyze_scale_factor": self.autovacuum_analyze_scale_factor, "autovacuum_analyze_threshold": self.autovacuum_analyze_threshold, "autovacuum_freeze_max_age": self.autovacuum_freeze_max_age, "autovacuum_vacuum_cost_delay": self.autovacuum_vacuum_cost_delay, "autovacuum_vacuum_cost_limit": self.autovacuum_vacuum_cost_limit, "autovacuum_vacuum_scale_factor": self.autovacuum_vacuum_scale_factor, "autovacuum_vacuum_threshold": self.autovacuum_vacuum_threshold, "autovacuum_freeze_min_age": self.autovacuum_freeze_min_age, "autovacuum_freeze_table_age": self.autovacuum_freeze_table_age, "spcname": self.spcname, "relowner": self.relowner, "schema": self.schema } } def _delete_query_data(self) -> dict: """ Provides data input for delete script """ return { "data": { "name": self.name, "schema": self.schema }, "cascade": self.cascade } def _update_query_data(self) -> dict: """ Provides data input for update script """ return { "data": { "name": self.name, "schema": self.schema, "relowner": self.relowner, "coll_inherits_added": self.coll_inherits_added, "coll_inherits_removed": self.coll_inherits_removed, "relhasoids": self.hasoids, "spcname": self.spcname, "fillfactor": self.fillfactor, "autovacuum_custom": self.autovacuum_custom, "autovacuum_enabled": self.autovacuum_enabled, "vacuum_table.changed": self.vacuum_table.changed, "toast_autovacuum": self.toast_autovacuum, "toast_autovacuum_enabled": self.toast_autovacuum_enabled, "vacuum_toast.changed": self.vacuum_toast.changed, "description": self.description, "relacl": self.acl, "seclabels": self.seclabels } } def _select_query_data(self) -> dict: """Provides data input for select script""" return { "data": { "name": self.name, "schema": self.schema, "columns": self.columns } }
class Database(NodeObject, ScriptableCreate, ScriptableDelete): TEMPLATE_ROOT = templating.get_template_root(__file__, 'templates') @classmethod def _from_node_query(cls, server: 's.Server', parent: None, **kwargs) -> 'Database': """ Creates a new Database object based on the results from a query to lookup databases :param server: Server that owns the database :param parent: Parent object of the database. Should always be None :param kwargs: Optional parameters for the database. Values that can be provided: Kwargs: oid int: Object ID of the database name str: Name of the database spcname str: Name of the tablespace for the database datallowconn bool: Whether or not the database can be connected to cancreate bool: Whether or not the database can be created by the current user owner int: Object ID of the user that owns the database datistemplate bool: Whether or not the database is a template database canconnect bool: Whether or not the database is accessbile to current user :return: Instance of the Database """ db = cls(server, kwargs['name']) db._oid = kwargs['oid'] db._tablespace = kwargs['spcname'] db._allow_conn = kwargs['datallowconn'] db._can_create = kwargs['cancreate'] db._owner_oid = kwargs['owner'] db._is_template = kwargs['datistemplate'] db._can_connect = kwargs['canconnect'] db._is_system = kwargs['is_system'] db._datlastsysoid = kwargs['datlastsysoid'] return db def __init__(self, server: 's.Server', name: str): """ Initializes a new instance of a database """ NodeObject.__init__(self, server, None, name) ScriptableCreate.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableDelete.__init__(self, self._template_root(server), self._macro_root(), server.version) # Declare the optional parameters self._tablespace: Optional[str] = None self._allow_conn: Optional[bool] = None self._is_template: Optional[bool] = None self._can_connect: Optional[bool] = None self._can_create: Optional[bool] = None self._owner_oid: Optional[int] = None self._connection: ServerConnection = None if server.maintenance_db_name == name: self._connection = server.connection # Declare the child items self._schemas = self._register_child_collection(Schema) self._tables: NodeCollection = self._register_child_collection(Table) self._views: NodeCollection = self._register_child_collection(View) self._collations: NodeCollection = self._register_child_collection(Collation) self._datatypes: NodeCollection = self._register_child_collection(DataType) self._functions: NodeCollection = self._register_child_collection(Function) self._sequences: NodeCollection = self._register_child_collection(Sequence) self._trigger_functions: NodeCollection = self._register_child_collection(TriggerFunction) self._extensions: NodeCollection = self._register_child_collection(Extension) self._materialized_views: NodeCollection = self._register_child_collection(MaterializedView) # PROPERTIES ########################################################### # -BASIC PROPERTIES #################################################### @property def allow_conn(self) -> bool: return self._allow_conn @property def connection(self) -> ServerConnection: if self._connection is not None: return self._connection else: connection = ServerConnection(self._server.db_connection_callback(self.name)) if connection.dsn_parameters['dbname'] == self.name: self._connection = connection return self._connection else: raise ValueError('connection create for wrong database') @property def is_template(self) -> bool: return self._is_template @property def can_connect(self) -> bool: return self._can_connect @property def can_create(self) -> bool: return self._can_create @property def tablespace(self) -> str: return self._tablespace # -FULL OBJECT PROPERTIES ############################################## @property def spcoid(self) -> str: return self._full_properties.get("spcoid", "") @property def datowner(self) -> str: return self._full_properties.get("datowner", "") @property def encoding(self) -> str: return self._full_properties.get("encoding", "") @property def template(self) -> str: return self._full_properties.get("template", "") @property def datcollate(self): return self._full_properties.get("datcollate", "") @property def datctype(self): return self._full_properties.get("datctype", "") @property def spcname(self): return self._full_properties.get("spcname", "") @property def datconnlimit(self): return self._full_properties.get("datconnlimit", "") @property def default_tablespace(self): return self._full_properties.get("default_tablespace", "") @property def comments(self): return self._full_properties.get("comments", "") @property def tblacl(self): return self._full_properties.get("tblacl", "") @property def seqacl(self): return self._full_properties.get("seqacl", "") @property def funcacl(self): return self._full_properties.get("funcacl", "") @property def typeacl(self): return self._full_properties.get("typeacl", "") @property def seclabels(self): return self._full_properties.get("seclabels", "") @property def acl(self): return self._full_properties.get("acl", "") # -CHILD OBJECTS ####################################################### @property def schemas(self) -> NodeCollection[Schema]: return self._schemas @property def collations(self) -> NodeCollection: return self._collations @property def datatypes(self) -> NodeCollection: return self._datatypes @property def functions(self) -> NodeCollection: return self._functions @property def sequences(self) -> NodeCollection: return self._sequences @property def tables(self) -> NodeCollection: return self._tables @property def trigger_functions(self) -> NodeCollection: return self._trigger_functions @property def views(self) -> NodeCollection: return self._views @property def materialized_views(self) -> NodeCollection: return self._materialized_views @property def extensions(self) -> NodeCollection: return self._extensions @property def datlastsysoid(self) -> int: return self._datlastsysoid # IMPLEMENTATION DETAILS ############################################### @classmethod def _template_root(cls, server: 's.Server') -> str: return cls.TEMPLATE_ROOT def _create_query_data(self) -> dict: """ Return the data input for create query """ return {"data": { "name": self.name, "datowner": self.datowner, "encoding": self.encoding, "template": self.template, "datcollate": self.datcollate, "datctype": self.datctype, "datconnlimit": self.datconnlimit, "spcname": self.spcname }} def _delete_query_data(self) -> dict: """ Return the data input for delete query """ return { "did": self._oid, "datname": self._name }
class Rule(NodeObject, ScriptableCreate, ScriptableDelete, ScriptableUpdate): TEMPLATE_ROOT = templating.get_template_root(__file__, 'rule') @classmethod def _from_node_query(cls, server: 's.Server', parent: NodeObject, **kwargs) -> 'Rule': """ Creates a new Rule object based on the results of a nodes query :param server: Server that owns the rule :param parent: Parent object of the rule. Should be Table/View :param kwargs: Parameters for the rule Kwargs: name str: The name of the rule oid int: Object ID of the rule :return: Instance of the rule """ idx = cls(server, parent, kwargs['name']) idx._oid = kwargs['oid'] return idx def __init__(self, server: 's.Server', parent: NodeObject, name: str): """ Initializes a new instance of an rule :param server: Server that owns the rule :param parent: Parent object of the rule. Should be Table/View :param name: Name of the rule """ NodeObject.__init__(self, server, parent, name) ScriptableCreate.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableDelete.__init__(self, self._template_root(server), self._macro_root(), server.version) ScriptableUpdate.__init__(self, self._template_root(server), self._macro_root(), server.version) # PROPERTIES ########################################################### @property def view(self): return self._full_properties["view"] @property def event(self): return self._full_properties["event"] @property def condition(self): return self._full_properties["condition"] @property def do_instead(self): return self._full_properties["do_instead"] @property def statements(self): return self._full_properties["statements"] @property def comment(self): return self._full_properties["comment"] @property def display_comments(self): return self._full_properties["display_comments"] @property def rid(self): return self._full_properties["rid"] @property def rulename(self): return self._full_properties["rulename"] # IMPLEMENTATION DETAILS ############################################### @classmethod def _template_root(cls, server: 's.Server') -> str: return cls.TEMPLATE_ROOT def _create_query_data(self) -> dict: """ Provides data input for create script """ return { "data": { "name": self.name, "schema": self.parent.schema, "view": self.view, "event": self.event, "condition": self.condition, "do_instead": self.do_instead, "statements": self.statements, "comment": self.comment }, "display_comments": self.display_comments } def _delete_query_data(self) -> dict: """ Provides data input for delete script """ return { "rid": self.rid, "rulename": self.rulename, "relname": self.parent.name, "nspname": self.parent.schema } def _update_query_data(self) -> dict: """ Function that returns data for update script """ return { "data": { "name": self.name, "event": self.event, "do_instead": self.do_instead, "condition": self.condition, "statements": self.statements, "comment": self.comment }, "o_data": { "name": "", "schema": "", "view": "", "condition": "", "do_instead": "", "statements": "" } }