class PrimaryKeyConstraint(NodeObject):
TEMPLATE_ROOT = templating.get_template_root(__file__, 'primary_key')
@classmethod
def _from_node_query(cls, server: 's.Server', parent: None,
**kwargs) -> 'PrimaryKeyConstraint':
"""
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
"""
primary = cls(server, kwargs["name"])
return primary
def __init__(self, server: 's.Server', name: str):
"""
Initializes a new instance of a database
"""
NodeObject.__init__(self, server, None, name)
@classmethod
def _template_root(cls, server: 's.Server') -> str:
return cls.TEMPLATE_ROOT
class Function(FunctionBase):
TEMPLATE_ROOT = templating.get_template_root(__file__,
'templates_functions')
@classmethod
def _template_root(cls, server: 's.Server'):
return os.path.join(cls.TEMPLATE_ROOT, server.server_type)
class CheckConstraint(Constraint):
TEMPLATE_ROOT = templating.get_template_root(__file__, 'constraint_check')
# -FULL OBJECT PROPERTIES ##############################################
@property
def src(self):
return self._full_properties["src"]
@property
def no_inherit(self):
return self._full_properties["no_inherit"]
# 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": {
"schema": self.parent.schema,
"table": self.parent.name,
"name": self.name,
"consrc": self.src,
"comment": self.comment,
"connoinherit": self.no_inherit,
"convalidated": self.convalidated
}
}
def _delete_query_data(self) -> dict:
""" Provides data input for delete script """
return {
"data": {
"name": self.name,
"nspname": self.parent.parent.name,
"relname": self.parent.name
}
}
def _update_query_data(self) -> dict:
""" Function that returns data for update script """
return {
"data": {
"comment": self.comment,
"name": self.name,
"table": self.parent.name,
"convalidated": self.convalidated
},
"o_data": {
"comment": "",
"name": "",
"nspname": "",
"relname": "",
"convalidated": ""
}
}
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["Database"])
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(self.server), self._macro_root(), self.server.version)
ScriptableDelete.__init__(self, self._template_root(self.server), self._macro_root(), self.server.version)
# 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 """
def _delete_query_data(self) -> dict:
""" Return the data input for delete query """
return {
"dbname": self._name
}
# -CHILD OBJECTS #######################################################
@property
def schemas(self) -> NodeCollection['Schema']:
# TODO: add Schema mysqlsmo
return []
class UserDefinedFunction(NodeObject, ScriptableCreate, ScriptableDelete):
TEMPLATE_ROOT = templating.get_template_root(__file__, 'templates')
@classmethod
def _from_node_query(cls, server: 's.Server', parent: None,
**kwargs) -> 'UserDefinedFunction':
"""
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
"""
udf = cls(server, kwargs["name"])
udf._soname = kwargs["soname"]
udf._return_type = kwargs["return_type"]
return udf
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(self.server),
self._macro_root(), self.server.version)
ScriptableDelete.__init__(self, self._template_root(self.server),
self._macro_root(), self.server.version)
@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 {
"fn_name": self._name,
"dl": self._soname,
"ret": self._return_type
}
def _delete_query_data(self) -> dict:
""" Return the data input for delete query """
return {"fn_name": self._name}
class MaterializedView(ViewBase):
TEMPLATE_ROOT = templating.get_template_root(
__file__, 'materialized_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) -> None:
ViewBase.__init__(self, server, parent, name)
self._indexes: NodeCollection[Index] = self._register_child_collection(
Index)
@property
def indexes(self) -> NodeCollection[Index]:
return self._indexes
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 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 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": ""
}
}
from pgsmo.objects.server import server as s # noqa
import smo.utils.templating as templating
GET_INDEX_CONSTRAINT_TEMPLATE_ROOT = templating.get_template_root(__file__, 'constraint_index')
GET_FOREIGN_CONSTRAINT_TEMPLATE_ROOT = templating.get_template_root(__file__, 'constraint_fk')
GET_CHECK_CONSTRAINT_TEMPLATE_ROOT = templating.get_template_root(__file__, 'constraint_check')
GET_EXCLUSION_CONSTRAINT_TEMPLATE_ROOT = templating.get_template_root(__file__, 'constraint_exclusion')
def get_index_constraints(server, did, tid, ctype, cid=None) -> (dict):
server_version = server.connection.server_version
sql = templating.render_template(
templating.get_template_path(GET_INDEX_CONSTRAINT_TEMPLATE_ROOT, 'properties.sql', server_version),
macro_roots=None,
did=did, tid=tid, cid=cid, constraint_type=ctype
)
result = server.connection.execute_dict(sql)
for idx_cons in result[1]:
sql = templating.render_template(
templating.get_template_path(
GET_INDEX_CONSTRAINT_TEMPLATE_ROOT,
'get_constraint_cols.sql',
server_version),
macro_roots=None,
cid=idx_cons['oid'],
colcnt=idx_cons['col_count'])
constraint_cols = server.connection.execute_dict(sql)
class ForeignKeyConstraint(Constraint):
TEMPLATE_ROOT = templating.get_template_root(__file__, 'constraint_fk')
# -FULL OBJECT PROPERTIES ##############################################
@property
def columns(self):
return self._full_properties["columns"]
@property
def remote_schema(self):
return self._full_properties["remote_schema"]
@property
def remote_table(self):
return self._full_properties["remote_table"]
@property
def fmatchtype(self):
return self._full_properties["fmatchtype"]
@property
def fupdtype(self):
return self._full_properties["fupdtype"]
@property
def fdeltype(self):
return self._full_properties["fdeltype"]
@property
def deferrable(self):
return self._full_properties["deferrable"]
@property
def deferred(self):
return self._full_properties["deferred"]
@property
def cascade(self):
return self._full_properties["cascade"]
# 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": {
"schema": self.parent.schema,
"table": self.parent.name,
"name": self.name,
"columns": self.columns,
"remote_schema": self.remote_schema,
"remote_table": self.remote_table,
"confmatchtype": self.fmatchtype,
"confupdtype": self.fupdtype,
"confdeltype": self.fdeltype,
"condeferrable": self.deferrable,
"condeferred": self.deferred,
"convalidated": self.convalidated,
"comment": self.comment
}
}
def _delete_query_data(self) -> dict:
""" Provides data input for delete script """
return {
"data": {
"schema": self.parent.schema,
"table": self.parent.name,
"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,
"table": self.parent.name,
"convalidated": self.convalidated,
"comment": self.comment
},
"o_data": {
"name": "",
"convalidated": "",
"comment": ""
}
}
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
isprimarykey bool: Whether or not the column is primary key
is_updatable bool: Whether or not the column is updatable or read only
isunique bool: Whether or not the column only accepts unique value or not
default: default value for the column
: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
"""
self._server = server
self._parent: Optional['NodeObject'] = parent
self._name: str = name
self._oid: Optional[int] = None
self._is_system: bool = False
self._child_collections: Dict[str, NodeCollection] = {}
self._property_collections: List[NodeLazyPropertyCollection] = []
# Use _column_property_generator instead of _property_generator
self._full_properties: NodeLazyPropertyCollection = self._register_property_collection(self._column_property_generator)
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
def _column_property_generator(self):
template_root = self._template_root(self._server)
# Setup the parameters for the query
template_vars = self.template_vars
# Render and execute the template
sql = templating.render_template(
templating.get_template_path(template_root, 'properties.sql', self._server.version),
self._macro_root(),
**template_vars
)
cols, rows = self._server.connection.execute_dict(sql)
for row in rows:
if row['name'] == self._name:
return row
# 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 attidentity(self):
return self._full_properties["attidentity"]
@property
def colconstype(self):
return self._full_properties["colconstype"]
@property
def seqcache(self):
return self._full_properties["seqcache"]
@property
def seqcycle(self):
return self._full_properties["seqcycle"]
@property
def seqincrement(self):
return self._full_properties["seqincrement"]
@property
def seqmax(self):
return self._full_properties["seqmax"]
@property
def seqmin(self):
return self._full_properties["seqmin"]
@property
def seqrelid(self):
return self._full_properties["seqrelid"]
@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 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 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):
self._server = server
self._parent: Optional['NodeObject'] = parent
self._name: str = name
self._oid: Optional[int] = None
self._is_system: bool = False
self._child_collections: Dict[str, NodeCollection] = {}
self._property_collections: List[NodeLazyPropertyCollection] = []
# Use _column_property_generator instead of _property_generator
self._full_properties: NodeLazyPropertyCollection = self._register_property_collection(
self._sequence_property_generator)
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
self._def: dict = None
def _sequence_property_generator(self):
template_root = self._template_root(self._server)
# Setup the parameters for the query
template_vars = self.template_vars
# Render and execute the template
sql = templating.render_template(
templating.get_template_path(template_root, 'properties.sql',
self._server.version),
self._macro_root(), **template_vars)
cols, rows = self._server.connection.execute_dict(sql)
if len(rows) > 0:
return rows[0]
# 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 smo.common.node_object import NodeObject, NodeLazyPropertyCollection # noqa
from smo.common.scripting_mixins import ScriptableCreate, ScriptableDelete, ScriptableUpdate
from pgsmo.objects.server import server as s # noqa
import smo.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 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 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:
# If we do not have a connection to the db, we create a new one
connection: ServerConnection = self._server.db_connection_callback(
self.name)
if connection.database_name == 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 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 IndexConstraint(Constraint):
TEMPLATE_ROOT = templating.get_template_root(__file__, 'constraint_index')
# -FULL OBJECT PROPERTIES ##############################################
@property
def index(self):
return self._full_properties["index"]
@property
def fillfactor(self):
return self._full_properties["fillfactor"]
@property
def spcname(self):
return self._full_properties["spcname"]
@property
def deferrable(self):
return self._full_properties["deferrable"]
@property
def deferred(self):
return self._full_properties["deferred"]
@property
def cascade(self):
return self._full_properties["cascade"]
# 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": {
"schema": self.parent.schema,
"table": self.parent.name,
"name": self.name,
"index": self.index,
"fillfactor": self.fillfactor,
"spcname": self.spcname,
"condeferrable": self.deferrable,
"condeferred": self.deferred,
"comment": self.comment
}
}
def _delete_query_data(self) -> dict:
""" Provides data input for delete script """
return {
"data": {
"schema": self.parent.schema,
"table": self.parent.name,
"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,
"table": self.parent.name,
"spcname": self.spcname,
"fillfactor": self.fillfactor,
"comment": self.comment
},
"o_data": {
"name": "",
"spcname": "",
"fillfactor": "",
"comment": ""
}
}
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 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 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": ""
}
}
class Function(NodeObject, ScriptableCreate, ScriptableDelete):
TEMPLATE_ROOT = templating.get_template_root(__file__, 'templates')
@classmethod
def _from_node_query(cls, server: 's.Server', parent: None,
**kwargs) -> 'Function':
"""
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
"""
func = cls(server, kwargs["name"], kwargs["dbname"])
return func
def __init__(self, server: 's.Server', name: str, dbname: str):
"""
Initializes a new instance of a database
"""
NodeObject.__init__(self, server, None, name)
ScriptableCreate.__init__(self, self._template_root(self.server),
self._macro_root(), self.server.version)
ScriptableDelete.__init__(self, self._template_root(self.server),
self._macro_root(), self.server.version)
self._dbname = dbname
self._server_version = server.version
@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 {"dbname": self._dbname, "fn_name": self._name}
def _delete_query_data(self) -> dict:
""" Return the data input for delete query """
return {"dbname": self._dbname, "fn_name": self._name}
def create_script(self):
"""Generates a script that creates an object of the inheriting type"""
data = self._create_query_data()
template_root = self._template_root(self._server)
sql = templating.render_template(templating.get_template_path(
template_root, 'create.sql', self._server_version),
macro_roots=self._macro_root(),
**data)
cols, rows = self._server.connection.execute_dict(sql)
script = rows[0]["Create Function"]
return script
class Table(NodeObject, ScriptableCreate, ScriptableDelete, ScriptableSelect):
TEMPLATE_ROOT = templating.get_template_root(__file__, 'templates')
@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, kwargs["name"], kwargs["dbname"])
return table
def __init__(self, server: 's.Server', name: str, dbname: str):
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)
ScriptableSelect.__init__(self, self._template_root(server),
self._macro_root(), server.version)
self._dbname = dbname
self._server = server
self._server_version = server.version
# PROPERTIES ###########################################################
@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 {"dbname": self._dbname, "tbl_name": self._name}
def _delete_query_data(self) -> dict:
""" Provides data input for delete script """
return {"dbname": self._dbname, "tbl_name": self._name}
def _select_query_data(self) -> dict:
"""Provides data input for select script"""
return {"dbname": self._dbname, "tbl_name": self._name}
def create_script(self):
"""Generates a script that creates an object of the inheriting type"""
data = self._create_query_data()
template_root = self._template_root(self._server)
sql = templating.render_template(templating.get_template_path(
template_root, 'create.sql', self._server_version),
macro_roots=self._macro_root(),
**data)
cols, rows = self._server.connection.execute_dict(sql)
try:
script = rows[0]["Create Table"]
except Exception:
script = rows[0]["Create View"]
return script
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 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 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
}
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
}
