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 is the most common bond type? most common bond type refers MAX(COUNT(bond_type))

    【Evidence】
    most common bond type refers 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 bond_type, COUNT(bond_id) FROM bond GROUP BY bond_type ORDER BY COUNT(bond_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】
    In the non-carcinogenic molecules, how many contain chlorine atoms? non-carcinogenic molecules refers to label = '-'; chlorine atoms refers to element = 'cl'

    【Evidence】
    non-carcinogenic molecules refers to label = '-'; chlorine atoms refers to element = 'cl'

    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 T1.molecule_id) FROM molecule AS T1 INNER JOIN atom AS T2 ON T1.molecule_id = T2.molecule_id WHERE T2.element = 'cl' AND T1.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】
    Calculate the average number of oxygen atoms in single-bonded molecules. single-bonded molecules refers to bond_type = '-' ; average number of oxygen atom = AVG(element = 'o')

    【Evidence】
    single-bonded molecules refers to bond_type = '-' ; average number of oxygen atom = AVG(element = 'o')

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

SQL: SELECT AVG(oxygen_count) FROM (SELECT T1.molecule_id, COUNT(T1.element) AS oxygen_count FROM atom AS T1 INNER JOIN bond AS T2 ON T1.molecule_id = T2.molecule_id  WHERE T2.bond_type = '-' AND T1.element = 'o'  GROUP BY T1.molecule_id) AS oxygen_counts
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】
    On average how many carcinogenic molecules are single bonded? carcinogenic molecules refers to label = '+'; single-bonded refers to bond_type = '-'; average = DIVIDE(SUM(bond_type = '-'), COUNT(atom_id))

    【Evidence】
    carcinogenic molecules refers to label = '+'; single-bonded refers to bond_type = '-'; average = DIVIDE(SUM(bond_type = '-'), COUNT(atom_id))

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

SQL: SELECT AVG(single_bond_count) FROM (SELECT T3.molecule_id, COUNT(T1.bond_type) AS single_bond_count FROM bond AS T1  INNER JOIN atom AS T2 ON T1.molecule_id = T2.molecule_id INNER JOIN molecule AS T3 ON T3.molecule_id = T2.molecule_id WHERE T1.bond_type = '-' AND T3.label = '+' GROUP BY T3.molecule_id) AS subquery
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】
    In the molecule containing sodium atoms, how many are non-carcinogenic? non-carcinogenic refers to label = '-'; sodium atoms refers to element = 'na'

    【Evidence】
    non-carcinogenic refers to label = '-'; sodium atoms refers to element = 'na'

    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 T1.element = 'na' AND 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】
    Find the triple-bonded molecules which are carcinogenic. triple-bonded molecules refers to bond_type = '#'; carcinogenic refers to label = '+'

    【Evidence】
    triple-bonded molecules refers to bond_type = '#'; carcinogenic refers to label = '+'

    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 = '+'
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 carbon in double-bond molecules? carbon refers to element = 'c'; double-bond molecules refers to bond_type = '='; percentage = DIVIDE(SUM(element = 'c'), COUNT(atom_id))

    【Evidence】
    carbon refers to element = 'c'; double-bond molecules refers to bond_type = '='; percentage = DIVIDE(SUM(element = 'c'), COUNT(atom_id))

    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 = 'c' THEN T1.atom_id ELSE NULL END) AS REAL) * 100 / COUNT(DISTINCT T1.atom_id) FROM atom AS T1 INNER JOIN bond AS T2 ON T1.molecule_id = T2.molecule_id WHERE T2.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 triple type bonds are there? triple type bonds refers to bond_type = '#'

    【Evidence】
    triple type bonds 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(T.bond_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】
    In how many atoms is there no bromine? atoms with no bromine refers to element ! = 'br'

    【Evidence】
    atoms with no bromine 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 T.atom_id) FROM atom AS T WHERE T.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】
    Of the first 100 molecules in number order, how many are carcinogenic? first 100 molecules in number order refers to molecule_id between 'TR000' and 'TR099'; label = '+' means molecules are carcinogenic

    【Evidence】
    first 100 molecules in number order refers to molecule_id between 'TR000' and 'TR099'; label = '+' means 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 COUNT(T.molecule_id) FROM molecule AS T WHERE molecule_id BETWEEN 'TR000' AND 'TR099' AND T.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】
    Identify by their ID the molecules in which there is carbon. carbon refers to element = 'c';

    【Evidence】
    carbon refers to element = 'c';

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

SQL: SELECT T.molecule_id FROM atom AS T WHERE T.element = 'c'
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 elements are in the TR004_8_9 bond atoms? TR004_8_9 bond atoms refers to bond_id = 'TR004_8_9';

    【Evidence】
    TR004_8_9 bond atoms refers to bond_id = 'TR004_8_9';

    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 FROM atom AS T1 INNER JOIN connected AS T2 ON T1.atom_id = T2.atom_id WHERE T2.bond_id = 'TR004_8_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】
    What elements are in a double type bond? double type bond refers to bond_type = '=';

    【Evidence】
    double 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 DISTINCT T1.element FROM atom AS T1 INNER JOIN bond AS T2 ON T1.molecule_id = T2.molecule_id INNER JOIN connected AS T3 ON T1.atom_id = T3.atom_id WHERE T2.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】
    Which type of label is the most numerous in atoms with hydrogen? with hydrogen refers to element = 'h'; label most numerous in atoms refers to MAX(COUNT(label));

    【Evidence】
    with hydrogen refers to element = 'h'; label most numerous in atoms refers to MAX(COUNT(label)); 

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

SQL: SELECT T.label FROM ( SELECT T2.label, COUNT(T2.molecule_id) FROM atom AS T1 INNER JOIN molecule AS T2 ON T1.molecule_id = T2.molecule_id WHERE T1.element = 'h' GROUP BY T2.label ORDER BY COUNT(T2.molecule_id) DESC 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】
    Chlorine is in what type of bond? type of bond refers to bond_type; chlorine refers to element = 'cl'

    【Evidence】
    type of bond refers to bond_type; chlorine refers to element = 'cl'

    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.bond_type FROM bond AS T1 INNER JOIN connected AS T2 ON T1.bond_id = T2.bond_id INNER JOIN atom AS T3 ON T2.atom_id = T3.atom_id WHERE T3.element = 'cl'