在Python中是否存在非SQLAlchemy方法来处理多对多关系？

Question

I've searched for quite a long time on the web for a method that deals with many-to-many relationships in python sqlite3, but all seems to lead to Sqlalchemy. I'm not against using sqlalchemy at all(although I do find it an overkill from time to time and it does introduce some unnecessary logic in many cases), I was wondering if there is a 'golden class/function' that provides basic CRUD interface directly without bothering Sqlalchemy? Any references (online or paper-based) will be highly appreciated.

Answer 1

If you want to solve many-to-many relations in basic SQL you can do this manualy using third table for storing those relations.

CREATE TABLE users {
    int user_id,
    varchar user_name
};

CREATE TABLE categories {
    int category_id,
    varchar category_name
};

CREATE TABLE category_permission {
    int user_id,
    int category_id
};  -- for storing relations

These three tables represents two models ( user , category ) and one many-to-many relation ( category_permission )

You have to query them manualy and also manualy maintain stored relations. Based on SQL engine you are using you should consider using

• unique index in table category_permission on all two collumns
• foreing keys to maintain relations when deleting something.

You can then select this way:

-- to list all users and their category count
SELECT U.user_name, count(CP.category_id) as 'permitted'
FROM users U 
LEFT JOIN category_permission PM
    ON PM.user_id = U.user_id
ORDER BY permitted DESC;  


 -- to list all categories for __desired_user__
SELECT C.* FROM categories C
JOIN category_permission CM
    ON CM.category_id = C.category_id
WHERE CM.user_id = __desired_user_id__; 

For further reference search for SQL solution instead of Python (which will always lead you to some framework). Many-to-many relationship is a common problem in relation databases.

• Mysql database design in a many to many relationship
• MySQL many-to-many relationship with FOREIGN KEYS
• ... and so on ...

Answer 2

If you are looking at other ORMs than SqlAlchemy, you can compare the ORMs presented here: What are some good Python ORM solutions?

I personnaly tried Storm that supports Many-to-Many almost transparently but you have to write SQL to create the table (IIRC).

I also tried autumn which is dead but a fork exists: AutORM . It is very lightweight but doesn't support many-to-many. You probably can work that around by declaring your junction table explicitly and it is targeted to sqlite (see peewee).

I tested dejavu (dead) and peewee which also doesn't have many-to-many transparently but explains how to do it in its docs (you can apply the same to AutORM).

For my own case I used SqlAlchemy finally because the machinery necessary for ORMs is anyway so big that I preferred getting more functions for the price and at that time Python 3 support was not that common (my two cents :-) ).