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 update_one(collection_name, query_dict, instance, base_model):
table = get_table_model(collection_name)
session = Session(engine, future=True)
stmt = update(table)
for key, value in query_dict.items():
stmt = stmt.where(eq(getattr(table, key), value))
instance_dict: dict = convert_to_dict(instance)
values = {}
for key, value in instance_dict.items():
if key != get_primary_key(collection_name):
values[key] = value
stmt = stmt.values(values)
try:
session.execute(stmt)
session.commit()
except:
session.rollback()
raise
finally:
session.close()
return base_model.parse_obj(instance)
def update_one(one, model, name) -> any:
collection = client.get_collection(name)
primary_key = get_primary_key(name)
one_dict = __convert_to_dict(one)
query_dict = {primary_key: one_dict.get(primary_key)}
collection.update_one(query_dict, {"$set": one_dict})
return model.parse_obj(one)
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 find_by_id(id_, model, name):
collections = client.get_collection(name)
primary_key = get_primary_key(name)
result = collections.find_one({primary_key: id_})
if result is None:
return
else:
return model.parse_obj(result)
def find_by_id(id_, model, name):
table = get_table_by_name(name)
primary_key = get_primary_key(name)
stmt = select(table).where(eq(table.c[primary_key.lower()], id_))
with engine.connect() as conn:
cursor = conn.execute(stmt).cursor
columns = [col[0] for col in cursor.description]
cursor.rowfactory = lambda *args: dict(zip(columns, args))
result = cursor.fetchone()
if result is None:
return
else:
return parse_obj(model, result, table)
def update_one(one, model, name) -> any:
table = get_table_model(name)
stmt = update(table)
instance_dict: dict = convert_to_dict(one)
primary_key = get_primary_key(name)
stmt = stmt.where(
eq(getattr(table, primary_key), instance_dict.get(primary_key)))
values = {}
for key, value in instance_dict.items():
if key != get_primary_key(name):
values[key] = value
stmt = stmt.values(values)
session = Session(engine, future=True)
try:
session.execute(stmt)
session.commit()
except:
session.rollback()
raise
finally:
session.close()
return model.parse_obj(one)
def update_(where, updates, model, name):
table = get_table_by_name(name)
stmt = update(table)
stmt = stmt.where(build_oracle_where_expression(table, where))
instance_dict: dict = convert_to_dict(updates)
values = {}
for key, value in instance_dict.items():
if key != get_primary_key(name):
values[key] = value
stmt = stmt.values(values)
session = Session(engine, future=True)
try:
session.execute(stmt)
session.commit()
except:
session.rollback()
raise
finally:
session.close()
def update_one(one, model, name) -> any:
table = get_table_by_name(name)
stmt = update(table)
one_dict: dict = convert_to_dict(one)
primary_key = get_primary_key(name)
stmt = stmt.where(
eq(table.c[primary_key.lower()], one_dict.get(primary_key)))
values = {}
for key, value in one_dict.items():
if isinstance(table.c[key.lower()].type, CLOB):
if value is not None:
values[key.lower()] = dumps(value)
else:
values[key.lower()] = None
else:
values[key.lower()] = value
stmt = stmt.values(values)
with engine.connect() as conn:
with conn.begin():
conn.execute(stmt)
return model.parse_obj(one)
def delete_by_id(id_, name):
table = get_table_by_name(name)
key = get_primary_key(name)
stmt = delete(table).where(eq(table.c[key.lower()], id_))
with engine.connect() as conn:
conn.execute(stmt)
def delete_one(id_, name):
collection = client.get_collection(name)
key = get_primary_key(name)
collection.delete_one({key: id_})
