watchmen-collector-kernel 16.4.7__tar.gz → 16.4.8__tar.gz

{watchmen_collector_kernel-16.4.7 → watchmen_collector_kernel-16.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: watchmen-collector-kernel
-Version: 16.4.7
+Version: 16.4.8
 Summary: 
 License: MIT
 Author: botlikes
@@ -18,11 +18,11 @@ Provides-Extra: oracle
 Provides-Extra: oss
 Provides-Extra: postgresql
 Provides-Extra: s3
-Requires-Dist: watchmen-pipeline-kernel (==16.4.7)
-Requires-Dist: watchmen-storage-mongodb (==16.4.7) ; extra == "mongodb"
-Requires-Dist: watchmen-storage-mssql (==16.4.7) ; extra == "mssql"
-Requires-Dist: watchmen-storage-mysql (==16.4.7) ; extra == "mysql"
-Requires-Dist: watchmen-storage-oracle (==16.4.7) ; extra == "oracle"
-Requires-Dist: watchmen-storage-oss (==16.4.7) ; extra == "oss"
-Requires-Dist: watchmen-storage-postgresql (==16.4.7) ; extra == "postgresql"
-Requires-Dist: watchmen-storage-s3 (==16.4.7) ; extra == "s3"
+Requires-Dist: watchmen-data-kernel (==16.4.8)
+Requires-Dist: watchmen-storage-mongodb (==16.4.8) ; extra == "mongodb"
+Requires-Dist: watchmen-storage-mssql (==16.4.8) ; extra == "mssql"
+Requires-Dist: watchmen-storage-mysql (==16.4.8) ; extra == "mysql"
+Requires-Dist: watchmen-storage-oracle (==16.4.8) ; extra == "oracle"
+Requires-Dist: watchmen-storage-oss (==16.4.8) ; extra == "oss"
+Requires-Dist: watchmen-storage-postgresql (==16.4.8) ; extra == "postgresql"
+Requires-Dist: watchmen-storage-s3 (==16.4.8) ; extra == "s3"

{watchmen_collector_kernel-16.4.7 → watchmen_collector_kernel-16.4.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "watchmen-collector-kernel"
-version = "16.4.7"
+version = "16.4.8"
 description = ""
 authors = ["botlikes <75356972+botlikes456@users.noreply.github.com>"]
 license = "MIT"
@@ -10,14 +10,14 @@ packages = [
 
 [tool.poetry.dependencies]
 python = "^3.9"
-watchmen-pipeline-kernel = "16.4.7"
-watchmen-storage-mysql = { version = "16.4.7", optional = true }
-watchmen-storage-oracle = { version = "16.4.7", optional = true }
-watchmen-storage-mongodb = { version = "16.4.7", optional = true }
-watchmen-storage-mssql = { version = "16.4.7", optional = true }
-watchmen-storage-postgresql = { version = "16.4.7", optional = true }
-watchmen-storage-oss = { version = "16.4.7", optional = true }
-watchmen-storage-s3 = { version = "16.4.7", optional = true }
+watchmen-data-kernel = "16.4.8"
+watchmen-storage-mysql = { version = "16.4.8", optional = true }
+watchmen-storage-oracle = { version = "16.4.8", optional = true }
+watchmen-storage-mongodb = { version = "16.4.8", optional = true }
+watchmen-storage-mssql = { version = "16.4.8", optional = true }
+watchmen-storage-postgresql = { version = "16.4.8", optional = true }
+watchmen-storage-oss = { version = "16.4.8", optional = true }
+watchmen-storage-s3 = { version = "16.4.8", optional = true }
 
 [tool.poetry.dev-dependencies]
 

{watchmen_collector_kernel-16.4.7 → watchmen_collector_kernel-16.4.8}/setup.py

@@ -7,28 +7,28 @@ package_dir = \
 packages = \
 ['watchmen_collector_kernel',
  'watchmen_collector_kernel.common',
- 'watchmen_collector_kernel.connector',
- 'watchmen_collector_kernel.lock',
- 'watchmen_collector_kernel.model']
+ 'watchmen_collector_kernel.model',
+ 'watchmen_collector_kernel.service',
+ 'watchmen_collector_kernel.storage']
 
 package_data = \
 {'': ['*']}
 
 install_requires = \
-['watchmen-pipeline-kernel==16.4.7']
+['watchmen-data-kernel==16.4.8']
 
 extras_require = \
-{'mongodb': ['watchmen-storage-mongodb==16.4.7'],
- 'mssql': ['watchmen-storage-mssql==16.4.7'],
- 'mysql': ['watchmen-storage-mysql==16.4.7'],
- 'oracle': ['watchmen-storage-oracle==16.4.7'],
- 'oss': ['watchmen-storage-oss==16.4.7'],
- 'postgresql': ['watchmen-storage-postgresql==16.4.7'],
- 's3': ['watchmen-storage-s3==16.4.7']}
+{'mongodb': ['watchmen-storage-mongodb==16.4.8'],
+ 'mssql': ['watchmen-storage-mssql==16.4.8'],
+ 'mysql': ['watchmen-storage-mysql==16.4.8'],
+ 'oracle': ['watchmen-storage-oracle==16.4.8'],
+ 'oss': ['watchmen-storage-oss==16.4.8'],
+ 'postgresql': ['watchmen-storage-postgresql==16.4.8'],
+ 's3': ['watchmen-storage-s3==16.4.8']}
 
 setup_kwargs = {
     'name': 'watchmen-collector-kernel',
-    'version': '16.4.7',
+    'version': '16.4.8',
     'description': '',
     'long_description': 'None',
     'author': 'botlikes',

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/common/__init__.py

@@ -0,0 +1,2 @@
+from .constants import CHANGE_RECORD_ID, TENANT_ID, IS_MERGED, LEFT_BRACE, RIGHT_BRACE, COMMA, \
+	IS_POSTED, CHANGE_JSON_ID, WAVE, IS_FINISHED, IS_EXTRACTED, MODEL_TRIGGER_ID

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/common/constants.py

@@ -0,0 +1,16 @@
+
+
+CHANGE_RECORD_ID = 'change_record_id'
+CHANGE_JSON_ID = 'change_json_id'
+TENANT_ID = 'tenant_id'
+MODEL_TRIGGER_ID = 'model_trigger_id'
+
+IS_FINISHED = 'is_finished'
+IS_EXTRACTED = 'is_extracted'
+IS_MERGED = 'is_merged'
+IS_POSTED = 'is_posted'
+
+LEFT_BRACE = '{'
+RIGHT_BRACE = '}'
+COMMA = ','
+WAVE = '~'

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/model/__init__.py

@@ -0,0 +1,15 @@
+from .competitive_lock import CompetitiveLock
+from .scheduled_task import ScheduledTask, TaskStatus
+
+from .collector_model_config import CollectorModelConfig
+from .collector_table_config import CollectorTableConfig
+
+from .trigger_event import TriggerEvent
+from .trigger_model import TriggerModel
+from .trigger_table import TriggerTable
+
+from .change_data_record import ChangeDataRecord
+from .change_data_json import ChangeDataJson
+
+from .condition import construct_conditions, Condition, ConditionJoint, ConditionExpression, \
+	ConditionJointConjunction

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/model/change_data_json.py

@@ -0,0 +1,28 @@
+from typing import Dict, List
+
+from pydantic import BaseModel
+
+from watchmen_model.common import TenantBasedTuple, Storable
+
+
+class Dependence(Storable, BaseModel):
+	modelName: str
+	objectId: str
+
+
+class ChangeDataJson(TenantBasedTuple, BaseModel):
+	changeJsonId: int
+	resourceId: str
+	modelName: str
+	objectId: str
+	sequence: int
+	content: Dict
+	dataId: Dict
+	dependOn: List[Dependence]
+	isPosted: bool
+	result: Dict
+	taskId: int
+	tableTriggerId: int
+	modelTriggerId: int
+	eventTriggerId: int
+

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/model/change_data_record.py

@@ -0,0 +1,19 @@
+from typing import Dict, Optional
+
+from watchmen_model.common import TenantBasedTuple
+
+
+class ChangeDataRecord(TenantBasedTuple):
+	changeRecordId: int
+	modelName: str
+	tableName: str
+	dataId: Dict
+	rootTableName: str
+	rootDataId: Dict
+	isMerged: bool
+	result: Dict
+	tableTriggerId: int
+	modelTriggerId: int
+	eventTriggerId: int
+
+

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/model/collector_model_config.py

@@ -0,0 +1,12 @@
+from typing import List
+from watchmen_model.common import TenantBasedTuple, OptimisticLock
+from pydantic import BaseModel
+
+
+class CollectorModelConfig(TenantBasedTuple, OptimisticLock, BaseModel):
+	modelId: str
+	modelName: str
+	dependOn: List[str]
+	rawTopicCode: str
+	isParalleled: bool
+

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/model/collector_table_config.py

@@ -0,0 +1,78 @@
+from typing import Dict, List, Optional, Union
+
+from pydantic import BaseModel
+
+from .condition import Condition, construct_conditions
+from watchmen_model.common import TenantBasedTuple, Storable, OptimisticLock
+from watchmen_utilities import ArrayHelper
+
+
+class JoinKey(Storable, BaseModel):
+	parentKey: str = None
+	childKey: str = None
+
+
+class Dependence(Storable, BaseModel):
+	modelName: str
+	objectKey: str  # the dependent column
+
+
+def construct_join_key(join_key: Union[JoinKey, Dict]) -> Optional[JoinKey]:
+	if join_key is None:
+		return None
+	elif isinstance(join_key, JoinKey):
+		return join_key
+	else:
+		return JoinKey(**join_key)
+
+
+def construct_join_keys(join_keys: Optional[List[Union[JoinKey, Dict]]]) -> Optional[List[JoinKey]]:
+	if join_keys is None:
+		return None
+	else:
+		return ArrayHelper(join_keys).map(lambda x: construct_join_key(x)).to_list()
+
+
+def construct_dependence(dependence: Union[Dependence, Dict]) -> Optional[Dependence]:
+	if dependence is None:
+		return None
+	elif isinstance(dependence, Dependence):
+		return dependence
+	else:
+		return Dependence(**dependence)
+
+
+def construct_depend_on(depend_on: Optional[List[Union[Dependence, Dict]]]) -> Optional[List[Dependence]]:
+	if depend_on is None:
+		return None
+	else:
+		return ArrayHelper(depend_on).map(lambda x: construct_dependence(x)).to_list()
+
+
+class CollectorTableConfig(TenantBasedTuple, OptimisticLock, BaseModel):
+	configId: str = None
+	name: str = None
+	tableName: str = None
+	primaryKey: List[str] = None
+	objectKey: str = None
+	sequenceKey: str = None
+	modelName: str = None
+	parentName: str = None
+	label: str = None
+	joinKeys: List[JoinKey] = []
+	dependOn: List[Dependence] = []
+	auditColumn: str = None
+	conditions: List[Condition] = []
+	dataSourceId: str = None
+	isList: bool = False
+	triggered: bool = False
+
+	def __setattr__(self, name, value):
+		if name == 'joinKeys':
+			super().__setattr__(name, construct_join_keys(value))
+		elif name == 'dependOn':
+			super().__setattr__(name, construct_depend_on(value))
+		elif name == 'conditions':
+			super().__setattr__(name, construct_conditions(value))
+		else:
+			super().__setattr__(name, value)

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/model/competitive_lock.py

@@ -0,0 +1,11 @@
+from datetime import datetime
+from typing import Optional
+
+from watchmen_model.common import CompetitiveLockId, Storable, TenantId
+
+
+class CompetitiveLock(Storable):
+	lockId: CompetitiveLockId
+	resourceId: str
+	registeredAt: Optional[datetime]
+	tenantId: TenantId

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/model/condition.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from datetime import date, datetime
+from enum import Enum
+from typing import Optional, List, Union, Dict
+
+from pydantic import BaseModel
+
+from watchmen_model.common import DataModel
+from watchmen_utilities import ArrayHelper
+
+
+class ConditionOperator(str, Enum):
+	IS_EMPTY = 'is-empty',
+	IS_NOT_EMPTY = 'is-not-empty',
+	IS_BLANK = 'is-blank',
+	IS_NOT_BLANK = 'is-not-blank',
+	EQUALS = 'equals',
+	NOT_EQUALS = 'not-equals',
+	LESS_THAN = 'less-than',
+	LESS_THAN_OR_EQUALS = 'less-than-or-equals',
+	GREATER_THAN = 'greater-than',
+	GREATER_THAN_OR_EQUALS = 'greater-than-or-equals',
+	IN = 'in',
+	NOT_IN = 'not-in'
+
+
+class Condition(DataModel, BaseModel):
+	pass
+
+
+class ConditionExpression(Condition):
+	columnName: str
+	operator: ConditionOperator = ConditionOperator.EQUALS
+	columnValue: Optional[Union[List[int], List[str], int, str, date, datetime]] = None
+
+
+class ConditionJointConjunction(str, Enum):
+	AND = 'and',
+	OR = 'or'
+
+
+class ConditionJoint(Condition):
+	conjunction: ConditionJointConjunction = ConditionJointConjunction.AND
+	children: List[Condition]
+
+	def __setattr__(self, name, value):
+		if name == 'children':
+			super().__setattr__(name, construct_conditions(value))
+		else:
+			super().__setattr__(name, value)
+
+
+def construct_condition(condition: Optional[Union[Condition, Dict]]) -> Optional[Condition]:
+	if condition is None:
+		return None
+	elif isinstance(condition, Condition):
+		return condition
+	elif isinstance(condition, ConditionExpression):
+		return condition
+	elif isinstance(condition, ConditionJoint):
+		return condition
+	elif condition.get('conjunction'):
+		return ConditionJoint(**condition)
+	else:
+		return ConditionExpression(**condition)
+
+
+def construct_conditions(conditions: Optional[List[Union[Condition, Dict]]]) -> Optional[List[Condition]]:
+	if conditions is None:
+		return None
+	else:
+		return ArrayHelper(conditions).map(lambda x: construct_condition(x)).to_list()

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/model/scheduled_task.py

@@ -0,0 +1,36 @@
+from typing import Dict, List
+
+from watchmen_model.common import TenantBasedTuple, ScheduledTaskId, Storable
+from pydantic import BaseModel
+from enum import Enum, IntEnum
+
+
+class Result(str, Enum):
+	DEPENDENCY_FAILED = "DEPENDENCY_FAILED"
+	PROCESS_TASK_SUCCESS = "PROCESS_TASK_SUCCESS"
+	PROCESS_TASK_FAILED = "PROCESS_TASK_FAILED"
+
+
+class TaskStatus(IntEnum):
+	INITIAL = 0
+	SUCCESS = 1
+	FAILED = 2
+
+
+class Dependence(Storable, BaseModel):
+	modelName: str
+	objectId: str
+
+
+class ScheduledTask(TenantBasedTuple, BaseModel):
+	taskId: ScheduledTaskId
+	resourceId: str  # global unique, monotonous increase
+	topicCode: str
+	content: Dict
+	modelName: str
+	objectId: str
+	dependOn: List[Dependence]
+	parentTaskId: List[int]
+	status: TaskStatus
+	result: Dict
+

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/model/trigger_event.py

@@ -0,0 +1,11 @@
+from datetime import datetime
+
+from watchmen_model.common import TenantBasedTuple
+from pydantic import BaseModel
+
+
+class TriggerEvent(TenantBasedTuple, BaseModel):
+	eventTriggerId: int
+	startTime: datetime
+	endTime: datetime
+	isFinished: bool = False

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/model/trigger_model.py

@@ -0,0 +1,8 @@
+from watchmen_model.common import TenantBasedTuple
+
+
+class TriggerModel(TenantBasedTuple):
+	modelTriggerId: int
+	modelName: str
+	isFinished: bool = False
+	eventTriggerId: int

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/model/trigger_table.py

@@ -0,0 +1,11 @@
+from watchmen_model.common import TenantBasedTuple
+
+
+class TriggerTable(TenantBasedTuple):
+	tableTriggerId: int
+	tableName: str
+	dataCount: int
+	modelName: str
+	isExtracted: bool = False
+	modelTriggerId: int
+	eventTriggerId: int

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/service/__init__.py

@@ -0,0 +1,8 @@
+from .lock_helper import try_lock_nowait, unlock
+from .lock_clean import init_lock_clean
+from .trigger_collector import get_trigger_collector
+from .data_capture import DataCaptureService
+from .extract_source import SourceTableExtractor
+from .task_service import get_task_service
+from .criteria_builder import CriteriaBuilder
+from .extract_utils import build_audit_column_criteria, cal_array2d_diff, build_data_id, get_data_id

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/service/criteria_builder.py

@@ -0,0 +1,53 @@
+from typing import List, Dict, Any
+from watchmen_collector_kernel.common import LEFT_BRACE, RIGHT_BRACE
+from watchmen_collector_kernel.model import Condition, ConditionJoint, ConditionExpression
+from watchmen_data_kernel.common import ask_all_date_formats
+from watchmen_storage import EntityCriteria, EntityCriteriaExpression, ColumnNameLiteral, EntityCriteriaJoint, \
+	EntityCriteriaStatement
+from watchmen_utilities import ArrayHelper, is_date
+
+
+class CriteriaBuilder:
+
+	def __init__(self, variables: Dict):
+		self.variables = variables
+
+	def add_variable(self, variable_name: str, variable_value: Any):
+		self.variables[variable_name] = variable_value
+
+	def build_criteria(self, conditions: List[Condition]) -> EntityCriteria:
+		return ArrayHelper(conditions).map(self.build_statement).to_list()
+
+	def build_statement(self, condition: Condition) -> EntityCriteriaStatement:
+		if isinstance(condition, ConditionJoint):
+			return self.build_criteria_joint(condition)
+		if isinstance(condition, ConditionExpression):
+			return self.build_criteria_expression(condition)
+		else:
+			raise ValueError(f'Unsupported condition[{condition}].')
+
+	def build_criteria_expression(self, condition: ConditionExpression) -> EntityCriteriaExpression:
+		return EntityCriteriaExpression(left=ColumnNameLiteral(columnName=condition.columnName),
+		                                operator=condition.operator,
+		                                right=self.parse_condition_value(condition.columnValue))
+
+	def build_criteria_joint(self, condition: ConditionJoint) -> EntityCriteriaJoint:
+		return EntityCriteriaJoint(conjunction=condition.conjunction,
+		                           children=ArrayHelper(condition.children)
+		                           .map(lambda child: self.build_statement(child))
+		                           .to_list())
+
+	def parse_condition_value(self, condition_value: Any) -> Any:
+		if isinstance(condition_value, str):
+			if condition_value.startswith(LEFT_BRACE) and condition_value.startswith(RIGHT_BRACE):
+				variable_name = condition_value.removeprefix(LEFT_BRACE).removesuffix(RIGHT_BRACE)
+				variable_value = self.variables.get(variable_name)
+				parsed, value = is_date(variable_value, ask_all_date_formats())
+				if parsed:
+					return value
+				else:
+					return variable_value
+			else:
+				return condition_value
+		else:
+			return condition_value

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/service/data_capture.py

@@ -0,0 +1,60 @@
+from logging import getLogger
+from typing import Optional, Dict, Any, Tuple
+
+from watchmen_auth import PrincipalService
+from watchmen_collector_kernel.model import CollectorTableConfig
+from .extract_source import SourceTableExtractor
+from watchmen_collector_kernel.storage import get_collector_table_config_service
+from watchmen_storage import TransactionalStorageSPI, SnowflakeGenerator
+from watchmen_utilities import ArrayHelper
+from .extract_utils import build_criteria_by_join_key
+
+logger = getLogger(__name__)
+
+
+class DataCaptureService:
+
+	def __init__(self, storage: TransactionalStorageSPI,
+	             snowflake_generator: SnowflakeGenerator,
+	             principal_service: PrincipalService):
+		self.meta_storage = storage
+		self.snowflake_generator = snowflake_generator
+		self.principal_service = principal_service
+		self.collector_table_config_service = get_collector_table_config_service(self.meta_storage,
+		                                                                         self.snowflake_generator,
+		                                                                         self.principal_service)
+
+	def find_data_by_data_id(self, config: CollectorTableConfig, data_id: Dict) -> Optional[Dict[str, Any]]:
+		return SourceTableExtractor(config, self.principal_service).find_by_id(data_id)
+
+	def find_parent_node(self, config: CollectorTableConfig,
+	                     data_: Dict) -> Tuple[CollectorTableConfig, Optional[Dict[str, Any]]]:
+		if config.parentName:
+			parent_config = self.collector_table_config_service.find_by_name(config.parentName)
+			parent_data = SourceTableExtractor(parent_config, self.principal_service).find(
+				ArrayHelper(config.joinKeys).map(lambda join_key: build_criteria_by_join_key(join_key, data_)).to_list()
+			)
+			if len(parent_data) != 1:
+				raise RuntimeError(f'The data : {data_}, config_name: {config.name}, '
+				                   f'parent_config_name: {parent_config.name}, size: {len(parent_data)}')
+			return self.find_parent_node(parent_config, parent_data[0])
+		else:
+			return config, data_
+
+	def build_json(self,
+	               config: CollectorTableConfig,
+	               data: Dict):
+		child_configs = self.collector_table_config_service.find_by_parent_name(config.name)
+		if child_configs:
+			ArrayHelper(child_configs).map(lambda child_config: self.get_child_data(child_config, data))
+
+	def get_child_data(self, child_config: CollectorTableConfig, data_: Dict):
+		child_data = SourceTableExtractor(child_config, self.principal_service).find(
+			ArrayHelper(child_config.joinKeys).map(lambda join_key: build_criteria_by_join_key(join_key, data_, True)).to_list()
+		)
+		if child_data:
+			if child_config.isList:
+				data_[child_config.label] = child_data
+			else:
+				data_[child_config.label] = child_data[0]
+			ArrayHelper(child_data).each(lambda child: self.build_json(child_config, child))

watchmen_collector_kernel-16.4.8/src/watchmen_collector_kernel/service/extract_source.py

@@ -0,0 +1,71 @@
+from typing import Optional, List, Dict, Any
+
+from watchmen_auth import PrincipalService
+from .extract_utils import build_criteria_by_primary_key
+from watchmen_collector_kernel.model import CollectorTableConfig
+from watchmen_data_kernel.service import ask_topic_storage, ask_topic_data_service
+from watchmen_data_kernel.topic_schema import TopicSchema
+from watchmen_model.admin import Topic, TopicKind
+from watchmen_storage import EntityCriteria, EntityStraightColumn
+from watchmen_utilities import get_current_time_in_seconds, ArrayHelper
+
+
+class SourceTableExtractor:
+
+	def __init__(self, config: CollectorTableConfig, principal_service: PrincipalService):
+		self.config = config
+		self.principal_service = principal_service
+		self.topic = self.fake_extracted_table_to_topic(self.config)
+		self.storage = ask_topic_storage(self.topic, self.principal_service)
+		self.storage.register_topic(self.topic)
+		self.service = ask_topic_data_service(TopicSchema(self.topic), self.storage, principal_service)
+
+	# noinspection PyMethodMayBeStatic
+	def fake_topic_id(self, config_id: str) -> str:
+		return f'f-{config_id}'
+
+	def fake_extracted_table_to_topic(self, config: CollectorTableConfig) -> Topic:
+		#  Fake synonym topic to visit source table
+		topic = Topic(topicId=self.fake_topic_id(config.configId),
+		              name=config.tableName,
+		              dataSourceId=config.dataSourceId,
+		              kind=TopicKind.SYNONYM,
+		              tenantId=self.principal_service.tenantId
+		              )
+		topic_storage = ask_topic_storage(topic, self.principal_service)
+		factors = topic_storage.ask_synonym_factors(config.tableName)
+		topic.factors = factors
+		now = get_current_time_in_seconds()
+		topic.createdAt = now
+		topic.createdBy = self.principal_service.get_user_id()
+		topic.lastModifiedAt = now
+		topic.lastModifiedBy = self.principal_service.get_user_id()
+		return topic
+
+	def find_change_data(self, criteria: EntityCriteria) -> Optional[List[Dict[str, Any]]]:
+		return self.lower_key(self.service.find_straight_values(
+			criteria=criteria,
+			columns=ArrayHelper(self.config.primaryKey).map(
+				lambda column_name: EntityStraightColumn(columnName=column_name)
+			).to_list()
+		))
+
+	def find_by_id(self, data_id: Dict) -> Optional[Dict[str, Any]]:
+		results = self.service.find(build_criteria_by_primary_key(data_id))
+		if len(results) == 1:
+			return self.lower_key(results)[0]
+		elif len(results) == 0:
+			return None
+		else:
+			raise RuntimeError(f'too many results with {data_id} find')
+
+	def find(self, criteria: EntityCriteria) -> Optional[List[Dict[str, Any]]]:
+		return self.lower_key(self.service.find(criteria))
+
+	def exists(self, criteria: EntityCriteria) -> bool:
+		return self.service.exists(criteria)
+
+	# noinspection PyMethodMayBeStatic
+	def lower_key(self, data_: List) -> Optional[List[Dict]]:
+		return ArrayHelper(data_).map(
+			lambda row: {k.lower(): v for k, v in row.items()}).to_list()