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】 toxicology
【Schema】
# Table: atom
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(element:TEXT, Examples: [cl, c, h])
]
# Table: molecule
[
(molecule_id:TEXT, Primary Key, Examples: [TR000, TR001, TR002]),
(label:TEXT, Examples: [+, -])
]
# Table: bond
[
(bond_id:TEXT, Primary Key, Examples: [TR000_1_2, TR000_2_3, TR000_2_4]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(bond_type:TEXT, Examples: [-, =, #])
]
# Table: connected
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(atom_id2:TEXT, Primary Key, Examples: [TR000_2, TR000_1, TR000_3]),
(bond_id:TEXT, Examples: [TR000_1_2, TR000_2_3, TR000_2_4])
]
【Foreign keys】
atom.molecule_id=molecule.molecule_id
bond.molecule_id=molecule.molecule_id
connected.bond_id=bond.bond_id
connected.atom_id2=atom.atom_id
connected.atom_id=atom.atom_id

    【Question】
    Please list top five molecules that have double bonds in alphabetical order. double bond refers to bond_type = ' = ';

    【Evidence】
    double bond refers to bond_type = ' = ';

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

SQL: SELECT DISTINCT T.molecule_id FROM bond AS T WHERE T.bond_type = '=' ORDER BY T.molecule_id LIMIT 5
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 toxicology
【Schema】
# Table: atom
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(element:TEXT, Examples: [cl, c, h])
]
# Table: molecule
[
(molecule_id:TEXT, Primary Key, Examples: [TR000, TR001, TR002]),
(label:TEXT, Examples: [+, -])
]
# Table: bond
[
(bond_id:TEXT, Primary Key, Examples: [TR000_1_2, TR000_2_3, TR000_2_4]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(bond_type:TEXT, Examples: [-, =, #])
]
# Table: connected
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(atom_id2:TEXT, Primary Key, Examples: [TR000_2, TR000_1, TR000_3]),
(bond_id:TEXT, Examples: [TR000_1_2, TR000_2_3, TR000_2_4])
]
【Foreign keys】
atom.molecule_id=molecule.molecule_id
bond.molecule_id=molecule.molecule_id
connected.bond_id=bond.bond_id
connected.atom_id2=atom.atom_id
connected.atom_id=atom.atom_id

    【Question】
    What is the percentage of double bonds in the molecule TR008? Please provide your answer as a percentage with five decimal places. double bond refers to bond_type = '='; TR008 is the molecule id; percentage = DIVIDE(SUM(bond_type = '='), COUNT(bond_id)) as percent where molecule_id = 'TR008'

    【Evidence】
    double bond refers to bond_type = '='; TR008 is the molecule id; percentage = DIVIDE(SUM(bond_type = '='), COUNT(bond_id)) as percent where molecule_id = 'TR008'

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

SQL: SELECT ROUND(CAST(COUNT(CASE WHEN T.bond_type = '=' THEN T.bond_id ELSE NULL END) AS REAL) * 100 / COUNT(T.bond_id),5) FROM bond AS T WHERE T.molecule_id = 'TR008'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 toxicology
【Schema】
# Table: atom
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(element:TEXT, Examples: [cl, c, h])
]
# Table: molecule
[
(molecule_id:TEXT, Primary Key, Examples: [TR000, TR001, TR002]),
(label:TEXT, Examples: [+, -])
]
# Table: bond
[
(bond_id:TEXT, Primary Key, Examples: [TR000_1_2, TR000_2_3, TR000_2_4]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(bond_type:TEXT, Examples: [-, =, #])
]
# Table: connected
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(atom_id2:TEXT, Primary Key, Examples: [TR000_2, TR000_1, TR000_3]),
(bond_id:TEXT, Examples: [TR000_1_2, TR000_2_3, TR000_2_4])
]
【Foreign keys】
atom.molecule_id=molecule.molecule_id
bond.molecule_id=molecule.molecule_id
connected.bond_id=bond.bond_id
connected.atom_id2=atom.atom_id
connected.atom_id=atom.atom_id

    【Question】
    What is the percentage of molecules that are carcinogenic? Please provide your answer as a percentage with three decimal places. label = '+' mean molecules are carcinogenic; percentage = DIVIDE(SUM(label = '+'), COUNT(molecule_id)) as percent

    【Evidence】
    label = '+' mean molecules are carcinogenic; percentage = DIVIDE(SUM(label = '+'), COUNT(molecule_id)) as percent

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

SQL: SELECT ROUND(CAST(COUNT(CASE WHEN T.label = '+' THEN T.molecule_id ELSE NULL END) AS REAL) * 100 / COUNT(T.molecule_id),3) FROM molecule t
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 toxicology
【Schema】
# Table: atom
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(element:TEXT, Examples: [cl, c, h])
]
# Table: molecule
[
(molecule_id:TEXT, Primary Key, Examples: [TR000, TR001, TR002]),
(label:TEXT, Examples: [+, -])
]
# Table: bond
[
(bond_id:TEXT, Primary Key, Examples: [TR000_1_2, TR000_2_3, TR000_2_4]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(bond_type:TEXT, Examples: [-, =, #])
]
# Table: connected
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(atom_id2:TEXT, Primary Key, Examples: [TR000_2, TR000_1, TR000_3]),
(bond_id:TEXT, Examples: [TR000_1_2, TR000_2_3, TR000_2_4])
]
【Foreign keys】
atom.molecule_id=molecule.molecule_id
bond.molecule_id=molecule.molecule_id
connected.bond_id=bond.bond_id
connected.atom_id2=atom.atom_id
connected.atom_id=atom.atom_id

    【Question】
    How much of the hydrogen in molecule TR206 is accounted for? Please provide your answer as a percentage with four decimal places. hydrogen refers to element = 'h'; TR206 is the molecule id; percentage = DIVIDE(SUM(element = 'h'), COUNT(atom_id)) as percent where molecule_id = 'TR206'

    【Evidence】
    hydrogen refers to element = 'h'; TR206 is the molecule id; percentage = DIVIDE(SUM(element = 'h'), COUNT(atom_id)) as percent where molecule_id = 'TR206'

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

SQL: SELECT ROUND(CAST(COUNT(CASE WHEN T.element = 'h' THEN T.atom_id ELSE NULL END) AS REAL) * 100 / COUNT(T.atom_id),4) FROM atom AS T WHERE T.molecule_id = 'TR206'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 toxicology
【Schema】
# Table: atom
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(element:TEXT, Examples: [cl, c, h])
]
# Table: molecule
[
(molecule_id:TEXT, Primary Key, Examples: [TR000, TR001, TR002]),
(label:TEXT, Examples: [+, -])
]
# Table: bond
[
(bond_id:TEXT, Primary Key, Examples: [TR000_1_2, TR000_2_3, TR000_2_4]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(bond_type:TEXT, Examples: [-, =, #])
]
# Table: connected
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(atom_id2:TEXT, Primary Key, Examples: [TR000_2, TR000_1, TR000_3]),
(bond_id:TEXT, Examples: [TR000_1_2, TR000_2_3, TR000_2_4])
]
【Foreign keys】
atom.molecule_id=molecule.molecule_id
bond.molecule_id=molecule.molecule_id
connected.bond_id=bond.bond_id
connected.atom_id2=atom.atom_id
connected.atom_id=atom.atom_id

    【Question】
    What is the type of bond that molecule TR000 has when involved in any bonds? type of bond refers to bond_type; TR000 is the molecule id

    【Evidence】
    type of bond refers to bond_type; TR000 is the molecule id

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

SQL: SELECT DISTINCT T.bond_type FROM bond AS T WHERE T.molecule_id = 'TR000'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 toxicology
【Schema】
# Table: atom
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(element:TEXT, Examples: [cl, c, h])
]
# Table: molecule
[
(molecule_id:TEXT, Primary Key, Examples: [TR000, TR001, TR002]),
(label:TEXT, Examples: [+, -])
]
# Table: bond
[
(bond_id:TEXT, Primary Key, Examples: [TR000_1_2, TR000_2_3, TR000_2_4]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(bond_type:TEXT, Examples: [-, =, #])
]
# Table: connected
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(atom_id2:TEXT, Primary Key, Examples: [TR000_2, TR000_1, TR000_3]),
(bond_id:TEXT, Examples: [TR000_1_2, TR000_2_3, TR000_2_4])
]
【Foreign keys】
atom.molecule_id=molecule.molecule_id
bond.molecule_id=molecule.molecule_id
connected.bond_id=bond.bond_id
connected.atom_id2=atom.atom_id
connected.atom_id=atom.atom_id

    【Question】
    What are the elements of the toxicology and label of molecule TR060? TR060 is the molecule id;

    【Evidence】
    TR060 is the molecule id; 

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

SQL: SELECT DISTINCT T1.element, T2.label FROM atom AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id WHERE T2.molecule_id = 'TR060'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 toxicology
【Schema】
# Table: atom
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(element:TEXT, Examples: [cl, c, h])
]
# Table: molecule
[
(molecule_id:TEXT, Primary Key, Examples: [TR000, TR001, TR002]),
(label:TEXT, Examples: [+, -])
]
# Table: bond
[
(bond_id:TEXT, Primary Key, Examples: [TR000_1_2, TR000_2_3, TR000_2_4]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(bond_type:TEXT, Examples: [-, =, #])
]
# Table: connected
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(atom_id2:TEXT, Primary Key, Examples: [TR000_2, TR000_1, TR000_3]),
(bond_id:TEXT, Examples: [TR000_1_2, TR000_2_3, TR000_2_4])
]
【Foreign keys】
atom.molecule_id=molecule.molecule_id
bond.molecule_id=molecule.molecule_id
connected.bond_id=bond.bond_id
connected.atom_id2=atom.atom_id
connected.atom_id=atom.atom_id

    【Question】
    Which bond type accounted for the majority of the bonds found in molecule TR010 and state whether or not this molecule is carcinogenic? TR010 is the molecule id; majority of the bond found refers to MAX(COUNT(bond_type));

    【Evidence】
    TR010 is the molecule id; majority of the bond found refers to MAX(COUNT(bond_type)); 

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

SQL: SELECT T.bond_type FROM ( SELECT T1.bond_type, COUNT(T1.molecule_id) FROM bond AS T1  WHERE T1.molecule_id = 'TR010' GROUP BY T1.bond_type ORDER BY COUNT(T1.molecule_id) DESC LIMIT 1 ) AS T
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 toxicology
【Schema】
# Table: atom
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(element:TEXT, Examples: [cl, c, h])
]
# Table: molecule
[
(molecule_id:TEXT, Primary Key, Examples: [TR000, TR001, TR002]),
(label:TEXT, Examples: [+, -])
]
# Table: bond
[
(bond_id:TEXT, Primary Key, Examples: [TR000_1_2, TR000_2_3, TR000_2_4]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(bond_type:TEXT, Examples: [-, =, #])
]
# Table: connected
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(atom_id2:TEXT, Primary Key, Examples: [TR000_2, TR000_1, TR000_3]),
(bond_id:TEXT, Examples: [TR000_1_2, TR000_2_3, TR000_2_4])
]
【Foreign keys】
atom.molecule_id=molecule.molecule_id
bond.molecule_id=molecule.molecule_id
connected.bond_id=bond.bond_id
connected.atom_id2=atom.atom_id
connected.atom_id=atom.atom_id

    【Question】
    Please list top three molecules that have single bonds between two atoms and are not carcinogenic in alphabetical order. label = '-' means molecules are not carcinogenic; single type bond refers to bond_type = '-'; list top three molecules refers to return molecule_id and order by molecule_id;

    【Evidence】
    label = '-' means molecules are not carcinogenic; single type bond refers to bond_type = '-'; list top three molecules refers to return molecule_id and order by molecule_id;

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

SQL: SELECT DISTINCT T2.molecule_id FROM bond AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id WHERE T1.bond_type = '-' AND T2.label = '-' ORDER BY T2.molecule_id LIMIT 3
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 toxicology
【Schema】
# Table: atom
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(element:TEXT, Examples: [cl, c, h])
]
# Table: molecule
[
(molecule_id:TEXT, Primary Key, Examples: [TR000, TR001, TR002]),
(label:TEXT, Examples: [+, -])
]
# Table: bond
[
(bond_id:TEXT, Primary Key, Examples: [TR000_1_2, TR000_2_3, TR000_2_4]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(bond_type:TEXT, Examples: [-, =, #])
]
# Table: connected
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(atom_id2:TEXT, Primary Key, Examples: [TR000_2, TR000_1, TR000_3]),
(bond_id:TEXT, Examples: [TR000_1_2, TR000_2_3, TR000_2_4])
]
【Foreign keys】
atom.molecule_id=molecule.molecule_id
bond.molecule_id=molecule.molecule_id
connected.bond_id=bond.bond_id
connected.atom_id2=atom.atom_id
connected.atom_id=atom.atom_id

    【Question】
    Please list top two bonds that happened with the molecule TR006 in alphabetical order. TR006 is the molecule id

    【Evidence】
    TR006 is the molecule id

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

SQL: SELECT DISTINCT T2.bond_id FROM atom AS T1 INNER JOIN connected AS T2 ON T1.atom_id = T2.atom_id WHERE T1.molecule_id = 'TR006' ORDER BY T2.bond_id LIMIT 2
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 toxicology
【Schema】
# Table: atom
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(element:TEXT, Examples: [cl, c, h])
]
# Table: molecule
[
(molecule_id:TEXT, Primary Key, Examples: [TR000, TR001, TR002]),
(label:TEXT, Examples: [+, -])
]
# Table: bond
[
(bond_id:TEXT, Primary Key, Examples: [TR000_1_2, TR000_2_3, TR000_2_4]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(bond_type:TEXT, Examples: [-, =, #])
]
# Table: connected
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(atom_id2:TEXT, Primary Key, Examples: [TR000_2, TR000_1, TR000_3]),
(bond_id:TEXT, Examples: [TR000_1_2, TR000_2_3, TR000_2_4])
]
【Foreign keys】
atom.molecule_id=molecule.molecule_id
bond.molecule_id=molecule.molecule_id
connected.bond_id=bond.bond_id
connected.atom_id2=atom.atom_id
connected.atom_id=atom.atom_id

    【Question】
    How many bonds which involved atom 12 does molecule TR009 have? TR009 is the molecule id;  involved atom 12 refers to atom_id = 'TR009_12' or atom_id2 = 'TR009_12'

    【Evidence】
    TR009 is the molecule id;  involved atom 12 refers to atom_id = 'TR009_12' or atom_id2 = 'TR009_12'

    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.bond_id) FROM bond AS T1 INNER JOIN connected AS T2 ON T1.bond_id = T2.bond_id WHERE T1.molecule_id = 'TR009' AND T2.atom_id = T1.molecule_id || '_1' AND T2.atom_id2 = T1.molecule_id || '_2'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 toxicology
【Schema】
# Table: atom
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(element:TEXT, Examples: [cl, c, h])
]
# Table: molecule
[
(molecule_id:TEXT, Primary Key, Examples: [TR000, TR001, TR002]),
(label:TEXT, Examples: [+, -])
]
# Table: bond
[
(bond_id:TEXT, Primary Key, Examples: [TR000_1_2, TR000_2_3, TR000_2_4]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(bond_type:TEXT, Examples: [-, =, #])
]
# Table: connected
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(atom_id2:TEXT, Primary Key, Examples: [TR000_2, TR000_1, TR000_3]),
(bond_id:TEXT, Examples: [TR000_1_2, TR000_2_3, TR000_2_4])
]
【Foreign keys】
atom.molecule_id=molecule.molecule_id
bond.molecule_id=molecule.molecule_id
connected.bond_id=bond.bond_id
connected.atom_id2=atom.atom_id
connected.atom_id=atom.atom_id

    【Question】
    How many molecules are carcinogenic and have the bromine element? label = '+' mean molecules are carcinogenic; have bromine element refers to element = 'br'

    【Evidence】
    label = '+' mean molecules are carcinogenic; have bromine element refers to element = 'br'

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

SQL: SELECT COUNT(DISTINCT T2.molecule_id) FROM atom AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id WHERE T2.label = '+' AND T1.element = 'br'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 toxicology
【Schema】
# Table: atom
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(element:TEXT, Examples: [cl, c, h])
]
# Table: molecule
[
(molecule_id:TEXT, Primary Key, Examples: [TR000, TR001, TR002]),
(label:TEXT, Examples: [+, -])
]
# Table: bond
[
(bond_id:TEXT, Primary Key, Examples: [TR000_1_2, TR000_2_3, TR000_2_4]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(bond_type:TEXT, Examples: [-, =, #])
]
# Table: connected
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(atom_id2:TEXT, Primary Key, Examples: [TR000_2, TR000_1, TR000_3]),
(bond_id:TEXT, Examples: [TR000_1_2, TR000_2_3, TR000_2_4])
]
【Foreign keys】
atom.molecule_id=molecule.molecule_id
bond.molecule_id=molecule.molecule_id
connected.bond_id=bond.bond_id
connected.atom_id2=atom.atom_id
connected.atom_id=atom.atom_id

    【Question】
    What are the bond type and the atoms of the bond ID of TR001_6_9? atoms refer to atom_id or atom_id2

    【Evidence】
    atoms refer to atom_id or atom_id2

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

SQL: SELECT T1.bond_type, T2.atom_id, T2.atom_id2 FROM bond AS T1 INNER JOIN connected AS T2 ON T1.bond_id = T2.bond_id WHERE T2.bond_id = 'TR001_6_9'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 toxicology
【Schema】
# Table: atom
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(element:TEXT, Examples: [cl, c, h])
]
# Table: molecule
[
(molecule_id:TEXT, Primary Key, Examples: [TR000, TR001, TR002]),
(label:TEXT, Examples: [+, -])
]
# Table: bond
[
(bond_id:TEXT, Primary Key, Examples: [TR000_1_2, TR000_2_3, TR000_2_4]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(bond_type:TEXT, Examples: [-, =, #])
]
# Table: connected
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(atom_id2:TEXT, Primary Key, Examples: [TR000_2, TR000_1, TR000_3]),
(bond_id:TEXT, Examples: [TR000_1_2, TR000_2_3, TR000_2_4])
]
【Foreign keys】
atom.molecule_id=molecule.molecule_id
bond.molecule_id=molecule.molecule_id
connected.bond_id=bond.bond_id
connected.atom_id2=atom.atom_id
connected.atom_id=atom.atom_id

    【Question】
    Which molecule does the atom TR001_10 belong to? Please state whether this molecule is carcinogenic or not. TR001_10 is the atom id; label = '+' mean molecules are carcinogenic

    【Evidence】
    TR001_10 is the atom id; label = '+' mean molecules are carcinogenic

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

SQL: SELECT T2.molecule_id , IIF(T2.label = '+', 'YES', 'NO') AS flag_carcinogenic FROM atom AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id WHERE T1.atom_id = 'TR001_10'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 toxicology
【Schema】
# Table: atom
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(element:TEXT, Examples: [cl, c, h])
]
# Table: molecule
[
(molecule_id:TEXT, Primary Key, Examples: [TR000, TR001, TR002]),
(label:TEXT, Examples: [+, -])
]
# Table: bond
[
(bond_id:TEXT, Primary Key, Examples: [TR000_1_2, TR000_2_3, TR000_2_4]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(bond_type:TEXT, Examples: [-, =, #])
]
# Table: connected
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(atom_id2:TEXT, Primary Key, Examples: [TR000_2, TR000_1, TR000_3]),
(bond_id:TEXT, Examples: [TR000_1_2, TR000_2_3, TR000_2_4])
]
【Foreign keys】
atom.molecule_id=molecule.molecule_id
bond.molecule_id=molecule.molecule_id
connected.bond_id=bond.bond_id
connected.atom_id2=atom.atom_id
connected.atom_id=atom.atom_id

    【Question】
    How many molecules have a triple bond type? triple bond refers to bond_type = '#';

    【Evidence】
    triple bond refers to bond_type = '#';

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

SQL: SELECT COUNT(DISTINCT T.molecule_id) FROM bond AS T WHERE T.bond_type = '#'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 toxicology
【Schema】
# Table: atom
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(element:TEXT, Examples: [cl, c, h])
]
# Table: molecule
[
(molecule_id:TEXT, Primary Key, Examples: [TR000, TR001, TR002]),
(label:TEXT, Examples: [+, -])
]
# Table: bond
[
(bond_id:TEXT, Primary Key, Examples: [TR000_1_2, TR000_2_3, TR000_2_4]),
(molecule_id:TEXT, Examples: [TR000, TR001, TR002]),
(bond_type:TEXT, Examples: [-, =, #])
]
# Table: connected
[
(atom_id:TEXT, Primary Key, Examples: [TR000_1, TR000_2, TR000_3]),
(atom_id2:TEXT, Primary Key, Examples: [TR000_2, TR000_1, TR000_3]),
(bond_id:TEXT, Examples: [TR000_1_2, TR000_2_3, TR000_2_4])
]
【Foreign keys】
atom.molecule_id=molecule.molecule_id
bond.molecule_id=molecule.molecule_id
connected.bond_id=bond.bond_id
connected.atom_id2=atom.atom_id
connected.atom_id=atom.atom_id

    【Question】
    How many connections does the atom 19 have? connections refers to bond_id; atom 19 refers to atom_id like 'TR%_19';

    【Evidence】
    connections refers to bond_id; atom 19 refers to atom_id like 'TR%_19';

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

SQL: SELECT COUNT(T.bond_id) FROM connected AS T WHERE SUBSTR(T.atom_id, -2) = '19'