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】
    What atoms are connected in single type bonds? single type bond refers to bond_type = '-';

    【Evidence】
    single type 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 T2.atom_id, T2.atom_id2 FROM bond AS T1 INNER JOIN connected AS T2 ON T1.bond_id = T2.bond_id WHERE T1.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】
    Indicate which atoms are connected in non-carcinogenic type molecules. label = '-' means molecules are non-carcinogenic

    【Evidence】
    label = '-' means molecules are non-carcinogenic

    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.atom_id FROM atom AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id INNER JOIN connected AS T3 ON T1.atom_id = T3.atom_id WHERE T2.label = '-'
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 element is the least numerous in non-carcinogenic molecules? label = '-' means molecules are non-carcinogenic; least numerous refers to MIN(COUNT(element));

    【Evidence】
    label = '-' means molecules are non-carcinogenic; least numerous refers to MIN(COUNT(element));

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

SQL: SELECT T.element FROM (SELECT T1.element, COUNT(DISTINCT T1.molecule_id) FROM atom AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id WHERE T2.label = '-' GROUP BY T1.element ORDER BY COUNT(DISTINCT T1.molecule_id) ASC LIMIT 1) 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】
    What type of bond is there between the atoms TR004_8 and TR004_20? type of bond refers to bond_type; between the atoms TR004_8 and TR004_20 refers to atom_id = 'TR004_8' AND atom_id2 = 'TR004_20' OR another way around

    【Evidence】
    type of bond refers to bond_type; between the atoms TR004_8 and TR004_20 refers to atom_id = 'TR004_8' AND atom_id2 = 'TR004_20' OR another way around

    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 FROM bond AS T1 INNER JOIN connected AS T2 ON T1.bond_id = T2.bond_id WHERE T2.atom_id = 'TR004_8' AND T2.atom_id2 = 'TR004_20' OR T2.atom_id2 = 'TR004_8' AND T2.atom_id = 'TR004_20'
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 type of label is not on molecules with atoms with tin? tin refers to element ! = 'sn'; label = '+' mean molecules are carcinogenic; label = '-' means molecules are non-carcinogenic

    【Evidence】
    tin refers to element ! = 'sn'; label = '+' mean molecules are carcinogenic; label = '-' means molecules are non-carcinogenic

    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.label FROM atom AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id WHERE T1.element != 'sn'
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 atoms with iodine and with sulfur type elements are there in single bond molecules? with iodine element refer to element = 'i'; with sulfur element refers to element = 's'; single type bond refers to bond_type = '-'; Should consider the distinct atoms when counting;

    【Evidence】
    with iodine element refer to element = 'i'; with sulfur element refers to element = 's'; single type bond refers to bond_type = '-'; Should consider the distinct atoms when counting;

    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 CASE WHEN T1.element = 'i' THEN T1.atom_id ELSE NULL END) AS iodine_nums , COUNT(DISTINCT CASE WHEN T1.element = 's' THEN T1.atom_id ELSE NULL END) AS sulfur_nums FROM atom AS T1 INNER JOIN connected AS T2 ON T1.atom_id = T2.atom_id INNER JOIN bond AS T3 ON T2.bond_id = T3.bond_id WHERE T3.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】
    Identify all connected atoms with a triple bond. 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 T2.atom_id, T2.atom_id2 FROM bond AS T1 INNER JOIN connected AS T2 ON T1.bond_id = T2.bond_id WHERE T1.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】
    Identify all the atoms that are connected to the atoms of the TR181 molecule. TR181 molecule refers to molecule_id = 'TR181'

    【Evidence】
    TR181 molecule refers to molecule_id = 'TR181'

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

SQL: SELECT T2.atom_id, T2.atom_id2 FROM atom AS T1 INNER JOIN connected AS T2 ON T2.atom_id = T1.atom_id WHERE T1.molecule_id = 'TR181'
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 percentage of carcinogenic-type molecules does not contain fluorine? label = '+' mean molecules are carcinogenic; contain fluorine refers to element = 'f'; percentage = DIVIDE(SUM(element = 'f') * 100, COUNT(molecule_id)) where label = '+'; Should consider the distinct atoms when counting;

    【Evidence】
    label = '+' mean molecules are carcinogenic; contain fluorine refers to element = 'f'; percentage = DIVIDE(SUM(element = 'f') * 100, COUNT(molecule_id)) where label = '+'; Should consider the distinct atoms when counting;

    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(DISTINCT CASE WHEN T1.element <> 'f' THEN T2.molecule_id ELSE NULL END) AS REAL) * 100 / COUNT(DISTINCT T2.molecule_id) FROM atom AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id WHERE T2.label = '+'
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 carcinogenic molecules in triple type bonds? label = '+' mean molecules are carcinogenic; triple bond refers to bond_type = '#'; percentage = DIVIDE(SUM(bond_type = '#') * 100, COUNT(bond_id)) as percent where label = '+'

    【Evidence】
    label = '+' mean molecules are carcinogenic; triple bond refers to bond_type = '#'; percentage = DIVIDE(SUM(bond_type = '#') * 100, COUNT(bond_id)) as percent where label = '+'

    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(DISTINCT CASE WHEN T2.label = '+' THEN T2.molecule_id ELSE NULL END) AS REAL) * 100 / COUNT(DISTINCT T2.molecule_id) FROM atom AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id INNER JOIN bond AS T3 ON T2.molecule_id = T3.molecule_id WHERE T3.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】
    Please list top three elements of the toxicology of the molecule TR000 in alphabetical order. TR000 is the molecule id;

    【Evidence】
    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.element FROM atom AS T WHERE T.molecule_id = 'TR000' ORDER BY T.element 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】
    What are the atoms that are bonded in the molecule TR001 with the bond ID of TR001_2_6? TR001 is the molecule id; TR001_2_6 is the bond id

    【Evidence】
    TR001 is the molecule id; TR001_2_6 is the bond id

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

SQL: SELECT SUBSTR(T.bond_id, 1, 7) AS atom_id1 , T.molecule_id || SUBSTR(T.bond_id, 8, 2) AS atom_id2 FROM bond AS T WHERE T.molecule_id = 'TR001' AND T.bond_id = 'TR001_2_6'
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 difference between the number of molecules that are carcinogenic and those that are not? label = '+' means molecules are carcinogenic; label = '-' means molecules are non-carcinogenic; difference = SUBTRACT(SUM(label = '+'), SUM(label = '-'))

    【Evidence】
    label = '+' means molecules are carcinogenic; label = '-' means molecules are non-carcinogenic; difference = SUBTRACT(SUM(label = '+'), SUM(label = '-'))

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

SQL: SELECT COUNT(CASE WHEN T.label = '+' THEN T.molecule_id ELSE NULL END) - COUNT(CASE WHEN T.label = '-' THEN T.molecule_id ELSE NULL END) AS diff_car_notcar 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】
    What are the atom IDs of the bond TR000_2_5? TR000_2_5 is the bond id

    【Evidence】
    TR000_2_5 is the bond id

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

SQL: SELECT T.atom_id FROM connected AS T WHERE T.bond_id = 'TR000_2_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 are the bond IDs that have the same atom ID 2 of TR000_2? TR000_2 is the atom id; atom ID 2 refers to atom_id2

    【Evidence】
    TR000_2 is the atom id; atom ID 2 refers to 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 T.bond_id FROM connected AS T WHERE T.atom_id2 = 'TR000_2'