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】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    Which Photography app has the highest total Sentiment subjectivity score? Photography app refers to Genre = 'Photography'; highest total sentiment subjectivity score = MAX(sum(Sentiment_Subjectivity));

    【Evidence】
    Photography app refers to Genre = 'Photography'; highest total sentiment subjectivity score = MAX(sum(Sentiment_Subjectivity));

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

SQL: SELECT T1.App FROM playstore AS T1 INNER JOIN user_reviews AS T2 ON T1.App = T2.App WHERE T1.Genres = 'Photography' GROUP BY T1.App ORDER BY SUM(T2.Sentiment_Subjectivity) DESC LIMIT 1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    List all the comments on the lowest rated Mature 17+ app. comments refers to Translated_Review; lowest rated refers to Rating = 1; Mature 17+ refers to Content Rating = 'Mature 17+ ';

    【Evidence】
    comments refers to Translated_Review; lowest rated refers to Rating = 1; Mature 17+ refers to Content Rating = 'Mature 17+ ';

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

SQL: SELECT T2.Translated_Review FROM playstore AS T1 INNER JOIN user_reviews AS T2 ON T1.App = T2.App WHERE T1."Content Rating" = 'Mature 17+' ORDER BY T1.Rating LIMIT 1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    What is the number of installments of the app with the highest total Sentiment polarity score? installments refers to Installs; highest total sentiment polarity score = MAX(SUM(Sentiment_Polarity));

    【Evidence】
    installments refers to Installs; highest total sentiment polarity score = MAX(SUM(Sentiment_Polarity));

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

SQL: SELECT T1.Installs FROM playstore AS T1 INNER JOIN user_reviews AS T2 ON T1.App = T2.App GROUP BY T1.App ORDER BY SUM(T2.Sentiment_Polarity) DESC LIMIT 1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    What is the number of neutral comments from all the weather apps? neutral comments refers to Sentiment = 'Neutral'; weather app refers to Genre = 'Weather';

    【Evidence】
    neutral comments refers to Sentiment = 'Neutral'; weather app refers to Genre = 'Weather';

    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.Sentiment) FROM playstore AS T1 INNER JOIN user_reviews AS T2 ON T1.App = T2.App WHERE T1.Genres = 'Weather' AND T2.Sentiment = 'Neutral'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    Which 1,000,000,000+ intalls apps has the most no comment reviews? no comment refers to Translated_Review = 'nan'; most no comment reviews = (MAX(COUNT(Translated_Review = 'nan')));

    【Evidence】
    no comment refers to Translated_Review = 'nan'; most no comment reviews = (MAX(COUNT(Translated_Review = 'nan')));

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

SQL: SELECT T1.App FROM playstore AS T1 INNER JOIN user_reviews AS T2 ON T1.App = T2.App WHERE T1.Installs = '1,000,000+' AND T2.Translated_Review = 'nan' GROUP BY T1.App ORDER BY COUNT(T2.Translated_Review) DESC LIMIT 1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    What is the rating and the total Sentiment subjectivity score of "Onefootball - Soccer Scores"? Onefootball - Soccer Scores refers to App = 'Onefootball - Soccer Scores';

    【Evidence】
    Onefootball - Soccer Scores refers to App = 'Onefootball - Soccer Scores';

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

SQL: SELECT T1.Rating, SUM(T2.Sentiment_Subjectivity) FROM playstore AS T1 INNER JOIN user_reviews AS T2 ON T1.App = T2.App WHERE T1.App = 'Onefootball - Soccer Scores'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    What percentage of no comment reviews are from "Teen" content rating apps? no comment refers to Translated_Review = 'nan'; percentage = DIVIDE((SUM(Content Rating = 'Teen')), COUNT(*));

    【Evidence】
    no comment refers to Translated_Review = 'nan'; percentage = DIVIDE((SUM(Content Rating = 'Teen')), COUNT(*));

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

SQL: SELECT CAST(COUNT(CASE WHEN T1.`Content Rating` = 'Teen' THEN 1 ELSE NULL END) AS REAL) * 100 / COUNT(T1.App) FROM playstore AS T1 INNER JOIN user_reviews AS T2 ON T1.App = T2.App WHERE T2.Translated_Review = 'nan'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    Which apps have 5 rating? List out then application name. application name refers to App;

    【Evidence】
    application name refers to App;

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

SQL: SELECT DISTINCT App FROM playstore WHERE Rating = 5
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    Which apps have been reviewed more than 75 000 000 times and the content is suitable for teenagers? Reviews>75000000; suitable for teenagers refers to Content Rating = 'Teen';

    【Evidence】
    Reviews>75000000; suitable for teenagers refers to Content Rating = 'Teen';

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

SQL: SELECT DISTINCT App FROM playstore WHERE Reviews > 75000000 AND `Content Rating` = 'Teen'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    List out genre that have downloads more than 1000000000. downloads and installs are synonyms; Installs = '1,000,000,000+';

    【Evidence】
    downloads and installs are synonyms; Installs = '1,000,000,000+';

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

SQL: SELECT Genres FROM playstore WHERE Installs = '1,000,000,000+' GROUP BY Genres
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    What is the average price for a dating application? average price = AVG(Price where Genre = 'Dating'); dating application refers to Genre = 'Dating';

    【Evidence】
    average price = AVG(Price where Genre = 'Dating'); dating application refers to Genre = 'Dating';

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

SQL: SELECT AVG(Price) FROM playstore WHERE Genres = 'Dating'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    What is the average download for entertainment apps with size no more than 1.0 M? downloads and installs are synonyms; entertainment apps refers to Category = 'ENTERTAINMENT';

    【Evidence】
    downloads and installs are synonyms; entertainment apps refers to Category = 'ENTERTAINMENT';

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

SQL: SELECT AVG(CAST(REPLACE(REPLACE(Installs, ',', ''), '+', '') AS INTEGER)) FROM playstore WHERE Category = 'ENTERTAINMENT' AND Size < '1.0M'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    What is the average review number for application with 5 rating? average review = AVG(Review); application refers to app; Rating = 5;

    【Evidence】
    average review = AVG(Review); application refers to app; Rating = 5;

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

SQL: SELECT AVG(Reviews) FROM playstore WHERE Rating = 5
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    List out the top 3 genre for application with a sentiment review greater than 0.5. sentiment review refers to Sentiment_Polarity; Sentiment_Polarity>0.5;

    【Evidence】
    sentiment review refers to Sentiment_Polarity; Sentiment_Polarity>0.5;

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

SQL: SELECT Genres FROM playstore WHERE App IN ( SELECT App FROM user_reviews WHERE Sentiment = 'Positive' AND Sentiment_Polarity > 0.5 ORDER BY Sentiment_Polarity DESC LIMIT 3 )
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    What is the percentage of application with 4.7 rating having more positives sentiment than negative sentiment? percentage = DIVIDE(SUBTRACT(SUM(Sentiment = 'Positive')), (SUM(Sentiment = 'Negative')), SUM(Sentiment = 'Negative')) as percentage; having more positive sentiment than negative sentiment refers to Sentiment = 'Positive'>Sentiment = 'Negative';

    【Evidence】
    percentage = DIVIDE(SUBTRACT(SUM(Sentiment = 'Positive')), (SUM(Sentiment = 'Negative')), SUM(Sentiment = 'Negative')) as percentage; having more positive sentiment than negative sentiment refers to Sentiment = 'Positive'>Sentiment = 'Negative';

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

SQL: SELECT CAST(COUNT(CASE WHEN ( SELECT COUNT(CASE WHEN Sentiment = 'Positive' THEN 1 ELSE NULL END) - COUNT(CASE WHEN Sentiment = 'Negative' THEN 1 ELSE NULL END) FROM user_reviews GROUP BY App ) > 0 THEN 1 ELSE NULL END) AS REAL) * 100 / COUNT(T2.Sentiment) FROM playstore AS T1 INNER JOIN user_reviews AS T2 ON T1.App = T2.App WHERE T1.Rating = 4.7