Процедура, создающая запись в таблице «func_body»:

def create_func_body(new_func_id: int, new_conjunction_num: int, new_predicate_id: int, new_inversio: bool) -> int:

try:

cursor.execute('SELECT COUNT(*) from func_body WHERE func_id=? AND conjunction_num=? AND predicate_id=? AND inversio=?', (new_func_id, new_conjunction_num, new_predicate_id, new_inversio,))

is_already_exist = cursor.fetchone()

if is_already_exist:

is_already_exist = is_already_exist[0]

if is_already_exist:

raise ValueError(f'ошибка! запись в таблице predicate с такими параметрами: \nfunc_id=\"{new_func_id}\", conjunction_num=\"{new_conjunction_num}\", predicate_id=\"{new_predicate_id}\", inversio=\"{new_inversio}\" уже существует.')

cursor.execute(

"INSERT INTO func_body(func_id, conjunction_num, predicate_id, inversio) VALUES (?, ?, ?, ?);",

(new_func_id, new_conjunction_num, new_predicate_id, new_inversio)

)

conn.commit()

print(f'запись в таблице predicate с такими параметрами: \nfunc_id=\"{new_func_id}\", conjunction_num=\"{new_conjunction_num}\", predicate_id=\"{new_predicate_id}\", inversio=\"{new_inversio}\" успешно создана')

return cursor.rowcount

except (sqlite3.Error, ValueError) as e:

print(f'Ошибка при создании тела функции в create_func_body: {e}')

Процедура, вычисляющая допустимость данного варианта исполнения согласно спецификациями заданным для его типового изделия с конфигуратором:

def check_spec_obj_variant(obj_id_val: int) -> bool:

try:

# Проверка наличия объекта

cursor.execute("SELECT product_name, configurable_type FROM product WHERE id = ?", (obj_id_val,))

obj_data = cursor.fetchone()

if not obj_data:

raise ValueError(f"Объект с id {obj_id_val} не найден")

product_name, configurable_type = obj_data

# Если объект — это вариант исполнения, найти связанное типовое изделие

if configurable_type == 2:

cursor.execute("""

SELECT id FROM product

WHERE product_name = ? AND configurable_type = 1

LIMIT 1

""", (product_name,))

conf_obj = cursor.fetchone()

if not conf_obj:

raise ValueError(f"Типовое изделие с именем '{product_name}' и configurable_type=1 не найдено")

conf_obj_id = conf_obj[0]

print(f"Найдено типовое изделие с id {conf_obj_id} для объекта {obj_id_val}")

# Переходим к проверке функций и предикатов типового изделия

return check_spec_for_typical_product(obj_id_val, conf_obj_id)

# Если объект — это типовое изделие, возвращаем ошибку (рекурсия невозможна)

raise ValueError(f"Объект с id {obj_id_val} не является вариантом исполнения и не может быть проверен напрямую.")

except Exception as e:

print(f"Ошибка в check_spec_obj_variant: {e}")

return False

Вспомогательная процедура(проверяет спецификацию для продукции конкретного экземпляра) для процедуры check_spec_obj_variant(obj_id_val: int)

def check_spec_for_typical_product(original_obj_id: int, typical_obj_id: int) -> bool:

try:

# Проверка наличия функций для типового изделия

cursor.execute("SELECT func_id FROM prod_spec WHERE prod_id = ?", (typical_obj_id,))

func_ids = [row[0] for row in cursor.fetchall()]

if not func_ids:

print(f"Для типового изделия с id {typical_obj_id} функции не найдены.")

return False

# Проверка всех функций

for func_id in func_ids:

print(f"Проверка функции с id {func_id}")

conjunction_result = True

last_conjunction_num = -1

func_result = True # Теперь начальное значение для всех функций — True

# Получаем предикаты для функции

cursor.execute("SELECT conjunction_num, predicate_id, inversio FROM func_body WHERE func_id = ? ORDER BY conjunction_num", (func_id,))

predicates = cursor.fetchall()

print(f'predicates - {predicates}')

for conjunction_num, predicate_id, inversio in predicates:

predicate_result = True # Начальное значение для каждого предиката

# Получаем данные предиката

cursor.execute("SELECT operator_id, param_id, enum_pos_id FROM predicate WHERE id = ?", (predicate_id,))

pred = cursor.fetchone()

if not pred:

raise ValueError(f"Предикат с id {predicate_id} не найден")

operator_id, param_id, enum_pos_id = pred

print(f'operator_id={operator_id}, param_id={param_id}, enum_pos_id={enum_pos_id}')

# Проверка параметра исходного объекта (original_obj_id)

cursor.execute("SELECT int_value, real_value, str_value FROM prod_param WHERE prod_id = ? AND param_id = ?", (original_obj_id, param_id))

obj_param = cursor.fetchone()

if not obj_param:

print(f"Параметр с param_id {param_id} отсутствует у объекта с id {original_obj_id}")

predicate_result = False # Если параметр отсутствует, предикат сразу False

else:

# Получаем данные enum для сравнения

cursor.execute("SELECT int_value, real_value, str_value FROM enum WHERE id = ?", (enum_pos_id,))

enum_param = cursor.fetchone()

# Получаем строковое значение оператора

cursor.execute("SELECT str_value FROM enum WHERE id = ?", (operator_id,))

op_str_val = cursor.fetchone()[0]

# Применение инверсии: заменяем оператор на противоположный

if inversio:

if op_str_val == '=':

op_str_val = '!='

elif op_str_val == '<':

op_str_val = '>='

else:

raise ValueError(f"Инверсия не поддерживается для оператора {op_str_val}")

print(f"Инвертированный оператор: {op_str_val}")

# Формируем строку описания условия

predicate_description = f"[Проверяем предикат: param_id={param_id}, оператор='{op_str_val}', значение объекта={obj_param}, значение сравнения={enum_param}]"

# Сравнение значений

if obj_param[0] is not None and enum_param[0] is not None: # int

if op_str_val == '=':

predicate_result = obj_param[0] == enum_param[0]

elif op_str_val == '!=':

predicate_result = obj_param[0] != enum_param[0]

elif op_str_val == '<':

predicate_result = obj_param[0] < enum_param[0]

elif op_str_val == '>=':

predicate_result = obj_param[0] >= enum_param[0]

elif obj_param[1] is not None and enum_param[1] is not None: # real

if op_str_val == '=':

predicate_result = obj_param[1] == enum_param[1]

elif op_str_val == '!=':

predicate_result = obj_param[1] != enum_param[1]

elif op_str_val == '<':

predicate_result = obj_param[1] < enum_param[1]

elif op_str_val == '>=':

predicate_result = obj_param[1] >= enum_param[1]

elif obj_param[2] is not None and enum_param[2] is not None: # string

if op_str_val == '=':

predicate_result = obj_param[2] == enum_param[2]

elif op_str_val == '!=':

predicate_result = obj_param[2] != enum_param[2]

else:

raise ValueError(f"Инверсия не поддерживается для строковых данных с оператором {op_str_val}")

else:

predicate_result = False # Если ни один тип данных не подошел

# Добавляем результат проверки в описание

predicate_description += f" -> Результат: {'True' if predicate_result else 'False'}"

print(predicate_description)

# Объединение результатов по conjunction_num

if last_conjunction_num == conjunction_num:

conjunction_result = conjunction_result and predicate_result

print(f"conjunction_result (обновленный): {conjunction_result}")

elif last_conjunction_num == -1:

conjunction_result = predicate_result

last_conjunction_num = conjunction_num

print(f"conjunction_result (начальный): {conjunction_result}")

else:

# Обновляем общий результат функции

func_result = func_result and conjunction_result

print(f"func_result (обновленный): {func_result}")

conjunction_result = predicate_result

last_conjunction_num = conjunction_num

# Финальный результат функции

func_result = func_result and conjunction_result

print(f"Финальный func_result для функции {func_id}: {func_result}")

# Если хотя бы одна функция возвращает False, возвращаем False

if not func_result:

print(f"Функция с id {func_id} для типового изделия {typical_obj_id} возвращает False.")

return False

# Если все функции возвращают True, результат True

print(f"Все функции для типового изделия с id {typical_obj_id} возвращают True.")

return True

except Exception as e:

print(f"Ошибка в check_spec_for_typical_product: {e}")

return False