How to achieve backref-like query in Node.js and sqlite? - sql

Question

Short Version: Is there an application in Node.js that offers functionalities similar to Python-SQLAlchemy's backref?
What I actually want to achieve:
I have three sql tables: article, chapter and subchapter. One article has multiple chapters, and on chapter can contain multiple or zero subchapter.
With SQLAlchemy it's quite simple, in models.py
class Article(db.Model):
...
chapters = db.relationship('Chapter', backref='mainArticle', lazy=True)
class Chapter(db.Model):
...
articleID = db.Column(db.Integer, db.ForeignKey('article.id'), nullable=False)
subChapters = db.relationship('subChapter', backref='mainChapter', lazy=True)
class subChapter(db.Model):
...
chapterID = db.Column(db.Integer, db.ForeignKey('chapter.id'), nullable=False)
And then I can access even the attributes of Article from subChapter:
subchapter = subChapter.query.first()
subchapter.mainChapter.id # Returns the chapter ID
subchapter.mainChapter.mainArticle.id # Returns the article ID
I've been using SQLAlchemy so I'm not sure how to select with SQLite, I tried:
app.get('/test/:articleID', (req, res) => {
let article_id = req.params.articleID;
let sql = `SELECT article.*, chapter.*, subchapter.*
FROM article
LEFT JOIN chapter ON article.id = chapter.articleID
LEFT JOIN subchapter ON chapter.id = subchapter.chapterID
WHERE article.id = ?`;
db.get(sql, [article_id], (err, article) => {
res.send(article)
});
})
But it just spit out a bunch of null...
Unfortunately current situation forces me to use Node.js instead of Python, so is there any way to achieve a similar result in Node.js?

Answer 1

Ok after some trials and errors I figured out a not-so-elegant way (maybe an ugly way) to get the job done without any third-party application.
First we select ALL the rows of the database that are linked to a article number with LEFT JOIN method. The null problem seems to be caused by identical key name in different tables (i.e. article.title, chapter.title, subchapter.title), so just distinguish them with AS method.
SELECT article.title,
chapter.title AS cT, chapter.chapterNumber AS cN,
subchapter.title AS scT, subchapter.subChapterNumber AS scN
FROM article
LEFT JOIN chapter ON article.id = chapter.articleID
LEFT JOIN subchapter ON chapter.id = subchapter.chapterID
WHERE article.id = 1
ORDER BY
chapterNumber ASC,
subChapterNumber ASC
This will get a bunch of entries where every subchapter is shown once, every chapter is shown at least once, depending on the subchapters it has.
Now we can write an iteration to sort the data. The fundamental idea is to form an article object, with a chapter property that contains an array of chapter objects, each one contains a subchapter property populated with an array of its own subchapter objects:
article = {
"title": "Article Title",
"chapters": [
{
"chapterNumber": 1,
"subchapters": [
{
"subchapterNumber": 1,
},
{
"subchapterNumber": 2,
}
]
},
{
"chapterNumber": 2,
"subchapters": []
},
]
}
Then we can simply use article.chapters[0] to access the chapter 1, and use article.chapters[0].subchapters[0] to get chapter 1.1.
To achieve this, the iteration to organise the data would be:
article = {"title":entries[0].title, "chapters":[]};
// First create all the chapter entries for subchapters to depend on.
for (i in entries) {
// Use underscore.js utility to determine if this chapter has already been put in.
if (_.findWhere(article.chapters, {"chapterNumber":entries[i].cN}) == null) {
// Create a new chapter entry.
article.chapters.push({"chapterNumber":entries[i].cN, "subchapters":[]})
}
};
// Then put in place all the subchapters.
for (i in entries) {
// Only analyse all the entries that contain a subchapter.
if (entries[i].scN){
// Find the corresponding chapter
chapter = _.findWhere(article.chapters, {"chapterNumber":entries[i].cN})
// Determine if this subchapter has already been put in.
if (_.findWhere(chapter.subchapters, {"subchapterNumber":entries[i].scN}) == null) {
// Create a new subchapter entry.
chapter.subchapters.push({"chapterNumber":entries[i].cN, "subchapterNumber":entries[i].scN})
}
}
};
The same principal still applies if the database is more complicated, like if every subchapter contains zero to multiple secondary subchapters.
Now a single article object contains all the informations we can possibly need to display an article in its order. A simple run with pug to display the schema would be:
html
head
title= article.title
body
each chapter in article.chapters
li= chapter.title
each subchapter in chapter.subchapters
li(style="padding-left:30px")= subchapter.title
This might not be quite efficient, but it at least get the job done. Please tell me if you know any better solution. Happy coding to everyone!