holado 0.13.22__py3-none-any.whl

holado_db/tests/behave/steps/tools/db/postgresql_client_steps.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+
+from holado.common.context.session_context import SessionContext
+from holado_test.behave.behave import *  # @UnusedWildImport
+from holado_scripting.text.interpreter.text_interpreter import TextInterpreter
+from holado_scripting.common.tools.variable_manager import VariableManager
+from holado_test.common.context.scenario_context import ScenarioContext
+import logging
+from holado_db.tools.db.clients.postgresql.postgresql_client import PostgreSQLClient
+from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
+from holado_value.common.tables.converters.value_table_converter import ValueTableConverter
+from holado_test.scenario.step_tools import StepTools
+
+logger = logging.getLogger(__name__)
+
+
+
+def __get_session_context() -> SessionContext:
+    return SessionContext.instance()
+
+def __get_scenario_context() -> ScenarioContext:
+    return __get_session_context().get_scenario_context()
+
+def __get_text_interpreter() -> TextInterpreter:
+    return __get_scenario_context().get_text_interpreter()
+
+def __get_variable_manager() -> VariableManager:
+    return __get_scenario_context().get_variable_manager()
+
+
+
+if PostgreSQLClient.is_available():
+
+    @Given(r"(?P<var_name>{Variable}) = new PostreSQL client")
+    def step_impl(context, var_name):
+        var_name = StepTools.evaluate_variable_name(var_name)
+        table = BehaveStepTools.convert_step_table_2_value_table_with_header(context.table)
+        kwargs = ValueTableConverter.convert_name_value_table_2_dict(table)
+        
+        client = __get_session_context().db_manager.new_client("postgresql", "postgresql", kwargs)
+        client.connect()
+        
+        __get_variable_manager().register_variable(var_name, client)
+
+
+

holado_db/tests/behave/steps/tools/db/sqlite_client_steps.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+
+from holado.common.context.session_context import SessionContext
+from holado_test.behave.behave import *  # @UnusedWildImport
+from holado_scripting.text.interpreter.text_interpreter import TextInterpreter
+from holado_scripting.common.tools.variable_manager import VariableManager
+from holado_test.common.context.scenario_context import ScenarioContext
+import logging
+from holado_db.tools.db.clients.sqlite.sqlite_client import SQLite3Client
+from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
+from holado_value.common.tables.converters.value_table_converter import ValueTableConverter
+from holado_test.scenario.step_tools import StepTools
+
+logger = logging.getLogger(__name__)
+
+
+
+def __get_session_context() -> SessionContext:
+    return SessionContext.instance()
+
+def __get_scenario_context() -> ScenarioContext:
+    return __get_session_context().get_scenario_context()
+
+def __get_text_interpreter() -> TextInterpreter:
+    return __get_scenario_context().get_text_interpreter()
+
+def __get_variable_manager() -> VariableManager:
+    return __get_scenario_context().get_variable_manager()
+
+
+
+if SQLite3Client.is_available():
+
+    @Given(r"(?P<var_name>{Variable}) = new SQLite3 client")
+    def step_impl(context, var_name):
+        var_name = StepTools.evaluate_variable_name(var_name)
+        table = BehaveStepTools.convert_step_table_2_value_table_with_header(context.table)
+        kwargs = ValueTableConverter.convert_name_value_table_2_dict(table)
+        
+        client = __get_session_context().db_manager.new_client("sqlite3", "sqlite3", kwargs)
+        client.connect()
+        
+        __get_variable_manager().register_variable(var_name, client)
+

holado_db/tools/db/clients/base/db_audit.py

@@ -0,0 +1,94 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2023 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+import logging
+from holado.common.handlers.object import Object
+import abc
+from holado.common.handlers.undefined import default_value, any_value
+
+logger = logging.getLogger(__name__)
+
+
+class DBAuditManager(Object):
+    """Base class for audit managers.
+    """
+    __metaclass__ = abc.ABCMeta
+
+    def __init__(self, name, db_client):
+        super().__init__(name)
+        
+        self.__db_client = db_client
+    
+    @property
+    def _db_client(self):
+        return self.__db_client
+    
+    def audit_table(self, table_name, operation_types=any_value, **kwargs):
+        raise NotImplementedError()
+
+    def _get_audit_table_name(self, audit_table_name=default_value):
+        if audit_table_name is default_value:
+            return "_audit"
+        else:
+            return audit_table_name
+
+    def _get_audit_table_sql_create(self, audit_table_name=default_value):
+        raise NotImplementedError()
+    
+    def ensure_audit_table_exists(self, audit_table_name=default_value):
+        audit_table_name = self._get_audit_table_name(audit_table_name)
+        create_sql = self._get_audit_table_sql_create(audit_table_name=audit_table_name)
+        self._db_client.create_table(audit_table_name, create_sql, raise_if_exist=False, do_commit=True, do_audit=False)
+    
+
+
+class TriggerAuditManager(DBAuditManager):
+    def __init__(self, name, db_client):
+        super().__init__(name, db_client)
+    
+    def audit_table(self, table_name, operation_types=any_value, audit_table_name=default_value, **kwargs):
+        self.ensure_audit_table_exists(audit_table_name)
+        
+        if operation_types is any_value:
+            operation_types = ['insert', 'update', 'delete']
+        else:
+            operation_types = [ot.lower() for ot in operation_types]
+        
+        for op_type in operation_types:
+            self.drop_trigger_of_audit_table_operation(table_name, op_type, audit_table_name, **kwargs)
+            self.create_trigger_to_audit_table_operation(table_name, op_type, audit_table_name, **kwargs)
+    
+    def get_trigger_name(self, table_name, operation_type):
+        return f"audit_{table_name}_on_{operation_type}"
+    
+    def drop_trigger_of_audit_table_operation(self, table_name, operation_type, audit_table_name, **kwargs):
+        drop_sql = self._get_drop_trigger_sql_of_audit_table_operation(table_name, operation_type, audit_table_name)
+        
+        do_commit = kwargs.pop('do_commit', True)
+        self._db_client.execute(drop_sql, do_commit=do_commit, **kwargs)
+    
+    def _get_drop_trigger_sql_of_audit_table_operation(self, table_name, operation_type):
+        raise NotImplementedError()
+    
+    def create_trigger_to_audit_table_operation(self, table_name, operation_type, audit_table_name, **kwargs):
+        create_sql = self._get_create_trigger_sql_to_audit_table_operation(table_name, operation_type, audit_table_name)
+        
+        do_commit = kwargs.pop('do_commit', True)
+        self._db_client.execute(create_sql, do_commit=do_commit, **kwargs)
+    
+    def _get_create_trigger_sql_to_audit_table_operation(self, table_name, operation_type):
+        raise NotImplementedError()
+
+
+
+

holado_db/tools/db/clients/base/db_client.py

@@ -0,0 +1,344 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2023 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+import logging
+from builtins import NotImplementedError
+from holado_core.common.exceptions.functional_exception import FunctionalException
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_core.common.tables.table_with_header import TableWithHeader
+from holado_core.common.tables.table_row import TableRow
+import abc
+from holado_core.common.tools.tools import Tools
+from holado_core.common.tables.table import Table
+from holado_db.tools.db.query.base.query_builder import QueryBuilder
+from holado_data.data.generator.base import BaseGenerator
+from holado_python.standard_library.typing import Typing
+from holado.common.handlers.object import Object
+
+logger = logging.getLogger(__name__)
+
+
+class DBClient(Object):
+    __metaclass__ = abc.ABCMeta
+
+    def __init__(self, name, connect_kwargs, with_cursor=True, auto_commit=True):
+        super().__init__(name)
+        
+        self.__connect_kwargs = connect_kwargs
+        self.__with_cursor = with_cursor
+        self.__auto_commit = auto_commit
+        
+        self.__connection = None
+        self.__query_builder = None
+        self.__audit_manager = None
+        self.__column_names_by_table = {}
+    
+    @property
+    def query_builder(self) -> QueryBuilder:
+        return self.__query_builder
+    
+    @query_builder.setter
+    def query_builder(self, builder):
+        self.__query_builder = builder
+    
+    @property
+    def is_connected(self):
+        return self.__connection is not None
+    
+    @property
+    def connection(self):
+        return self.__connection
+    
+    @property
+    def cursor(self):
+        if not self.__with_cursor:
+            raise TechnicalException(f"DB client '{self.__name}' doesn't manage cursor")
+        return self.__cursor
+    
+    @property
+    def audit_manager(self):
+        if self.__audit_manager is None:
+            self.__audit_manager = self._new_audit_manager()
+        return self.__audit_manager
+    
+    def _new_audit_manager(self):
+        """Create a new audit manager.
+        By default, use a audit manager with a single table of audit for whole DB and with triggers on audited tables.
+        Override this method in order to define which audit manager to use.
+        """
+        raise NotImplementedError()
+    
+    def connect(self):
+        try:
+            self.__connection = self._connect(**self.__connect_kwargs)
+        except Exception as exc:
+            Tools.raise_same_exception_type(exc, f"[{self.name}] Failed to connect with parameters {self.__connect_kwargs}")
+        if self.__with_cursor:
+            self.__cursor = self.__connection.cursor()
+    
+    def _connect(self, **kwargs):
+        raise NotImplementedError()
+    
+    def _verify_is_connected(self):
+        if not self.is_connected:
+            raise FunctionalException(f"DB Client '{self.name}' is not connected")
+    
+    # Manage queries
+    
+    def insert(self, table_name, data: dict, do_commit=None):
+        """
+        Insert given data.
+        Parameter 'data' has to be a dictionary with keys equal to table column names.
+        """
+        query, values = self.query_builder.insert(table_name, data)
+        return self.execute_query(query, *values, do_commit=do_commit)
+    
+    def update(self, table_name, data: dict, where_data: dict=None, where_compare_data: list=None, do_commit=None):
+        """
+        Update given data.
+        Parameters 'data' and 'where_data' have to be dictionaries with keys equal to table column names.
+        """
+        query, values = self.query_builder.update(table_name, data, where_data=where_data, where_compare_data=where_compare_data)
+        return self.execute_query(query, *values, do_commit=do_commit)
+    
+    def select(self, table_name, where_data: dict=None, where_compare_data: list=None, sql_return="*", **kwargs):
+        """
+        Select by filtering on given where data.
+        @param where_data: dictionary of (field_name, value) for simple where clauses.
+        @param where_compare_data: list of tuples (field_name, operator, value) for where clauses comparing fields with values.
+        """
+        query, values = self.query_builder.select(table_name, where_data=where_data, where_compare_data=where_compare_data, sql_return=sql_return)
+        return self.execute_query(query, *values, do_commit=False, **kwargs)
+    
+    def delete(self, table_name, where_data: dict=None, where_compare_data: list=None, do_commit=None):
+        """
+        Delete by filtering on given where data.
+        Parameter 'where_data' has to be a dictionary with keys equal to table column names.
+        """
+        query, values = self.query_builder.delete(table_name, where_data=where_data, where_compare_data=where_compare_data)
+        return self.execute_query(query, *values, do_commit=do_commit)
+    
+    def count(self, table_name, where_data: dict=None, where_compare_data: list=None):
+        result = self.select(table_name, where_data=where_data, where_compare_data=where_compare_data, sql_return="count(*)")
+        return result[0][0].content
+        
+    def execute_query(self, query, *args, **kwargs):
+        sql = self.query_builder.to_sql(query)
+        
+        # Force do_commit to False for select queries
+        do_commit = kwargs.pop('do_commit', None)
+        
+        return self.execute(sql, *args, do_commit=do_commit, **kwargs)
+        
+    def execute(self, sql, *args, **kwargs):
+        # Manage specific parameters
+        if self.is_query_type(sql, 'select'):
+            do_commit = False
+        else:
+            do_commit = kwargs.pop('do_commit', None)
+            if do_commit is None:
+                do_commit = self.__auto_commit
+        result_as_dict_list = kwargs.pop('result_as_dict_list', False)
+        as_generator = kwargs.pop('as_generator', False)
+        if as_generator and do_commit:
+            raise TechnicalException(f"'do_commit=True' and 'as_generator=True' are incompatible")
+        if as_generator and not result_as_dict_list:
+            raise TechnicalException(f"'as_generator=True' is possible only with 'result_as_dict_list=True'")
+            
+        self._verify_is_connected()
+        
+        # Execute
+        if Tools.do_log(logger, logging.DEBUG):
+            logger.debug(f"[{self.name}] Executing SQL [{Tools.truncate_text(sql, 1000)}] (args: {Tools.truncate_text(args, 1000)} ; kwargs: {Tools.truncate_text(kwargs, 1000)})...")
+        try:
+            if args:
+                self.cursor.execute(sql, args)
+            elif kwargs:
+                self.cursor.execute(sql, kwargs)
+            else:
+                self.cursor.execute(sql)
+        except self._get_base_exception_type() as exc:
+            self.rollback()
+            raise TechnicalException(f"[{self.name}] Error while executing SQL [{sql}] (args: {args} ; kwargs: {kwargs})") from exc
+        
+        # Get result
+        if self.cursor.description:
+            field_names = [field[0] for field in self.cursor.description]
+            
+            if result_as_dict_list:
+                class Cursor2DictGenerator(BaseGenerator):
+                    def __init__(self, field_names, cursor):
+                        super().__init__(name="DB cursor to dict generator")
+                        self.__field_names = field_names
+                        self.__cursor = cursor
+                        self.__cursor_iter = iter(self.__cursor)
+                    
+                    def __next__(self):
+                        row_values = next(self.__cursor_iter)
+                        return dict(zip(self.__field_names, row_values))
+                
+                gen = Cursor2DictGenerator(field_names, self.cursor)
+                if as_generator:
+                    res = gen
+                else:
+                    res = [e for e in gen]
+            else:
+                res = TableWithHeader()
+                res.header = TableRow(cells_content=field_names)
+                
+                row_values = self.cursor.fetchone()
+                while row_values:
+                    res.add_row(cells_content=row_values)
+                    row_values = self.cursor.fetchone()
+        elif self.cursor.rowcount > 0:
+            res = self.cursor.rowcount
+        else:
+            res = None
+        
+        self.__log_sql_result(res, message=f"Executed SQL [{Tools.truncate_text(sql, 1000)}] (args: {Tools.truncate_text(args, 1000)} ; kwargs: {Tools.truncate_text(kwargs, 1000)})")
+        
+        # Manage commit
+        if do_commit:
+            try:
+                self.commit()
+            except self._get_base_exception_type() as exc:
+                self.rollback()
+                raise TechnicalException(f"[{self.name}] Error while commit after SQL [{sql}] (args: {args} ; kwargs: {kwargs})") from exc
+            
+        return res
+    
+    def is_query_type(self, sql_or_query, query_type):
+        from sql_metadata.keywords_lists import QueryType
+        import sql_metadata
+        import pypika.queries
+        
+        if isinstance(sql_or_query, pypika.queries.QueryBuilder):
+            sql = self.query_builder.to_sql(sql_or_query)
+        else:
+            sql = sql_or_query
+        if not isinstance(sql, str):
+            raise TechnicalException(f"Unexpected type '{Typing.get_object_class_fullname(sql)}' for parameter sql_or_query")
+        sql = sql.lower()
+        
+        # Parsing query with sql_metadata can be costly, thus begin by fast and simple methods
+        query_type_str = query_type.lower() if isinstance(query_type, str) else query_type.name.lower()
+        for qt in ['select', 'insert', 'update', 'delete']:
+            if sql.startswith(qt):
+                return qt == query_type_str
+        
+        # Parse more complex queries
+        if isinstance(query_type, str):
+            query_type = QueryType[query_type.upper()]
+        if not isinstance(query_type, QueryType):
+            raise TechnicalException(f"Unmanage query_type of type '{Typing.get_object_class_fullname(query_type)}'")
+        
+        try:
+            p = sql_metadata.Parser(sql)
+            res = p.query_type == query_type
+        except ValueError as exc:
+            if "Not supported query type" in str(exc):
+                res = False
+            else:
+                raise TechnicalException(f"Failed to define query type") from exc
+        except Exception as exc:
+            raise TechnicalException(f"Failed to define query type") from exc
+        
+        return res
+    
+    def set_or_update_json_key_value(self, table_name, field_name, json_key, json_value, where_data: dict=None, where_compare_data: list=None):
+        """
+        Set or update a json field with key=value.
+        """
+        raise NotImplementedError()
+        
+    def _get_sql_placeholder(self):
+        """
+        Return the character/string to use as placeholder in SQL requests.
+        """
+        raise NotImplementedError()
+
+    def _get_base_exception_type(self):
+        raise NotImplementedError()
+    
+    def __log_sql_result(self, sql_result, message="SQL result", limit_rows=10):
+        if Tools.do_log(logger, logging.DEBUG):
+            res_str = self.__represent_sql_result(sql_result, limit_rows=limit_rows)
+            if '\n' in res_str:
+                logger.debug(f"[{self.name}] {message}:\n{Tools.indent_string(4, res_str)}")
+            else:
+                logger.debug(f"[{self.name}] {message} => {res_str}")
+    
+    def __represent_sql_result(self, sql_result, limit_rows = 10):
+        if isinstance(sql_result, Table):
+            return sql_result.represent(limit_rows=limit_rows)
+        elif isinstance(sql_result, list) and limit_rows > 0 and len(sql_result) > limit_rows:
+            return str(sql_result[:limit_rows])[:-1] + f", ...({len(sql_result)-limit_rows})]"
+        else:
+            return str(sql_result)
+    
+    
+    # Manage transactions
+    
+    def commit(self):
+        self.connection.commit()
+        
+    def rollback(self):
+        self.connection.rollback()
+    
+    
+    # Manage tables
+    
+    def exist_table(self, table_name):
+        raise NotImplementedError()
+    
+    def create_table(self, table_name, create_sql, raise_if_exist=False, do_commit=True, do_audit=False):
+        if not self.exist_table(table_name):
+            self.execute(create_sql, do_commit=do_commit)
+            if not self.exist_table(table_name):
+                raise TechnicalException(f"Failed to create table '{table_name}' with SQL request [{create_sql}]")
+            
+            # Audit table
+            if do_audit:
+                self.audit_manager.audit_table(table_name)
+        elif raise_if_exist:
+            raise FunctionalException(f"Table '{table_name}' already exists")
+    
+    def drop_table(self, table_name, raise_if_not_exist=False, do_commit=True):
+        if self.exist_table(table_name):
+            sql = f"drop table {table_name};"
+            self.execute(sql, do_commit=do_commit)
+            if self.exist_table(table_name):
+                raise TechnicalException(f"Failed to drop table '{table_name}' with SQL request [{sql}]")
+        elif raise_if_not_exist:
+            raise FunctionalException(f"Table '{table_name}' doesn't exist")
+    
+    def get_table_column_names(self, table_name):
+        if table_name not in self.__column_names_by_table:
+            self.__column_names_by_table[table_name] = self._get_table_column_names(table_name)
+        return self.__column_names_by_table[table_name]
+    
+    def _get_table_column_names(self, table_name):
+        sql = f"select * from {table_name} limit 1"
+        try:
+            self.cursor.execute(sql)
+        except self._get_base_exception_type() as exc:
+            self.rollback()
+            raise TechnicalException(f"[{self.name}] Error while executing SQL [{sql}]") from exc
+        
+        if self.cursor.description:
+            res = [field[0] for field in self.cursor.description]
+        else:
+            raise TechnicalException(f"Failed to get column names of table {table_name}")
+        
+        return res
+        

holado_db/tools/db/clients/postgresql/postgresql_audit.py

@@ -0,0 +1,75 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2023 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+import logging
+from holado.common.handlers.undefined import default_value
+from holado_db.tools.db.clients.base.db_audit import TriggerAuditManager
+
+logger = logging.getLogger(__name__)
+
+
+class PostgreSQLTriggerAuditManager(TriggerAuditManager):
+    """Manage audit of tables by triggers.
+    WARNING: This case is not tested yet
+    """
+    def __init__(self, name, db_client):
+        super().__init__(name, db_client)
+    
+    def _get_audit_table_sql_create(self, audit_table_name=default_value):
+        audit_table_name = self._get_audit_table_name(audit_table_name)
+        return f"""CREATE TABLE {audit_table_name} (
+                id SERIAL PRIMARY KEY,
+                table_name TEXT,
+                record_id INTEGER,
+                operation_type TEXT,
+                changed_at TIMESTAMP DEFAULT now(),
+                changed_by TEXT,
+                previous_values JSONB,
+                new_values JSONB
+            )"""
+    
+    def _get_drop_trigger_sql_of_audit_table_operation(self, table_name, operation_type, audit_table_name):
+        audit_table_name = self._get_audit_table_name(audit_table_name)
+        trigger_name = self.get_trigger_name(table_name, operation_type)
+        return f"DROP TRIGGER IF EXISTS {trigger_name} on {table_name}"
+    
+    def _get_create_trigger_sql_to_audit_table_operation(self, table_name, operation_type, audit_table_name):
+        audit_table_name = self._get_audit_table_name(audit_table_name)
+        trigger_name = self.get_trigger_name(table_name, operation_type)
+        trigger_insert_sql = self.__get_trigger_insert_sql(table_name, operation_type, audit_table_name)
+        return f"""CREATE TRIGGER {trigger_name} AFTER {operation_type.upper()} ON {table_name}
+                BEGIN
+                    {trigger_insert_sql}
+                END;
+                """
+    
+    def __get_trigger_insert_sql(self, table_name, operation_type, audit_table_name):
+        rowid_txt = "NEW.id" if operation_type in ['insert', 'update'] else "OLD.id"
+        op_type = operation_type[0]
+        prev_vals_txt = "to_jsonb(OLD)" if operation_type in ['update', 'delete'] else "NULL"
+        new_vals_txt = "to_jsonb(NEW)" if operation_type in ['insert', 'update'] else "NULL"
+        
+        audit_info = [f"'{table_name}'",
+                      rowid_txt,
+                      f"'{op_type}'",
+                      "current_user",
+                      prev_vals_txt,
+                      new_vals_txt,
+                     ]
+        audit_info = ','.join(audit_info)
+        
+        return f"""INSERT INTO {audit_table_name} (table_name, record_id, operation_type, changed_by, previous_values, new_values) 
+                   VALUES ({audit_info});"""
+
+
+