sh-edraft.de/sh_cpl
2
1
Fork 0
Code Issues 4 Pull Requests 1 Actions Packages Projects 1 Releases 12 Wiki Activity

[WIP] Added native mysql support

Browse Source
This commit is contained in:
Sven Heidemann
2021-11-29 20:55:43 +01:00
parent 7616cd4c69
commit d9f10edbb7
22 changed files with 277 additions and 231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/cpl_core/database/__init__.py
View File

@@ -20,9 +20,9 @@ __version__ = '2021.10.2'
from collections import namedtuple
# imports:
from .database_model import DatabaseModel
from .database_settings import DatabaseSettings
from .database_settings_name_enum import DatabaseSettingsNameEnum
from .database_settings import DatabaseSettings
from .table_abc import TableABC
VersionInfo = namedtuple('VersionInfo', 'major minor micro')
version_info = VersionInfo(major='2021', minor='10', micro='2')

61
src/cpl_core/database/connection/database_connection.py
View File

@@ -1,59 +1,40 @@
from typing import Optional
from sqlalchemy import engine, create_engine
from sqlalchemy.orm import Session, sessionmaker
import mysql.connector as sql
from cpl_core.console.console import Console
from cpl_core.console.foreground_color_enum import ForegroundColorEnum
from cpl_core.database.connection.database_connection_abc import DatabaseConnectionABC
from cpl_core.database.connection.database_connection_abc import \
DatabaseConnectionABC
from cpl_core.database.database_settings import DatabaseSettings
from cpl_core.utils import CredentialManager
from mysql.connector.abstracts import MySQLConnectionAbstract
class DatabaseConnection(DatabaseConnectionABC):
r"""Representation of the database connection
Parameter
---------
database_settings: :class:`cpl_core.database.database_settings.DatabaseSettings`
"""
def __init__(self, database_settings: DatabaseSettings):
def __init__(self):
DatabaseConnectionABC.__init__(self)
self._db_settings = database_settings
self._engine: Optional[engine] = None
self._session: Optional[Session] = None
self._credentials: Optional[str] = None
self._database_server: Optional[MySQLConnectionAbstract] = None
@property
def engine(self) -> engine:
return self._engine
def server(self) -> MySQLConnectionAbstract:
return self._database_server
@property
def session(self) -> Session:
return self._session
def connect(self, connection_string: str):
def connect(self, database_settings: DatabaseSettings):
try:
self._engine = create_engine(connection_string)
if self._db_settings.auth_plugin is not None:
self._engine = create_engine(connection_string, connect_args={'auth_plugin': self._db_settings.auth_plugin})
if self._db_settings.encoding is not None:
self._engine.encoding = self._db_settings.encoding
if self._db_settings.case_sensitive is not None:
self._engine.case_sensitive = self._db_settings.case_sensitive
if self._db_settings.echo is not None:
self._engine.echo = self._db_settings.echo
self._engine.connect()
db_session = sessionmaker(bind=self._engine)
self._session = db_session()
self._database_server = sql.connect(
host=database_settings.host,
user=database_settings.user,
passwd=CredentialManager.decrypt(database_settings.password),
db=database_settings.database,
charset=database_settings.charset,
use_unicode=database_settings.use_unicode,
buffered=database_settings.buffered,
auth_plugin=database_settings.auth_plugin
)
Console.set_foreground_color(ForegroundColorEnum.green)
Console.write_line(f'[{__name__}] Connected to database')
Console.set_foreground_color(ForegroundColorEnum.default)

16
src/cpl_core/database/connection/database_connection_abc.py
View File

@@ -1,7 +1,7 @@
from abc import abstractmethod, ABC
from abc import ABC, abstractmethod
from sqlalchemy import engine
from sqlalchemy.orm import Session
from cpl_core.database.database_settings import DatabaseSettings
from mysql.connector.abstracts import MySQLConnectionAbstract
class DatabaseConnectionABC(ABC):
@@ -12,14 +12,10 @@ class DatabaseConnectionABC(ABC):
@property
@abstractmethod
def engine(self) -> engine: pass
@property
def server(self) -> MySQLConnectionAbstract: pass
@abstractmethod
def session(self) -> Session: pass
@abstractmethod
def connect(self, connection_string: str):
def connect(self, database_settings: DatabaseSettings):
r"""Connects to a database by connection string
Parameter

54
src/cpl_core/database/context/database_context.py
View File

@@ -1,13 +1,13 @@
from sqlalchemy import engine, Table
from sqlalchemy.orm import Session
from typing import Optional
from cpl_core.console.console import Console
from cpl_core.console.foreground_color_enum import ForegroundColorEnum
from cpl_core.database.connection.database_connection import DatabaseConnection
from cpl_core.database.connection.database_connection_abc import DatabaseConnectionABC
from cpl_core.database.connection.database_connection_abc import \
DatabaseConnectionABC
from cpl_core.database.context.database_context_abc import DatabaseContextABC
from cpl_core.database.database_settings import DatabaseSettings
from cpl_core.database.database_model import DatabaseModel
from cpl_core.database.table_abc import TableABC
class DatabaseContext(DatabaseContextABC):
@@ -19,38 +19,24 @@ class DatabaseContext(DatabaseContextABC):
"""
def __init__(self, database_settings: DatabaseSettings):
DatabaseContextABC.__init__(self)
DatabaseContextABC.__init__(self, database_settings)
self._db: DatabaseConnectionABC = DatabaseConnection(database_settings)
self._tables: list[Table] = []
self._db: DatabaseConnectionABC = DatabaseConnection()
self._cursor: Optional[str] = None
self._tables: list[TableABC] = TableABC.__subclasses__()
@property
def engine(self) -> engine:
return self._db.engine
def cursor(self):
return self._cursor
@property
def session(self) -> Session:
return self._db.session
def connect(self, connection_string: str):
self._db.connect(connection_string)
self._create_tables()
def connect(self, database_settings: DatabaseSettings):
self._db.connect(database_settings)
c = self._db.server.cursor()
self._cursor = c
Console.write_line(f"Ts: {self._tables}")
for table in self._tables:
Console.write_line(f"{table}, {table.create_string}")
c.execute(table.create_string)
def save_changes(self):
self._db.session.commit()
def _create_tables(self):
try:
for subclass in DatabaseModel.__subclasses__():
self._tables.append(subclass.__table__)
DatabaseModel.metadata.drop_all(self._db.engine, self._tables)
DatabaseModel.metadata.create_all(self._db.engine, self._tables, checkfirst=True)
Console.set_foreground_color(ForegroundColorEnum.green)
Console.write_line(f'[{__name__}] Created tables')
Console.set_foreground_color(ForegroundColorEnum.default)
except Exception as e:
Console.set_foreground_color(ForegroundColorEnum.red)
Console.write_line(f'[{__name__}] Creating tables failed -> {e}')
Console.set_foreground_color(ForegroundColorEnum.default)
exit()
self._db.server.commit()

23
src/cpl_core/database/context/database_context_abc.py
View File

@@ -1,7 +1,6 @@
from abc import abstractmethod, ABC
from abc import ABC, abstractmethod
from sqlalchemy import engine
from sqlalchemy.orm import Session
from cpl_core.database.database_settings import DatabaseSettings
class DatabaseContextABC(ABC):
@@ -13,28 +12,18 @@ class DatabaseContextABC(ABC):
@property
@abstractmethod
def engine(self) -> engine: pass
@property
@abstractmethod
def session(self) -> Session: pass
def cursor(self): pass
@abstractmethod
def connect(self, connection_string: str):
r"""Connects to a database by connection string
def connect(self, database_settings: DatabaseSettings):
r"""Connects to a database by connection settings
Parameter
---------
connection_string: :class:`str`
Database connection string, see: https://docs.sqlalchemy.org/en/14/core/engines.html
database_settings :class:`cpl_core.database.database_settings.DatabaseSettings`
"""
pass
def save_changes(self):
r"""Saves changes of the database"""
pass
@abstractmethod
def _create_tables(self):
r"""Create all tables for application from database model"""
pass

3
src/cpl_core/database/database_model.py
View File

@@ -1,3 +0,0 @@
from sqlalchemy.ext.declarative import declarative_base
DatabaseModel: declarative_base = declarative_base()

112
src/cpl_core/database/database_settings.py
View File

@@ -13,61 +13,47 @@ class DatabaseSettings(ConfigurationModelABC):
def __init__(self):
ConfigurationModelABC.__init__(self)
self._host: Optional[str] = None
self._user: Optional[str] = None
self._password: Optional[str] = None
self._databse: Optional[str] = None
self._charset: Optional[str] = None
self._use_unicode: Optional[bool] = None
self._buffered: Optional[bool] = None
self._auth_plugin: Optional[str] = None
self._connection_string: Optional[str] = None
self._credentials: Optional[str] = None
self._encoding: Optional[str] = None
self._case_sensitive: Optional[bool] = None
self._echo: Optional[bool] = None
@property
def auth_plugin(self) -> str:
def host(self) -> Optional[str]:
return self._host
@property
def user(self) -> Optional[str]:
return self._user
@property
def password(self) -> Optional[str]:
return self._password
@property
def database(self) -> Optional[str]:
return self._databse
@property
def charset(self) -> Optional[str]:
return self._charset
@property
def use_unicode(self) -> Optional[bool]:
return self._use_unicode
@property
def buffered(self) -> Optional[bool]:
return self._buffered
@property
def auth_plugin(self) -> Optional[str]:
return self._auth_plugin
@auth_plugin.setter
def auth_plugin(self, auth_plugin: str):
self._auth_plugin = auth_plugin
@property
def connection_string(self) -> str:
return self._connection_string
@connection_string.setter
def connection_string(self, connection_string: str):
self._connection_string = connection_string
@property
def credentials(self) -> str:
return self._credentials
@credentials.setter
def credentials(self, credentials: str):
self._credentials = credentials
@property
def encoding(self) -> str:
return self._encoding
@encoding.setter
def encoding(self, encoding: str) -> None:
self._encoding = encoding
@property
def case_sensitive(self) -> bool:
return self._case_sensitive
@case_sensitive.setter
def case_sensitive(self, case_sensitive: bool) -> None:
self._case_sensitive = case_sensitive
@property
def echo(self) -> bool:
return self._echo
@echo.setter
def echo(self, echo: bool) -> None:
self._echo = echo
def from_dict(self, settings: dict):
r"""Sets attributes from given dict
@@ -76,20 +62,22 @@ class DatabaseSettings(ConfigurationModelABC):
settings: :class:`dict`
"""
try:
self._connection_string = settings[DatabaseSettingsNameEnum.connection_string.value]
self._credentials = settings[DatabaseSettingsNameEnum.credentials.value]
self._host = settings[DatabaseSettingsNameEnum.host.value]
self._user = settings[DatabaseSettingsNameEnum.user.value]
self._password = settings[DatabaseSettingsNameEnum.password.value]
self._databse = settings[DatabaseSettingsNameEnum.database.value]
if DatabaseSettingsNameEnum.charset.value in settings:
self._charset = settings[DatabaseSettingsNameEnum.charset.value]
if DatabaseSettingsNameEnum.buffered.value in settings:
self._use_unicode = bool(settings[DatabaseSettingsNameEnum.use_unicode.value])
if DatabaseSettingsNameEnum.buffered.value in settings:
self._buffered = bool(settings[DatabaseSettingsNameEnum.buffered.value])
if DatabaseSettingsNameEnum.auth_plugin.value in settings:
self._auth_plugin = settings[DatabaseSettingsNameEnum.auth_plugin.value]
if DatabaseSettingsNameEnum.encoding.value in settings:
self._encoding = settings[DatabaseSettingsNameEnum.encoding.value]
if DatabaseSettingsNameEnum.case_sensitive.value in settings:
self._case_sensitive = bool(settings[DatabaseSettingsNameEnum.case_sensitive.value])
if DatabaseSettingsNameEnum.echo.value in settings:
self._echo = bool(settings[DatabaseSettingsNameEnum.echo.value])
except Exception as e:
Console.set_foreground_color(ForegroundColorEnum.red)
Console.write_line(f'[ ERROR ] [ {__name__} ]: Reading error in {self.__name__} settings')

12
src/cpl_core/database/database_settings_name_enum.py
View File

@@ -3,9 +3,11 @@ from enum import Enum
class DatabaseSettingsNameEnum(Enum):
connection_string = 'ConnectionString'
credentials = 'Credentials'
encoding = 'Encoding'
case_sensitive = 'CaseSensitive'
echo = 'Echo'
host = 'Host'
user = 'User'
password = 'Password'
database = 'Database'
charset = 'Charset'
use_unicode = 'UseUnicode'
buffered = 'Buffered'
auth_plugin = 'AuthPlugin'

35
src/cpl_core/database/table_abc.py Normal file
View File

@@ -0,0 +1,35 @@
from abc import ABC, abstractmethod
from datetime import datetime
from typing import Optional
class TableABC(ABC):
@abstractmethod
def __init__(self):
self._created_at: Optional[datetime] = None
self._modified_at: Optional[datetime] = None
@property
def CreatedAt(self) -> datetime:
return self._created_at
@property
def LastModifiedAt(self) -> datetime:
return self._modified_at
@property
@abstractmethod
def create_string(self) -> str: pass
@property
@abstractmethod
def insert_string(self) -> str: pass
@property
@abstractmethod
def udpate_string(self) -> str: pass
@property
@abstractmethod
def delete_string(self) -> str: pass