pip is Python's package installer. The correct command is: pip install mysql-connector-python. This is run once in the terminal/command prompt before writing any Python-MySQL code.

mysql.connector.connect() creates and returns a connection object. It accepts parameters like host, user, password, and database to establish the connection.

The correct syntax uses keyword arguments: host, user, password, and database. Positional arguments are not supported and 'db' is not the correct parameter name in mysql.connector.

The host parameter specifies the address of the MySQL server. For a local machine it is 'localhost' or '127.0.0.1'. For a remote server it would be the server's IP address or domain name.

The mandatory order is: (1) Import the connector module, (2) Create a Connection, (3) Create a Cursor object, (4) Execute SQL queries, (5) Fetch results and Close the connection.

A cursor object is the tool (like a 'pen') that sends SQL statements to the MySQL server and receives the results back into Python. It is created from the connection object using conn.cursor().

The cursor is created by calling the cursor() method on the connection object: cursor = conn.cursor(). This creates a new cursor associated with the current connection.

cursor.execute(query) sends the SQL query string to the MySQL server for execution. For parameterised queries, values are passed as the second argument: cursor.execute(query, values).

cursor.fetchall() retrieves all remaining rows from the result set and returns them as a list of tuples. Each tuple represents one row from the database.

cursor.fetchone() returns None when there are no more rows to retrieve. This is commonly used as a loop condition: while row is not None: ... to process all rows one at a time.

cursor.fetchall() returns a list of tuples. Each tuple in the list represents one row from the database. Individual values are accessed by index: row[0], row[1], etc.

cursor.fetchmany(n) retrieves the next n rows from the result set as a list of tuples. It is useful when you want to process data in batches rather than all at once.

The first call to cursor.fetchone() returns the first row from the result set as a tuple. Each subsequent call returns the next row. When no rows remain, it returns None.

conn.is_connected() returns True if the connection to the MySQL server is currently active, and False otherwise. It is commonly used to verify a successful connection before executing queries.

cursor.rowcount returns the number of rows that were affected by the last DML operation (INSERT/UPDATE/DELETE) or the number of rows retrieved by the last SELECT. It is useful to confirm how many rows were processed.

Best practice is to close the cursor first, then the connection: cursor.close() then conn.close(). Closing the cursor releases its resources while keeping the connection available; closing the connection then terminates the session.

MySQL has a limit on simultaneous connections. Unclosed connections hold server resources even after the program ends. Accumulating unclosed connections can exhaust the connection pool and prevent new users from connecting.

A parameterised query uses %s as a placeholder in the SQL string for values, and passes the actual values separately as a tuple to cursor.execute(). This keeps the SQL structure and data separate.

mysql.connector uses %s as the placeholder for values in parameterised queries. Note: sqlite3 uses ? as its placeholder, but mysql.connector specifically uses %s.

The value must be passed as a tuple: ('IT',) — note the trailing comma for a single-value tuple. Passing just 'IT' as a string (not a tuple) will cause an error. mysql.connector uses %s not ?.

In Python, ('IT') without a trailing comma is NOT a tuple — it is simply the string 'IT' surrounded by parentheses. A single-element tuple REQUIRES a trailing comma: ('IT',). Without it, cursor.execute() receives a string instead of a tuple and raises a TypeError.

Parameterised queries prevent SQL Injection attacks, where malicious user input contains SQL commands that manipulate the query structure. By treating values as data (not SQL), parameterised queries neutralise this threat.

String concatenation (+ dept) directly embeds user input into SQL, allowing SQL Injection. The malicious input becomes: WHERE Dept = 'IT' OR '1'='1' — which returns ALL rows. Parameterised queries (%s with tuple) treat the input as a literal string, preventing injection.

conn.commit() permanently writes all pending DML changes to the database. Without calling commit(), the changes exist only in the current session and are lost when the connection closes.

Without conn.commit(), DML changes are stored in a temporary transaction buffer. When the connection closes, uncommitted changes are automatically rolled back — the data is never permanently saved to the database.

conn.rollback() cancels all uncommitted DML changes (INSERT, UPDATE, DELETE) and restores the database to the state it was in after the last commit(). It is typically called in the except block of a try-except-finally structure.

Each value in the INSERT must have its own %s placeholder. The values tuple must have the same number of elements as there are %s placeholders. The tuple is passed as the second argument to cursor.execute().

After a successful INSERT of one record, cursor.rowcount returns 1 — indicating that 1 row was affected. For bulk inserts using executemany(), it returns the total number of rows inserted.

cursor.executemany(query, list_of_tuples) executes the same SQL query multiple times, once for each tuple in the list. It is far more efficient than calling cursor.execute() in a loop for each row.

cursor.executemany(query, data) accepts a list of tuples as its second argument. Each tuple contains the values for one row. The query is executed once for each tuple in the list.

executemany() takes the SQL template as the first argument and a list of tuples as the second. Each tuple matches the %s placeholders in the query. The number of %s must match the number of elements in each tuple.

The tuple values must match the %s placeholders in order. SET Salary=%s → first value is 50000. WHERE EmpId=%s → second value is 101. So the tuple is (50000, 101). Option C has the values reversed.

cursor.execute() runs a single SQL statement with one set of values. cursor.executemany() runs the same SQL statement repeatedly, once for each set of values in the provided list. It is more efficient for bulk operations.

The finally block always executes regardless of whether an exception occurred or not. Placing conn.close() in finally guarantees the connection is always closed — whether the code succeeded or raised an error.

When conn.autocommit = True, every DML statement (INSERT/UPDATE/DELETE) is immediately committed after execution without needing an explicit conn.commit() call. The downside is that conn.rollback() cannot undo changes since they are committed instantly.

Option D passes 'IT' as a plain string, not a tuple. cursor.execute() expects the values to be passed as a tuple (or list). The correct form is ('IT',) with the trailing comma to make it a tuple.

cursor.fetchall() returns a list of tuples. Each tuple in the list represents one complete row from the database. Individual column values are accessed by index: row[0] for the first column, row[1] for the second, etc.

conn.commit() is missing. After executing an INSERT statement, conn.commit() must be called to permanently save the data to the database. Without it, the INSERT is rolled back when the connection closes and no data is actually saved.

cursor.rowcount returns 3 — the number of rows that matched the SELECT query condition. It reflects how many rows are in the result set, which is 3 Delhi employees.

conn.rollback() only undoes changes that have NOT yet been committed. It restores the database to the state it was in after the last conn.commit() call. Already-committed changes cannot be rolled back.

fetchall() returns a list of tuples. Rows are accessed by index — row[0] is EmpId, row[1] is Name, etc. You cannot use attribute-style access like row.Name. The result must be stored first, then iterated.

Each call to fetchone() returns the NEXT row in sequence. The first call returns row 1 (as a tuple); the second call returns row 2 (the next one). The cursor advances with each call — it does NOT restart.

The correct pattern is: fetch the first row before the loop, check if it's None in the while condition, print it, then fetch the next row at the end of the loop body. Option B skips every other row (fetches inside condition AND inside body).

Option C correctly uses a parameterised query with %s placeholder and passes the value as a single-element tuple (sal,). Option A uses string concatenation with an int (type error). Option B passes sal as a plain value, not a tuple. Option D uses f-string which is also vulnerable to injection.

cursor.fetchnext() does not exist in mysql.connector. The three valid fetch methods are: fetchone() (one row), fetchall() (all rows), and fetchmany(n) (next n rows).

cursor.fetchall() consumes ALL rows from the result set. After fetchall() is called, the cursor's position is at the end — there are no more rows to fetch. A subsequent fetchone() returns None.

autocommit = False (the default) means changes from INSERT/UPDATE/DELETE are held in a transaction and NOT permanently saved until you explicitly call conn.commit(). This allows you to use rollback() if something goes wrong.

Providing a wrong password causes MySQL to reject the connection with an 'Access Denied' error. mysql.connector raises this as a DatabaseError or InterfaceError. This is why try-except blocks are important in database connectivity code.

Option B is the only correct one: uses mysql.connector.connect() (not mysql.connect()), passes 'IT' correctly as a tuple ('IT',), uses cursor.execute() (not run()), fetches with fetchall(), iterates over rows, and properly closes both cursor and connection.

try-except-finally ensures: the try block attempts the database operations, the except block handles any errors (like wrong password or network issues), and the finally block ALWAYS runs to close the connection — even if an error occurred.

There are 4 columns (RollNo, Name, Class, Marks) so 4 %s placeholders are needed. The values tuple must also have exactly 4 elements — one for each placeholder, in the same order as the columns.

cursor.fetchmany(n) returns UP TO n rows. If fewer than n rows remain in the result set, it returns only those remaining rows. If no rows remain, it returns an empty list.

After cursor.executemany() inserts 5 rows, cursor.rowcount returns 5 — reflecting the total number of rows that were affected by the executemany() operation.

The correct import is: from mysql.connector import Error. This allows you to write except Error as e: to catch MySQL-specific exceptions like connection errors, syntax errors, and constraint violations.