def delete_one(id: str, name: str):
table = get_table_model(name)
key = get_primary_key(name)
stmt = delete(table).where(table.c.get(key) == id)
with engine.connect() as conn:
conn.execute(stmt)
conn.commit()
def find_one(where, model, name):
table = get_table_model(name)
stmt = select(table)
stmt = stmt.where(build_where_expression(table, where))
with engine.connect() as conn:
result = conn.execute(stmt).first()
conn.commit()
return parse_obj(model, result[0])
def find_by_id(id, model, name):
table = get_table_model(name)
primary_key = get_primary_key(name)
stmt = select(table).where(eq(getattr(table, primary_key), id))
with engine.connect() as conn:
result = conn.execute(stmt)
conn.commit()
return parse_obj(model, result[0])
def upsert(where, updates, model, name):
table = get_table_model(name)
instance_dict: dict = convert_to_dict(updates)
stmt = insert(table)
stmt = stmt.values(updates)
stmt = stmt.on_duplicate_key_update(instance_dict)
with engine.connect() as conn:
conn.execute(stmt)
conn.commit()
return model.parse_obj(updates)
def query_topic_instance(topic_name, conditions):
metadata = MetaData()
table = Table('topic_' + topic_name,
metadata,
autoload=True,
autoload_with=engine)
stmt = select(table).where(*build_where_expression(table, conditions))
with engine.connect() as conn:
result = conn.execute(stmt)
conn.commit()
return result
def list_(where, model, name) -> list:
table = get_table_model(name)
stmt = select(table).where(where)
with engine.connect() as conn:
res = conn.execute(stmt)
conn.commit()
result = []
for row in res:
for item in row:
result.append(parse_obj(model, item))
return result
def insert_all(data, model, name):
metadata = MetaData()
table = Table(name, metadata, autoload=True, autoload_with=engine)
stmt = insert(table)
value_list = []
for item in data:
instance_dict: dict = convert_to_dict(item)
values = {}
for key in table.c.keys():
values[key] = instance_dict.get(key)
value_list.append(values)
with engine.connect() as conn:
result = conn.execute(stmt, value_list)
conn.commit()
def page(where, sort, pageable, model, name) -> DataPage:
count = count_table(name)
table = get_table_model(name)
stmt = select(table).where(build_where_expression(where)).order_by(sort)
offset = pageable.pageSize * (pageable.pageNumber - 1)
stmt = stmt.offset(offset).limit(pageable.pageSize)
result = []
with engine.connect() as conn:
res = conn.execute(stmt)
conn.commit()
for row in res:
for item in row:
result.append(parse_obj(model, item))
return build_data_pages(pageable, result, count)
def insert_topic_instances(topic_name, instances):
metadata = MetaData()
table = Table('topic_' + topic_name,
metadata,
autoload=True,
autoload_with=engine)
values = []
for instance in instances:
instance_dict: dict = convert_to_dict(instance)
value = {}
for key in table.c.keys():
value[key] = instance_dict.get(key)
values.append(value)
stmt = insert(table)
with engine.connect() as conn:
result = conn.execute(stmt, values)
conn.commit()
def delete_(where, model, name):
table = get_table_model(name)
stmt = delete(table).where(where)
with engine.connect() as conn:
conn.execute(stmt)
conn.commit()
