QIAN-ME/bird_schema_data huggingface dataset:
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 music_platform_2
【Schema】
# Table: podcasts
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(itunes_id:INTEGER, Examples: [1313466221, 158973461, 139076942]),
(slug:TEXT, Examples: [scaling-global]),
(itunes_url:TEXT),
(title:TEXT, Examples: [Scaling Global])
]
# Table: runs
[
(run_at:TEXT, Examples: [2021-05-10 02:53:00, 2021-06-06 21:34:36, 2021-07-02 18:04:55]),
(max_rowid:INTEGER, Examples: [3266481, 3300773, 3329699]),
(reviews_added:INTEGER, Examples: [1215223, 13139, 11561])
]
# Table: categories
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(category:TEXT, Primary Key, Examples: [arts, arts-performing-arts, music])
]
# Table: reviews
[
(podcast_id:TEXT, Examples: [c61aa81c9b929a66f0c1db6cbe5d8548]),
(title:TEXT, Examples: [really interesting!]),
(content:TEXT),
(rating:INTEGER, Examples: [5, 1, 3]),
(author_id:TEXT, Examples: [F7E5A318989779D, F6BF5472689BD12, 1AB95B8E6E1309E]),
(created_at:TEXT, Examples: [2018-04-24T12:05:16-07:00])
]
【Foreign keys】
categories.podcast_id=podcasts.podcast_id
reviews.podcast_id=podcasts.podcast_id

    【Question】
    What is the longest review? review refers to content; longest review refers to Max(content)

    【Evidence】
    review refers to content; longest review refers to Max(content)

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT title FROM reviews ORDER BY LENGTH(content) DESC LIMIT 1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 music_platform_2
【Schema】
# Table: podcasts
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(itunes_id:INTEGER, Examples: [1313466221, 158973461, 139076942]),
(slug:TEXT, Examples: [scaling-global]),
(itunes_url:TEXT),
(title:TEXT, Examples: [Scaling Global])
]
# Table: runs
[
(run_at:TEXT, Examples: [2021-05-10 02:53:00, 2021-06-06 21:34:36, 2021-07-02 18:04:55]),
(max_rowid:INTEGER, Examples: [3266481, 3300773, 3329699]),
(reviews_added:INTEGER, Examples: [1215223, 13139, 11561])
]
# Table: categories
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(category:TEXT, Primary Key, Examples: [arts, arts-performing-arts, music])
]
# Table: reviews
[
(podcast_id:TEXT, Examples: [c61aa81c9b929a66f0c1db6cbe5d8548]),
(title:TEXT, Examples: [really interesting!]),
(content:TEXT),
(rating:INTEGER, Examples: [5, 1, 3]),
(author_id:TEXT, Examples: [F7E5A318989779D, F6BF5472689BD12, 1AB95B8E6E1309E]),
(created_at:TEXT, Examples: [2018-04-24T12:05:16-07:00])
]
【Foreign keys】
categories.podcast_id=podcasts.podcast_id
reviews.podcast_id=podcasts.podcast_id

    【Question】
    What is the review with the title "Hosts bring the show down" for? "Hosts bring the show down" refers to title of review

    【Evidence】
    "Hosts bring the show down" refers to title of review

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT title FROM podcasts WHERE podcast_id = ( SELECT podcast_id FROM reviews WHERE title = 'Hosts bring the show down' )
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 music_platform_2
【Schema】
# Table: podcasts
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(itunes_id:INTEGER, Examples: [1313466221, 158973461, 139076942]),
(slug:TEXT, Examples: [scaling-global]),
(itunes_url:TEXT),
(title:TEXT, Examples: [Scaling Global])
]
# Table: runs
[
(run_at:TEXT, Examples: [2021-05-10 02:53:00, 2021-06-06 21:34:36, 2021-07-02 18:04:55]),
(max_rowid:INTEGER, Examples: [3266481, 3300773, 3329699]),
(reviews_added:INTEGER, Examples: [1215223, 13139, 11561])
]
# Table: categories
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(category:TEXT, Primary Key, Examples: [arts, arts-performing-arts, music])
]
# Table: reviews
[
(podcast_id:TEXT, Examples: [c61aa81c9b929a66f0c1db6cbe5d8548]),
(title:TEXT, Examples: [really interesting!]),
(content:TEXT),
(rating:INTEGER, Examples: [5, 1, 3]),
(author_id:TEXT, Examples: [F7E5A318989779D, F6BF5472689BD12, 1AB95B8E6E1309E]),
(created_at:TEXT, Examples: [2018-04-24T12:05:16-07:00])
]
【Foreign keys】
categories.podcast_id=podcasts.podcast_id
reviews.podcast_id=podcasts.podcast_id

    【Question】
    Which "music" podcast has the longest title? music podcasts refers to category = 'music'; longest title refers to title = Max(length(title))

    【Evidence】
    music podcasts refers to category = 'music'; longest title refers to title = Max(length(title))

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T2.title FROM categories AS T1 INNER JOIN podcasts AS T2 ON T2.podcast_id = T1.podcast_id WHERE T1.category = 'music' ORDER BY LENGTH(T2.title) DESC LIMIT 1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 music_platform_2
【Schema】
# Table: podcasts
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(itunes_id:INTEGER, Examples: [1313466221, 158973461, 139076942]),
(slug:TEXT, Examples: [scaling-global]),
(itunes_url:TEXT),
(title:TEXT, Examples: [Scaling Global])
]
# Table: runs
[
(run_at:TEXT, Examples: [2021-05-10 02:53:00, 2021-06-06 21:34:36, 2021-07-02 18:04:55]),
(max_rowid:INTEGER, Examples: [3266481, 3300773, 3329699]),
(reviews_added:INTEGER, Examples: [1215223, 13139, 11561])
]
# Table: categories
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(category:TEXT, Primary Key, Examples: [arts, arts-performing-arts, music])
]
# Table: reviews
[
(podcast_id:TEXT, Examples: [c61aa81c9b929a66f0c1db6cbe5d8548]),
(title:TEXT, Examples: [really interesting!]),
(content:TEXT),
(rating:INTEGER, Examples: [5, 1, 3]),
(author_id:TEXT, Examples: [F7E5A318989779D, F6BF5472689BD12, 1AB95B8E6E1309E]),
(created_at:TEXT, Examples: [2018-04-24T12:05:16-07:00])
]
【Foreign keys】
categories.podcast_id=podcasts.podcast_id
reviews.podcast_id=podcasts.podcast_id

    【Question】
    List all the cagetories for all the podcasts with "jessica" in the title. podcast with 'jessica' in title refers to title like '%jessica%'

    【Evidence】
    podcast with 'jessica' in title refers to title like '%jessica%'

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT category FROM categories WHERE podcast_id IN ( SELECT podcast_id FROM podcasts WHERE title LIKE '%jessica%' )
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 music_platform_2
【Schema】
# Table: podcasts
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(itunes_id:INTEGER, Examples: [1313466221, 158973461, 139076942]),
(slug:TEXT, Examples: [scaling-global]),
(itunes_url:TEXT),
(title:TEXT, Examples: [Scaling Global])
]
# Table: runs
[
(run_at:TEXT, Examples: [2021-05-10 02:53:00, 2021-06-06 21:34:36, 2021-07-02 18:04:55]),
(max_rowid:INTEGER, Examples: [3266481, 3300773, 3329699]),
(reviews_added:INTEGER, Examples: [1215223, 13139, 11561])
]
# Table: categories
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(category:TEXT, Primary Key, Examples: [arts, arts-performing-arts, music])
]
# Table: reviews
[
(podcast_id:TEXT, Examples: [c61aa81c9b929a66f0c1db6cbe5d8548]),
(title:TEXT, Examples: [really interesting!]),
(content:TEXT),
(rating:INTEGER, Examples: [5, 1, 3]),
(author_id:TEXT, Examples: [F7E5A318989779D, F6BF5472689BD12, 1AB95B8E6E1309E]),
(created_at:TEXT, Examples: [2018-04-24T12:05:16-07:00])
]
【Foreign keys】
categories.podcast_id=podcasts.podcast_id
reviews.podcast_id=podcasts.podcast_id

    【Question】
    What is the category for the "Moist Boys" podcast? "Moist Boys" refers to title of podcast

    【Evidence】
    "Moist Boys" refers to title of podcast

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT category FROM categories WHERE podcast_id IN ( SELECT podcast_id FROM podcasts WHERE title = 'Moist Boys' )
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 music_platform_2
【Schema】
# Table: podcasts
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(itunes_id:INTEGER, Examples: [1313466221, 158973461, 139076942]),
(slug:TEXT, Examples: [scaling-global]),
(itunes_url:TEXT),
(title:TEXT, Examples: [Scaling Global])
]
# Table: runs
[
(run_at:TEXT, Examples: [2021-05-10 02:53:00, 2021-06-06 21:34:36, 2021-07-02 18:04:55]),
(max_rowid:INTEGER, Examples: [3266481, 3300773, 3329699]),
(reviews_added:INTEGER, Examples: [1215223, 13139, 11561])
]
# Table: categories
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(category:TEXT, Primary Key, Examples: [arts, arts-performing-arts, music])
]
# Table: reviews
[
(podcast_id:TEXT, Examples: [c61aa81c9b929a66f0c1db6cbe5d8548]),
(title:TEXT, Examples: [really interesting!]),
(content:TEXT),
(rating:INTEGER, Examples: [5, 1, 3]),
(author_id:TEXT, Examples: [F7E5A318989779D, F6BF5472689BD12, 1AB95B8E6E1309E]),
(created_at:TEXT, Examples: [2018-04-24T12:05:16-07:00])
]
【Foreign keys】
categories.podcast_id=podcasts.podcast_id
reviews.podcast_id=podcasts.podcast_id

    【Question】
    List all of the two-star reviews and their categories. two-stars review refers to rating = 2

    【Evidence】
    two-stars review refers to rating = 2

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T1.category FROM categories AS T1 INNER JOIN reviews AS T2 ON T2.podcast_id = T1.podcast_id WHERE T2.rating = 2
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 music_platform_2
【Schema】
# Table: podcasts
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(itunes_id:INTEGER, Examples: [1313466221, 158973461, 139076942]),
(slug:TEXT, Examples: [scaling-global]),
(itunes_url:TEXT),
(title:TEXT, Examples: [Scaling Global])
]
# Table: runs
[
(run_at:TEXT, Examples: [2021-05-10 02:53:00, 2021-06-06 21:34:36, 2021-07-02 18:04:55]),
(max_rowid:INTEGER, Examples: [3266481, 3300773, 3329699]),
(reviews_added:INTEGER, Examples: [1215223, 13139, 11561])
]
# Table: categories
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(category:TEXT, Primary Key, Examples: [arts, arts-performing-arts, music])
]
# Table: reviews
[
(podcast_id:TEXT, Examples: [c61aa81c9b929a66f0c1db6cbe5d8548]),
(title:TEXT, Examples: [really interesting!]),
(content:TEXT),
(rating:INTEGER, Examples: [5, 1, 3]),
(author_id:TEXT, Examples: [F7E5A318989779D, F6BF5472689BD12, 1AB95B8E6E1309E]),
(created_at:TEXT, Examples: [2018-04-24T12:05:16-07:00])
]
【Foreign keys】
categories.podcast_id=podcasts.podcast_id
reviews.podcast_id=podcasts.podcast_id

    【Question】
    List all the podcasts reviewed by a reviewer who has a review titled "Inspired & On Fire!". "Inspired & On Fire" refers to title of review

    【Evidence】
    "Inspired & On Fire" refers to title of review

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T1.title FROM podcasts AS T1 INNER JOIN reviews AS T2 ON T2.podcast_id = T1.podcast_id WHERE T2.title = 'Inspired & On Fire!'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 music_platform_2
【Schema】
# Table: podcasts
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(itunes_id:INTEGER, Examples: [1313466221, 158973461, 139076942]),
(slug:TEXT, Examples: [scaling-global]),
(itunes_url:TEXT),
(title:TEXT, Examples: [Scaling Global])
]
# Table: runs
[
(run_at:TEXT, Examples: [2021-05-10 02:53:00, 2021-06-06 21:34:36, 2021-07-02 18:04:55]),
(max_rowid:INTEGER, Examples: [3266481, 3300773, 3329699]),
(reviews_added:INTEGER, Examples: [1215223, 13139, 11561])
]
# Table: categories
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(category:TEXT, Primary Key, Examples: [arts, arts-performing-arts, music])
]
# Table: reviews
[
(podcast_id:TEXT, Examples: [c61aa81c9b929a66f0c1db6cbe5d8548]),
(title:TEXT, Examples: [really interesting!]),
(content:TEXT),
(rating:INTEGER, Examples: [5, 1, 3]),
(author_id:TEXT, Examples: [F7E5A318989779D, F6BF5472689BD12, 1AB95B8E6E1309E]),
(created_at:TEXT, Examples: [2018-04-24T12:05:16-07:00])
]
【Foreign keys】
categories.podcast_id=podcasts.podcast_id
reviews.podcast_id=podcasts.podcast_id

    【Question】
    What are the titles and categories of all the podcasts with a review that has "Absolutely fantastic" in it? review refers to content; 'Absolutely fantastic' in it refers to content like '%Absolutely fantastic%'

    【Evidence】
    review refers to content; 'Absolutely fantastic' in it refers to content like '%Absolutely fantastic%'

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T2.title, T1.category FROM categories AS T1 INNER JOIN podcasts AS T2 ON T2.podcast_id = T1.podcast_id INNER JOIN reviews AS T3 ON T3.podcast_id = T2.podcast_id WHERE T3.content LIKE '%Absolutely fantastic%'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 music_platform_2
【Schema】
# Table: podcasts
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(itunes_id:INTEGER, Examples: [1313466221, 158973461, 139076942]),
(slug:TEXT, Examples: [scaling-global]),
(itunes_url:TEXT),
(title:TEXT, Examples: [Scaling Global])
]
# Table: runs
[
(run_at:TEXT, Examples: [2021-05-10 02:53:00, 2021-06-06 21:34:36, 2021-07-02 18:04:55]),
(max_rowid:INTEGER, Examples: [3266481, 3300773, 3329699]),
(reviews_added:INTEGER, Examples: [1215223, 13139, 11561])
]
# Table: categories
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(category:TEXT, Primary Key, Examples: [arts, arts-performing-arts, music])
]
# Table: reviews
[
(podcast_id:TEXT, Examples: [c61aa81c9b929a66f0c1db6cbe5d8548]),
(title:TEXT, Examples: [really interesting!]),
(content:TEXT),
(rating:INTEGER, Examples: [5, 1, 3]),
(author_id:TEXT, Examples: [F7E5A318989779D, F6BF5472689BD12, 1AB95B8E6E1309E]),
(created_at:TEXT, Examples: [2018-04-24T12:05:16-07:00])
]
【Foreign keys】
categories.podcast_id=podcasts.podcast_id
reviews.podcast_id=podcasts.podcast_id

    【Question】
    Which category has the most reviews? Most review refers to Max(Count(reviews.podcast_id))

    【Evidence】
    Most review refers to Max(Count(reviews.podcast_id))

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T1.category FROM categories AS T1 INNER JOIN reviews AS T2 ON T2.podcast_id = T1.podcast_id GROUP BY T1.category ORDER BY COUNT(T2.podcast_id) DESC LIMIT 1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 music_platform_2
【Schema】
# Table: podcasts
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(itunes_id:INTEGER, Examples: [1313466221, 158973461, 139076942]),
(slug:TEXT, Examples: [scaling-global]),
(itunes_url:TEXT),
(title:TEXT, Examples: [Scaling Global])
]
# Table: runs
[
(run_at:TEXT, Examples: [2021-05-10 02:53:00, 2021-06-06 21:34:36, 2021-07-02 18:04:55]),
(max_rowid:INTEGER, Examples: [3266481, 3300773, 3329699]),
(reviews_added:INTEGER, Examples: [1215223, 13139, 11561])
]
# Table: categories
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(category:TEXT, Primary Key, Examples: [arts, arts-performing-arts, music])
]
# Table: reviews
[
(podcast_id:TEXT, Examples: [c61aa81c9b929a66f0c1db6cbe5d8548]),
(title:TEXT, Examples: [really interesting!]),
(content:TEXT),
(rating:INTEGER, Examples: [5, 1, 3]),
(author_id:TEXT, Examples: [F7E5A318989779D, F6BF5472689BD12, 1AB95B8E6E1309E]),
(created_at:TEXT, Examples: [2018-04-24T12:05:16-07:00])
]
【Foreign keys】
categories.podcast_id=podcasts.podcast_id
reviews.podcast_id=podcasts.podcast_id

    【Question】
    List the urls for all the "fiction-science-fiction" podcasts. fiction-science-fiction podcasts refers to category = 'fiction-science-fiction'; urls refers to itunes_url

    【Evidence】
    fiction-science-fiction podcasts refers to category = 'fiction-science-fiction'; urls refers to itunes_url

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT itunes_url FROM podcasts WHERE podcast_id IN ( SELECT podcast_id FROM categories WHERE category = 'fiction-science-fiction' )
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 music_platform_2
【Schema】
# Table: podcasts
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(itunes_id:INTEGER, Examples: [1313466221, 158973461, 139076942]),
(slug:TEXT, Examples: [scaling-global]),
(itunes_url:TEXT),
(title:TEXT, Examples: [Scaling Global])
]
# Table: runs
[
(run_at:TEXT, Examples: [2021-05-10 02:53:00, 2021-06-06 21:34:36, 2021-07-02 18:04:55]),
(max_rowid:INTEGER, Examples: [3266481, 3300773, 3329699]),
(reviews_added:INTEGER, Examples: [1215223, 13139, 11561])
]
# Table: categories
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(category:TEXT, Primary Key, Examples: [arts, arts-performing-arts, music])
]
# Table: reviews
[
(podcast_id:TEXT, Examples: [c61aa81c9b929a66f0c1db6cbe5d8548]),
(title:TEXT, Examples: [really interesting!]),
(content:TEXT),
(rating:INTEGER, Examples: [5, 1, 3]),
(author_id:TEXT, Examples: [F7E5A318989779D, F6BF5472689BD12, 1AB95B8E6E1309E]),
(created_at:TEXT, Examples: [2018-04-24T12:05:16-07:00])
]
【Foreign keys】
categories.podcast_id=podcasts.podcast_id
reviews.podcast_id=podcasts.podcast_id

    【Question】
    What is the content of the earliest review for the "Stuff You Should Know" podcast? "Stuff You Should Know" is the title of podcast; earliest refers to Min(created_at)

    【Evidence】
    "Stuff You Should Know" is the title of podcast; earliest refers to Min(created_at)

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T2.content FROM podcasts AS T1 INNER JOIN reviews AS T2 ON T2.podcast_id = T1.podcast_id WHERE T1.title = 'Stuff You Should Know' ORDER BY T2.created_at ASC LIMIT 1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 music_platform_2
【Schema】
# Table: podcasts
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(itunes_id:INTEGER, Examples: [1313466221, 158973461, 139076942]),
(slug:TEXT, Examples: [scaling-global]),
(itunes_url:TEXT),
(title:TEXT, Examples: [Scaling Global])
]
# Table: runs
[
(run_at:TEXT, Examples: [2021-05-10 02:53:00, 2021-06-06 21:34:36, 2021-07-02 18:04:55]),
(max_rowid:INTEGER, Examples: [3266481, 3300773, 3329699]),
(reviews_added:INTEGER, Examples: [1215223, 13139, 11561])
]
# Table: categories
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(category:TEXT, Primary Key, Examples: [arts, arts-performing-arts, music])
]
# Table: reviews
[
(podcast_id:TEXT, Examples: [c61aa81c9b929a66f0c1db6cbe5d8548]),
(title:TEXT, Examples: [really interesting!]),
(content:TEXT),
(rating:INTEGER, Examples: [5, 1, 3]),
(author_id:TEXT, Examples: [F7E5A318989779D, F6BF5472689BD12, 1AB95B8E6E1309E]),
(created_at:TEXT, Examples: [2018-04-24T12:05:16-07:00])
]
【Foreign keys】
categories.podcast_id=podcasts.podcast_id
reviews.podcast_id=podcasts.podcast_id

    【Question】
    How many reviews does "Planet Money" have? "Planet Money" is the title of podcast

    【Evidence】
    "Planet Money" is the title of podcast

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT COUNT(T2.podcast_id) FROM podcasts AS T1 INNER JOIN reviews AS T2 ON T2.podcast_id = T1.podcast_id WHERE T1.title = 'Planet Money'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 music_platform_2
【Schema】
# Table: podcasts
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(itunes_id:INTEGER, Examples: [1313466221, 158973461, 139076942]),
(slug:TEXT, Examples: [scaling-global]),
(itunes_url:TEXT),
(title:TEXT, Examples: [Scaling Global])
]
# Table: runs
[
(run_at:TEXT, Examples: [2021-05-10 02:53:00, 2021-06-06 21:34:36, 2021-07-02 18:04:55]),
(max_rowid:INTEGER, Examples: [3266481, 3300773, 3329699]),
(reviews_added:INTEGER, Examples: [1215223, 13139, 11561])
]
# Table: categories
[
(podcast_id:TEXT, Primary Key, Examples: [a00018b54eb342567c94dacfb2a3e504]),
(category:TEXT, Primary Key, Examples: [arts, arts-performing-arts, music])
]
# Table: reviews
[
(podcast_id:TEXT, Examples: [c61aa81c9b929a66f0c1db6cbe5d8548]),
(title:TEXT, Examples: [really interesting!]),
(content:TEXT),
(rating:INTEGER, Examples: [5, 1, 3]),
(author_id:TEXT, Examples: [F7E5A318989779D, F6BF5472689BD12, 1AB95B8E6E1309E]),
(created_at:TEXT, Examples: [2018-04-24T12:05:16-07:00])
]
【Foreign keys】
categories.podcast_id=podcasts.podcast_id
reviews.podcast_id=podcasts.podcast_id

    【Question】
    What is the average rating for the "crime-junkie" podcast? "crime-junkie" podcast refers to title = 'crime-junkie'; average rating = Divide (Sum(rating), Count(rating))

    【Evidence】
    "crime-junkie" podcast refers to title = 'crime-junkie'; average rating = Divide (Sum(rating), Count(rating))

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT AVG(T2.rating) FROM podcasts AS T1 INNER JOIN reviews AS T2 ON T2.podcast_id = T1.podcast_id WHERE T1.title = 'Crime Junkie'