Interface of python with SQL Quiz Class 12

✅ Answer: (b) Establishes a connection to an SQL database

connect() (e.g. mysql.connector.connect(host=..., user=..., password=..., database=...)) opens a live connection to an SQL database server, which your program then uses for all further queries.

✅ Answer: (c) cursor()

You call .cursor() on an existing connection object (e.g. mycursor = mydb.cursor()) to get a cursor — the object actually used to execute SQL commands and fetch results.

✅ Answer: (a) Executes SQL queries

cursor.execute(query) runs the given SQL query string against the connected database — this is the core method for sending any SELECT, INSERT, UPDATE, or DELETE statement.

✅ Answer: (a) commit()

connection.commit() permanently saves any changes made by INSERT, UPDATE, or DELETE statements. Without calling it, those changes may be lost or rolled back once the connection closes.

✅ Answer: (c) fetchone()

cursor.fetchone() returns the next unread row from the result set as a tuple, or None if there are no more rows left.

✅ Answer: (c) execute(“INSERT …”)

There’s no special “insert” method — you simply pass a standard SQL INSERT statement as a string into execute(), just like any other query, e.g. cursor.execute("INSERT INTO Students VALUES (%s, %s, %s)", data).

✅ Answer: (b) Fetches all the rows of the result set as a list of tuples

cursor.fetchall() retrieves every remaining row from the result set at once, returning them as a list of tuples — one tuple per row.

✅ Answer: (a) cursor.rowcount (accessed as a property, WITHOUT parentheses)

cursor.rowcount is a property, not a method — you read it directly, without calling it like a function. (This question is corrected from a version that showed it as rowcount() with parentheses, which is actually a syntax error since rowcount takes no arguments and isn’t callable at all.)

✅ Answer: (c) Fetches the NEXT unread row of the result set (only the first row if called immediately after execute())

fetchone() always returns the next unread row — it happens to be the first row only if it’s the very first call after execute(). Calling it again fetches the row after that, and so on, until it returns None. (This question is refined from a version that simply said “fetches the first row”, which is only true the first time it’s called.)

✅ Answer: (b) execute(“UPDATE …”)

Just like INSERT, an UPDATE statement is simply passed as a string to execute(): cursor.execute("UPDATE Students SET Marks = 90 WHERE RollNo = 1"), followed by commit() to save the change.

✅ Answer: (b) It acts as a placeholder for values, letting you safely pass parameters into a query and helping prevent SQL injection

%s is a placeholder in the query string — the actual values are passed separately as a tuple, e.g. cursor.execute("INSERT INTO Students VALUES (%s, %s, %s)", (1, "Riya", 85)). This keeps user input separate from the SQL command itself, which is the standard defense against SQL injection attacks.

✅ Answer: (a) Using the format() method or f-strings to insert values directly into the query text

You can also build the query text using str.format() or f-strings before passing it to execute(). However, unlike %s placeholders (which mysql.connector escapes safely), directly formatting raw values into a string is more vulnerable to SQL injection if the values come from untrusted user input.

✅ Answer: (b) To release database resources and connections properly, preventing resource leaks

Calling cursor.close() and connection.close() frees up the resources (like the open connection slot on the database server) that were being used — leaving connections open unnecessarily can eventually exhaust the database’s connection limit.

✅ Answer: (b) Wrap the database operations in a try-except block to handle potential errors gracefully

Wrapping database code in try-except lets you catch connection failures, invalid queries, or constraint violations gracefully — showing a helpful message or retrying, instead of letting the whole program crash.

✅ Answer: (b) host, user, password, and database (or similar connection details)

A typical connection call looks like mysql.connector.connect(host="localhost", user="root", password="pass", database="school") — specifying where the server is, who is connecting, their credentials, and which database to use.

✅ Answer: (b) It inserts one new row (1, ‘Riya’, 85) into the Students table, permanently saves it, and reports 1 record inserted

The %s placeholders are filled in order by the values in the data tuple, inserting exactly one new row. commit() makes that change permanent, and cursor.rowcount confirms 1 row was affected.

✅ Answer: (b) All three rows are printed, one tuple per line, in the order they were retrieved

fetchall() returns a list of all matching rows as tuples. Looping over that list with for row in results: prints each tuple one at a time: ('Riya', 90), then ('Aman', 78), then ('Kabir', 92) — a very common pattern for displaying query results.

✅ Answer: (b) The change may not be permanently saved to the database — it can be lost once the connection closes (depending on the database’s autocommit setting)

Without commit(), changes made through execute() for INSERT/UPDATE/DELETE may exist only in the current transaction and can be lost if the connection closes or the transaction is rolled back — this is exactly why commit() is a critical, easy-to-forget step in every write operation.

✅ Answer: (b) fetchone() returns just the next single row (or None); fetchall() returns every remaining row at once, as a list of tuples

fetchone() pulls one row at a time — useful when you only need the first match or want to process rows one by one without loading everything into memory. fetchall() grabs everything remaining in one go, convenient for smaller result sets you want as a complete list.

✅ Answer: (c) execute(“DELETE FROM table WHERE condition”)

Just like INSERT and UPDATE, a DELETE statement is passed as a plain SQL string to execute(): cursor.execute("DELETE FROM Students WHERE RollNo = %s", (3,)), followed by commit() to make the deletion permanent.