# data[].attributes.body
The transaction should be rolled back because it violates the ACID properties. Atomicity requires all steps to succeed or none at all, but since money was deducted from Account A and not added to Account B, committing would cause data inconsistency. Rolling back restores both accounts to their original state, ensuring atomicity and consistency, while also preventing partial updates that would break isolation and ensuring the database remains reliable.

# data[].attributes.body
The transaction should be rolled back.

Atomicity

A transaction is all or nothing.

Since Step 2 failed, Step 1 must also be undone. Otherwise, Account A will lose

RM300 without Account

# data[].attributes.body
The transaction should be rolled back because Step 1 (deduct RM300 from Account A) was a success, but Step 2 (add RM300 to Account B) failed. According to the ACID rules (Atomicity and Consistency), a transaction must complete all steps correctly. If we commit now, RM300 is lost from Account A and not added to Account B, which breaks consistency. Therefore, the safe action is to roll back so both accounts return to their original state.

# data[].attributes.body
1.rolled back

2.

1. Atomicity – A transaction must be all or nothing. Since Step 2 failed, the whole transaction cannot be considered complete. Rolling back ensures Account A gets back the deducted RM300.

2. Consistency – The database must remain in a valid state. If we commit after deducting from A but failing to add to B, money will "disappear," violating consistency.

3. Isolation – Other transactions should not see partial updates. If not rolled back, other users may see Account A reduced while Account B doesn’t get the money.

4. Durability – Only successfully completed (committed) transactions are saved permanently. Since this transaction failed, it must not be saved.

# data[].attributes.body
Roll back

- ISOLATION: other transactions should not see the part

- DURABILITY: only applies after a successful commit

# data[].attributes.body
1. Rollback

2. Atomicity. Because the second step failed. If the second step failed, first step must rollback

# data[].attributes.body
The transaction should be ROLLED BACK.

Atomicity – A transaction must succeed fully or not at all. Since Step 2 failed, the whole transaction must be undone.

Consistency – If committed, RM300 would disappear (deducted from A but not added to B). Rolling back keeps the accounts correct.

Isolation – Rolling back ensures no incorrect changes affect other transactions.

Durability – Only successful transactions are saved permanently. This one failed, so it cannot be committed.

# data[].attributes.body
The transaction should be ROLLED BACK.

1. Atomicity – A transaction must succeed fully or not at all. Since Step 2 failed, the whole transaction must be undone.

2. Consistency – If committed, RM300 would disappear (deducted from A but not added to B). Rolling back keeps the accounts correct.

3. Isolation – Rolling back ensures no incorrect changes affect other transactions.

4. Durability – Only successful transactions are saved permanently. This one failed, so it cannot be committed.

# data[].attributes.body
ROLLED BACK.

Explanation:

· Atomicity requires that a transaction must be "all or nothing" - either all operations complete successfully, or none do.

· In this case:

· Step 1 (Deduct RM300 from Account A) succeeded

· Step 2 (Add RM300 to Account B) failed

· Since one part of the transaction succeeded while the other failed, the transaction is incomplete and inconsistent.

# data[].attributes.body
1. Rollback-bcs step 2 is failed.

2. According to ACID properties

-A-atomocity=its a transaction where is all or noting. Eg:if step 2 fails, step 1 must rollback.

# data[].attributes.body
1.This transaction should be rolled back.

2.According to the ACID properties:

Atomicity requires that all steps of the transaction succeed or none at all. Since Step 2 failed, the whole transaction must be undone.

Consistency ensures money is not lost or created incorrectly. If we commit, Account A would lose RM300 while Account B receives nothing, which is inconsistent.

Isolation prevents partial updates from being visible to others, so rollback maintains correctness.

Durability means only successful transactions are saved permanently. Since this transaction failed, it cannot be saved.

# data[].attributes.body
1. Atomicity

Atomicity means all steps of a transaction must succeed, or none at all.

Here, Step 1 succeeded, but Step 2 failed.

Since not all operations succeeded, the entire transaction must be undone (rollback) to maintain consistency.

2. Consistency

The database should remain in a valid state before and after the transaction.

If we commit now, RM300 would be missing (deducted from A but never added to B), which breaks consistency.

Rolling back restores the database to its original state (no money lost).

3. Isolation

Isolation ensures transactions don’t interfere with each other.

If this transaction is rolled back, it will be as if it never happened, preventing inconsistencies from leaking into other transactions.

4. Durability

Once a transaction is committed, changes must be permanent.

Since this transaction is invalid (partial failure), it cannot be committed. Only after a successful completion of all steps would durability apply.

# data[].attributes.body
This transaction should be ROLLED BACK.

Why?

1. Atomicity

A transaction must complete fully or not at all.Here, only Step 1 worked but Step 2 failed - violates Atomicity.Therefore, rollback is needed to undo the deduction from Account A.

2. Consistency

The total money before and after must remain the same.If only Account A lost money and Account B didn’t receive it, consistency is broken.

3. Isolation

Other transactions should not see incomplete updates.If committed, other users might see Account A with less money while Account B didn’t gain — incorrect.

4. Durability

Only successful transactions should be saved permanently.Since this one failed halfway, it must not be saved.

# data[].attributes.body
Question 1

The transaction should be rollback because it failed at stage 2

Question2

1. Atomicity -All steps must succeed or none at all. Since step 2 failed, we must cancel everything.

2. Consistency -The money must not disappear.

3. Isolation -Other transactions must not see half-done transfers. Rolling back hides the failure.

4. Durability -Only successful transactions should be saved permanently. Failed ones must not.

# data[].attributes.body
the transaction should be rolled back.

atomicity- all steps must succeed since step 2 failed, rollback is needed.

consistency- if commit, account A loses rm300 but account B doesnt get it, proving inconsistency.

# data[].attributes.body
1. Rollback

2. Atomicity is the most relevant ACID property in this case because it mandates that a transaction must be treated as a single, indivisible unit of work. The transaction failed at Step 2, meaning only one part of the operation (the deduction) was successful. To enforce the "all-or-nothing" rule, Atomicity requires a rollback to reverse the initial deduction, thereby ensuring no partial or inconsistent changes are left in the database.

# data[].attributes.body
The transaction must be ROLLED BACK.

Reason (using ACID):

Atomicity (All or Nothing): Step 2 failed, so we must cancel Step 1 also.

Consistency: If we only deduct from A and not add to B, money will disappear. That is not correct.

Isolation: Others should not see half-done work.

Durability: If we commit now, the wrong result will be saved forever.

# data[].attributes.body
a) ROLLBACK because the second transaction failed.

b) This leads to atomicy which means that a transaction is all or nothing. For example, if step 2 fails, step 1 must rollback.

# data[].attributes.body
The transaction should be Rollback. This is because the transaction didn't succeed from account A to account B, which would go against property of Atomicity.

# data[].attributes.body
rolled-back

based on acid properties atomicity transaction is all or noting, if step 2 fails, step 1 must rollback. database must remain in valid state after the transaction. rolled back ensure the system return to its original state

# data[].attributes.body
This transaction be roll back because according to atomicity if steps two is failed, step 1 must rollback. Rolling back ensures amount in both accounts remaining as same as before the transaction.

# data[].attributes.body
The transaction must be ROLLED BACK .

Reason :

Atomicity (All or Nothing): Step 2 failed, so we must cancel Step 1 also.

Consistency: If we only deduct from A and not add to B, money will disappear. That is not correct.

Isolation: Others should not see half-done work.

Durability: If we commit now, the wrong result will be saved forever.

# data[].attributes.body
The transaction should be Rollback. This is because Atomicity: A transfer is all-or-nothing. Step 2 (credit B) failed, so Step 1 (debit A) must be undone.

Consistency: Without rollback, total funds drop by RM300 (A lost money, B didn’t gain) It violates balance invariants.

Isolation: Until success, no other transaction should see a partial transfer. Rolling back prevents exposure of the half-done state.

Durability: Because we don’t commit, none of the partial changes become permanent.

# data[].attributes.body
The transaction should be rolled back.

Explanation using ACID properties:

Atomicity

A transaction is all or nothing. Since Step 2 failed, Step 1 (deduction) must also be undone. Otherwise, Account A will lose RM300 without Account B receiving it.

Therefore, rollback is required.

# data[].attributes.body
ROLLBACK.

Atomicity: These requires transaction 'all or nothing'. Since step 2 failed, the entire transaction must be rolled back to make sure that there is no partial changes saved. Therefore, to enforce this property, the entire transaction must be rolled back, to undo the deduction from account A. Ensure 'all or nothing'.

# data[].attributes.body
Rollback the transaction

From Atomicity of ACID properties, transaction is only single unit and if one operation is failed, none of them would've completed. In this, database returns to original due to failure at second step.

# data[].attributes.body
This transaction should be rolled back.

Reason (ACID):

Atomicity: All steps must succeed or none. Since Step 2 failed, the whole transaction fails.

Consistency: Money cannot disappear. If we commit, RM300 is lost.

Isolation & Durability: Other users must not see incomplete results, and only successful transactions should be saved.

Therefore, we must rollback to keep the accounts correct.

# data[].attributes.body
The transaction should roll back because the step 2 has failed.

Based on the ACID properties, this step is called as Atomicity. Atomicity means a transaction is all or nothing. For example, if step 2 fails, step 1 must rollback.

# data[].attributes.body
1. The transcation is ROLLBACK.

2. Because a transaction must either complete entirely (commit) or fail entirely (rollback) according to Atomicity. In this scenario, Step 1 (deducting money from Account A) succeeded, but Step 2 (adding money to Account B) failed. Because the entire transaction didn't complete successfully, it cannot be committed. Rolling it back ensures that the system returns to its original state, as if the transaction never happened. If it were committed, it would leave the system in an inconsistent state, with RM300 missing from Account A but not added to Account B.

# data[].attributes.body
The answer is: ROLLBACK

Explanation based on ACID:

1. Atomicity (All or nothing):

Since Step 2 failed, the transaction is incomplete.

To follow atomicity, we must undo Step 1 (put RM300 back in Account A).

2. Consistency:

If we commit now, Account A loses RM300 but Account B doesn’t get it.

That breaks consistency.

3. Isolation:

Isolation ensures no other transaction sees the “half-done” transfer.

4. Durability:

Durability ensures only successful, committed transactions are saved.

Therefore, this transaction should be ROLLED BACK because it did not complete successfully. According to ACID rules, either both accounts must be update

d or none at all.

# data[].attributes.body
The transaction should be rolled back because Atomicity requires all steps to succeed or none at all.

Since money was deducted from Account A but not added to Account B, the database became inconsistent.

Rolling back undoes the partial change and restores consistency.

This preserves the ACID properties of transactions.

According to the ACID properties:

-Atomicity – All steps must succeed or none at all. Here, deduction from Account A succeeded but credit to Account B failed, so rollback is required.

-Consistency – The database must remain valid. If committed, RM300 would be lost, making the system inconsistent. Rolling back restores the original state.

-Isolation – Transactions must not interfere. Rolling back prevents other transactions from seeing this incomplete transfer.

-Durability – Only successful transactions are permanent. Since this one failed midway, it cannot be committed.

# data[].attributes.body
1.Should this transaction be committed or rolled back?

=Rolled back

2.Explain why based on the ACID properties.

Atomicity = transaction must be all or nothing

In this case the step 1 is succeeded but step 2 failed so the entire transaction must be rolled

# data[].attributes.body
Roll back

because the transfer from A has been deducted while it hasn’t been received for B because there’s a failure it cannot me a commit so it’s a rollback

and when it comes to the acid properties it’s atomicity. it means if step 2 fails step one must be rollback

# data[].attributes.body
The transaction should be Rolled back .

Because Step 2 failed, committing would violate Atomicity and Consistency money would disappear from the system. Rolling back ensures both accounts return to their original state, preserving database integrity.

# data[].attributes.body
Roll back

Step 2 is failed so the transaction is not accurate to continue. Therefore it should rollback

In Acid properties

Atomicity- either all parts or non of the parts of transaction should happen.

As here step 2 is failed, whole transaction should be aborted

# data[].attributes.body
Activity Title: “Bank Transfer Challenge”

Instructions for Students:

You are simulating a bank transfer between two accounts.

Follow these steps carefully and decide whether the transaction should COMMIT or ROLLBACK.

Question:

Should this transaction be committed or rolled back?

Explain why based on the ACID properties.

# data[].attributes.body
Query Processing

the database process the user's query and come out with the results

Query Compiler

Check and translate the high-level SQL and ensure the validity of the query

Query Plan

Step by step plan in the system, translated into the valid query by the system to get the proper results from user's input

Query Optimizer

Execute and choose the most efficient query

Catalog Manager

Managing the track of all about of the data

Library of the data ( metadata )

System Catalog

Database that contains information of the metadata

Query Execution Plan

Final optimized version which is ready to be run

Command Processer

Read and check if it's valid and send to the part to modify the data

Data Manager

Handles the real data

Opens, read, fetching and storing the data

Database

Keeps and store the data

Query Result

Processed and sent in formatted data structure

# data[].attributes.body
Query processing

1. Query processing: The overall process of how the database system manage the query.

2. Query Compiler: Ensures the accuracy of the query by checking the syntax and semantics. It translates the intermediate form from high-level SQL query.

3. Query Plan: Step-by-step the system use to get the data. It is comes from the intermediate form of the query.

4. Query Optimizer: It find the other way to execute the query and choose the most effective one. It decides the the arrangement of operations, indexes to use, and join strategies.

5. Catalog Manager: managing the system catalog which is consist of Database structure, indexes, constraints and etc. Provides the optimizer with needed details of the table, indexes, and statistics.

6. System Catalog: Database’s metadata storage contains information like table structures, index definitions, and storage details.

7. Query Execution Plan: It is the confirm version of the plan and ready to be run.

8. Command Processor: Takes the plan and align with the data manager to retrieve or modify the data.

9. Data Manager: Handles data access and write it to the database storage. Database Control System is the component of a DBMS that acts as a bridge between the data stored in the database and the queries received from users or applications.

10. Database: The place where the data is stored.

11. Query Result: The processed data is returned to the user.

# data[].attributes.body
1. Query Processing

- Overall activity for a user’s query (usually in SQL) is handled by the database system.

2. Query Compiler

- It translated the high-level SQL query into a mid form.

- It checks syntax and semantics to make sure the query is valid

3. Query Plan

- A set of steps the system will use to to get data. It is produced from the mid form (the one in query compiler).

4. Query Optimizer

- It looks at many possible ways to present the query and choose the most efficient one.

- It decided the steps of the operations, indexes to use and join stratergies.

5. Catalog Manager

- Manages system catalog like metadata (database structure, indexes, constraints).

- Provides the optimizer with important details (tables, indexes and statistics)

6. System catalog

- database’s metadata storage contains information (table strusctures, index definitions and storage details)

7. Query Execution Plan

- The final optimized version of the plan, ready to run by the database engine.

8. Command processor

- Takes the execution plan and synchronize with data manager to recover or change data.

9. Data Manager

- Manage actual data access bring from and writing to database storage.

10. Database

- The physical storage where the actual data is stored.

11. Query Result

- The processed and recovered data is returned to the user in the requested format.

# data[].attributes.body
- Query Processing:

Database system control overall activity that involve user query for execution.

- Query Compiler: Transforms the query compiler into a middle form

- Query Plan: A detailed strategy for executing the query for generate from intermidate form of query.

- Query Optimizer: Analyzes different execution strategies to find the most efficient plan.

- Catalog Manager: Manages metadata about the database structure, which is used during optimization and execution.

- System Catalog: Stores metadata about the database, such as table structures and indexes

- Query Execution Plan: The optimized plan is executed to retrieve the desired data.

- Command Processor: Processes the commands from the query execution plan.

- Data Manager: Handles the actual retrieval and manipulation of data from the database.

- Database: The organized collection of data stored and managed by the system.

- Query Result: The final output of the query for the requested information to the user.

# data[].attributes.body
1. QUERY PROCESSING

This stage is a general stage where overall actions where it handles a user's query language (normally sql) by the database system.

2. QUERY COMPILER

This stage the compiler changes the high level sql query to an intermediate standard. Then, it also checks the syntax and semantics to make sure of the validity of the query.

3. QUERY PLAN

This plan is basically a set of steps need to be taken by the system to get the data. This is generated from the intermediate form of the query.

4. QUERY OPTIMIZER

This stage, the optimizer looks at all different possible ways to execute the particular query and choose the most best one. It also decides the order of operations, indexes and join strategies to use.

5. CATALOG MANAGER

This manager manages the system catalog which consists of (metadat about database structure,indexes, any constraints, and etc). It also provides the optimizer with important details about tables, indexes and needed statistics.

6. SYSTEM CATALOG

This is a database's metadata storage which contains information like tables, index definitions, and details about storage.

7. QUERY EXECUTION PLAN

This the final optimizer version of the plan, where it is ready to be run by the database engine.

8. COMMAND PROCESSOR

This takes up the execution plan before this and coordinates with the data manager to retrieve/modify the data stored.

9. DATA MANAGER

This manager handles actual data access retrieving from and writing/read

data to the database storage.

10. DATABASE

This is the physical storage where the actual data is stored.

11. QUERY RESULT

The processed and retrieved data is returned to to user in the user requested format.

# data[].attributes.body
1. Query Processing

This is the starting point, where the database system receives the query (often written in SQL) from the user

2. Query Compiler

The compiler checks if the query is written correctly (syntax check) and translates it into an internal form that the database can work with.

3. Query Plan

This is show the way of how the database could run the query, detailing the steps and methods to retrieve the needed data.

4. Query Optimizer

The optimizer looks at different possible query plans and chooses the most efficient one, using information from the System Catalog (which stores metadata about the database’s structure, indexes, and statistics).

5. Query Execution Plan

This is the final, optimized plan that the database will actually run to get the results.

6. Command Processor

This component interprets the execution plan and passes instructions to the Data Manager to fetch or update the data.

7. Data Manager

The data manager controls access to the physical database, ensuring the correct records are read or modified.

8. Database

This is where the actual data lives, stored on disk or other storage systems.

9. Query Result

After execution, the processed data is returned to the user in the required format.

# data[].attributes.body
1. Query Processing

The Overall Activity.

It starts when you send the SQL statement and ends when you get back the answer.

At this point, the system only has raw text nothing has been checked or executed yet.

2.Query Compiler

-acts like a translator.
-It takes your SQL query and converts it into an intermediate form that the database can work with internally.
-It checks:
Syntax = Is your SQL written correctly?
Semantics = Do the tables, columns, and operations you mention actually exist and make sense?
-If something is wrong, you get an error message here before anything else happens.

3.Query Plan

-Once the query is valid, the system creates a query plan or a step-by-step roadmap of how it could get the data.
-This is not yet the final optimized plan; it’s more like the first draft.

4. Query Optimizer

-The optimizer looks for the fastest and most resource-efficient way to execute the query.
-It considers:
=The order to process different parts of the query

=Which indexes to use
=Which join methods are best

-The optimizer is critical because the difference between a good and bad plan can mean seconds vs. hours in execution time.

5. Catalog Manager

This part keeps track of metadata //information about the database.
It tells the optimizer details like:

=How big each table is

=What indexes exist

=What constraints apply

-Without this info, the optimizer would be guessing.

6. System Catalog

The actual storage of metadata (also called the data dictionary).

Contains things like: Table structures, Index definitions, Column data types and Storage details

7. Query Execution Plan

After optimization, the final execution plan is produced.

This is the ready-to-run version of the plan the database will follow.

8. Command Processor

-This component takes the execution plan and works with the data manager to carry it out.

-Think of it as the coordinator that says:
Alright, step 1: do this rows. Step 2: join with that table. Step 3: filter results.

9. Data Manager

The data manager is the one that actually goes to storage and:

Fetches the data, Writes any changes back, It deals with low-level data access.

10. Database (Physical Storage)

-This is where the actual data lives =on disk or in memory.

-Could be in tables, indexes, and files.

11. Query Result

After the data is processed according to your SQL instructions, the results are sent back to you.

The output can be: A table of rows (for SELECT), A success message (for INSERT, UPDATE, DELETE)

# data[].attributes.body
1.query processing

database system handle all activities involving user's query.

2.query compiler

translate high level SQL into a format database can understand easily.

3.query plan

a step-by-step list before actually running the query.

4.query optimizer

to find the quickest way most efficient way to follow the steps.

5.catalog manager

manages system catalog involving database structure, indexes, constraints, etc.

6.system catalog

database's metadata storage that contains information like table structures, index definitions and storage details.

7.query execution plan

finalised plan that is ready to be run by database engine.

8.command processor

coordinates with data manager to retrieve data from the execution plan.

9.data manager

actually fetches and stores data in the database.

10.database

physical storage where real data is stored.

11.query result

finalized answer.

# data[].attributes.body
1. QUERY PROCESSING

This stage is a general stage where overall actions where it handles a user's query language (normally sql) by the database system.

2. QUERY COMPILER

This stage the compiler changes the high level sql query to an intermediate standard. Then, it also checks the syntax and semantics to make sure of the validity of the query.

3. QUERY PLAN

This plan is basically a set of steps need to be taken by the system to get the data. This is generated from the intermediate form of the query.

4. QUERY OPTIMIZER

This stage, the optimizer looks at all different possible ways to execute the particular query and choose the most best one. It also decides the order of operations, indexes and join strategies to use.

5. CATALOG MANAGER

This manager manages the system catalog which consists of (metadat about database structure,indexes, any constraints, and etc). It also provides the optimizer with important details about tables, indexes and needed statistics.

6. SYSTEM CATALOG

This is a database's metadata storage which contains information like tables, index definitions, and details about storage.

7. QUERY EXECUTION PLAN

This the final optimizer version of the plan, where it is ready to be run by the database engine.

8. COMMAND PROCESSOR

This takes up the execution plan before this and coordinates with the data manager to retrieve/modify the data stored.

9. DATA MANAGER

This manager handles actual data access retrieving from and writing/read

data to the database storage.

10. DATABASE

This is the physical storage where the actual data is stored.

11. QUERY RESULT

The processed and retrieved data is returned to to user in the user requested format.

# data[].attributes.body
1) query processing = is the overall activity where the user query that is usually in SQL is handled using the database system

2) query compiler = this compiler is used to translate high level SQL into intermediate form

3) query plan = is a step that the system will be using toget the data and its generated from an intermediate form of the query.

4) query optimizer = search for alternatives way to execute

The query and choose the most suitable one.

5)catalog manager= it manages the system catalog for example

metadata ant database structure indexs , constrain and etc it will also provide the optimezer along with detail that is needed., about the table, indexes and

statistic

6) system catalog= its a database metadata storage that contain information such as table structure, index definition and storage detail

7) query execution plan = it is a final optimized version of the plan and ready to be run by the database engine.

8) commad processor = it will take the execution plan and coordinate with the data manager to retrieve or modify the data

9) data managers = they will handle actual data access fetching

From and writing to the database storage.

10) database = is a physical storage where the actual data is kept

11) query result = is the processed and retrieved data is returned to the user in the requested format

# data[].attributes.body
1. Query Processing – The full process of handling a user’s request.

2. Query Compiler – Turns SQL into an intermediate form and checks it.

3. Query Plan – Steps to follow to get the data.

4. Query Optimizer – Picks the fastest, most efficient way to run it.

5. Catalog Manager – Manages database structure info for the optimizer.

6. System Catalog – Stores details like tables, indexes, and storage.

7. Query Execution Plan – Final optimized plan ready to run.

8. Command Processor – Runs the plan and works with the data manager.

9. Data Manager – Handles reading and writing data from storage.

10. Database – Physical place where data is stored.

11. Query Result – The fin

al data sent back to the user.

# data[].attributes.body
1. Query Processing – This is the starting point where the database receives a user’s query.

2. Query Compiler – This part translates the user’s SQL query into an internal format that the database system can understand. It also checks if the query syntax is correct.

3. Query Plan – Here, the database creates a step-by-step outline (plan) of how to get the requested data. This is like a blueprint for execution.

4. Query Optimizer – The optimizer looks at the query plan and finds the most efficient way to run it, such as choosing the fastest search method or reducing unnecessary steps.

5. Catalog Manager – This component manages the system catalog, which stores information about the structure of the database (tables, columns, indexes, etc.). The optimizer often uses this data to make better decisions.

6. Query Execution Plan – After optimization, a final plan is prepared, detailing exactly how the database will retrieve and process the data.

7. Command Processor – This takes the execution plan and actually carries out the commands, interacting with the data manager.

8. Data Manager – This is the part that directly handles reading and writing data in the physical database storage.

9. Database – The actual storage where all data is kept.

10. Query Result – The final output that is sent back to the user after all steps are completed.

# data[].attributes.body
1.Query Processing

is the overall activity that user’s query handled by database system.

usually in SQL

2.Query compiler

compiler that translating high level SQL query into an intermediate form.

3.Query Plan

to get the data the system will use a set of steps from a query plan. it is generated from the mid form of query.

4.Query Optimizer

the query optimizer check different ways to run your query and pick the fastest one. it figures out which steps to do first, which indexes to use.

5.Catalog Manager

managing the system catalog such as metadata about database structure, indexes and constraints.

optimizer need a details about table,indexes and statistics

6.System Catalog

it’s a database metadata storage that contains information

7.Query execution plan

final optimized version

ready to be run

8.Command processor

take execution plan

coordinate with data manager

9.Data manager

this part gets the data from storage or saves new data into it.

10.Database

the place where all the data is physically stored.

11.Query result

the final data you asked for, sent back to you in the format you wanted.

# data[].attributes.body
1. Query Processing

This is where the user's query is handled by the database system

2. Query Compiler

This translates the high-level SQL query into an intermediate form. It also checks syntax and semantics ro ensure the query is valid

3. Query Plan

This is a set of steps the system will use to get the data and it is generated from the intermediate form of the query

4. Query Optimizer

The optimzer looks at different ways to execute the query and chooses the most efficient way, ans it also decides the order of operations, indexes to use and join strategies.

5. Catalog Manager

This manager manages the system catalog and it provides the optimzer with the needed details about the tables, indexes, and statistics.

6. System Catalog

A database's metadata storage contains information like table structures, index definitions, and storage details.

7. Query Execution Plan

This is the final optimized version of the plan and is ready to be run by the database's engine

8. Command Processor

Takes the execution plan and coordinates with the data manager to retrieve or modify the data.

9. Data Manager

Handles the actual data access fetching from and writing to the database storage.

10. Database

The physical data storage where the actual data is kept

11. Query result

The processed and retrieved data is returned to the user in the requested format.

# data[].attributes.body
1. Query Proccessing:

In this process, user's query is handled by the database manager usually in SQL.

2. Query Complier:

This is the process where the query complier translates high level SQL query into an intermediate form.

It checks syntax and semantics to ensure that the query is valid.

3. Query Plan:

It's a set of steps the system will use to get the data from the intermediate query form.

4. Query Optimizer:

Query Optimizer looks at different ways to execute the query and chooses the most efficient way. It decides the order of operations, which indexes to use and join strategies.

5. Catalog Manager:

The Catalog Manager manages the system catalog, such as metadata about database structure.

6. System catalog:

System catalog is a database's metadata storage which contains information about indexes, tables, and statistics.

7. Query execution plan:

This is the final optimized stage which is ready to be used by the database engine.

8. Command Processor:

Command Processor takes the execution plan and coordinates with the data manager to retrieve and modify data

9. Data manager:

It handles actual data access fetching from and writing to the database storage.

10. Database:

The physical storage where the actual data is stored.

11. Query Result:

This is the processed and retrieved data which is returned to the user in the way the user requests.

# data[].attributes.body
1. Query Processing

This refers to the complete process by which a database system handles a user’s query written in SQL.

2. Query Compiler

The query compiler converts the SQL query into an executable form representation. During this stage, it also verifies that the query’s syntax and meaning are correct.

3. Query Plan
A query plan outlines the sequence of operations the system will perform to retrieve the requested data, based on the intermediate form of the query.

4. Query Optimizer

The optimizer evaluates various possible execution methods for a query and selects the most efficient approach. It determines the sequence of operations, the indexes to apply, and the join methods to use.

5. Catalog Manager
The catalog manager oversees the system catalog, which contains metadata describing the database’s structure, indexes, constraints, and more. It supplies the optimizer with essential information about tables, indexes, and statistical data.

6. System Catalog

This is the repository of a database’s metadata, containing details such as table designs, index configurations, and storage specifications.

7. Query Execution
The finalized and optimized plan that the database engine will execute to process the query.

8. Command Processor

Executes the query by taking the final plan and working with the data manager to access or update the data.

9. Data Manager
Responsible for reading data from and writing data to the database’s physical storage.

10. Database

The physical location where all data is stored.

# data[].attributes.body
Components inside query processing

1. Query Processing -The overall work the database does to understand and answer the question given

2.Query Compiler -Changes your SQL query into a form the computer understands and checks if there are any mistakes

3.Query Plan -A detailed set of steps on how to find the data you asked for

4.Query Optimizer -Looks at different ways to run the query and picks the fastest and most efficient method

5.Catalog Manager -Manages the information about the database’s structure and shares it with the optimizer when needed

6.System Catalog -A special storage that contains details about all tables, columns, indexes, and other database objects

7.Query Execution Plan-The final version of the plan after optimization, ready to be carried out

8.Command Processor -Sends instructions from the execution plan to the Data Manager

9.Data Manager -Handles the actual reading or updating of data in the database storage

10.Database -Where all the real data is kept

11.Query Result -The final answer that is sent back to the user

# data[].attributes.body
1. Query processing is how the database system handles a user’s SQL query.

2. The query compiler changes the SQL query into an intermediate form and checks its validity.

3. A query plan is the step-by-step method the system uses to retrieve the data.

4. The query optimizer picks the most efficient way to run the query by deciding operation order, indexes, and join methods.

5. The catalog manager handles database metadata and gives the optimizer details about tables, indexes, and statistics.

6. The system catalog stores metadata such as table structures, index definitions, and storage details.

7. A query execution plan is the final optimized plan ready for the database to run.

8. The command processor runs the execution plan and works with the data manager to get or change data.

9. The data manager reads from and writes data to the database storage.

10. The database is the physical storage holding all actual data.

11. The query result is the final data returned to the user in the desired format.

# data[].attributes.body
1. Query Processing

This is where the process starts.

The user’s SQL query (e.g., SELECT * FROM Students) is taken in for processing.

2. Query Compiler

Translates the SQL query into an internal form that the database can understand better.

Checks the query syntax and semantics (making sure it’s valid and makes sense).

3. Query Plan

A raw plan showing possible steps to retrieve the requested data.

It’s like a “first draft” of how the database might execute the query

4. Query Optimizer

Improves the raw query plan to make it faster and use fewer resources.

Chooses the most efficient way to access tables, indexes, and data.

5. Catalog Manager

Works with the System Catalog (metadata database that stores information about tables, columns, indexes, permissions, etc.).

Provides necessary information for optimization and execution planning.

6. Query Execution Plan

The final, optimized set of steps for executing the query.

Passed to the execution system.

7. Command Processor

Receives the execution plan and translates it into actual database commands.

Sends instructions to the Data Manager.

8. Data Manager

Directly interacts with the physical database storage.

Retrieves or updates the data based on the commands.

9. Database

The actual storage where all data resides (tables, indexes, files, etc.).

10. Query Result

The final output returned to the user after the query is executed.

# data[].attributes.body
Query Processing is the overall procedure of interpreting, optimizing, and executing a query to produce the desired result.

Query Compiler converts a high-level query (e.g., SQL) into an internal form the database can understand.

Query Plan is a sequence of operations that outlines how the query will be executed.

Query Optimizer selects the most efficient execution strategy by comparing alternative plans.

Catalog Manager controls access to metadata about database objects and their properties.

System Catalog is the repository storing metadata such as table definitions, indexes, constraints, and statistics.

Query Execution Plan is the finalized, optimized set of operations to be performed on the database.

Command Processor executes non-query commands like schema modifications or security changes.

Data Manager handles the physical reading, writing, and buffering of stored data.

Database is the structured, persistent storage of data.

Query Result is the final output returned to the user after query execution.

# data[].attributes.body
1. Query Processing: This is the initial step where the system takes the user’s query and prepares it for further handling.

2. Query Compiler: This part translates the query written by the user into a form that the database system can understand and work with, usually an internal representation.

3. Query Plan: After compilation, the system creates a plan showing how to execute the query efficiently. It’s like a roadmap of steps to get the data.

4. Query Optimizer: This component reviews the query plan and tries to improve it by finding the most efficient way to execute the query, saving time and resources.

5. System Catalog / Catalog Manager: This is like a database directory that holds metadata about the data — what tables exist, their structure, indexes, etc. The optimizer and others refer to this to make decisions.

6. Query Execution Plan: This is the final, optimized set of instructions that tells the system exactly how to retrieve the data.

7. Command Processor: This executes the instructions from the query execution plan and manages communication between different components.

8. Data Manager: Responsible for accessing the actual stored data in the database.

9. Query Result: The final data output produced after the query has been processed and executed.

# data[].attributes.body
1. Query Processing-The overall process of handling a user's request to retrieve or modify data in a database.

2.Query Compiler- Translates a SQL query or user command into a format the database system can understand.

3. Query Plan-A step-by-step strategy created by the system to fetch the requested data efficiently.

4. Query Optimize- Analyzes different ways to execute a query and selects the fastest and most efficient method.

5.Catalog Manager- Keeps track of database metadata .

6.Query Result-The final data returned to the user after processing the query.

7.Command Processo

Executes database commands .

8. Query Execution Plan- The finalized version of the query plan that the database actually follows to retrieve data.

9.System Catalog that stores metadata

10.Data Manager-Handles the actual storage, retrieval, and updating of data in the database.

11. Database-The physical storage where all structured data is kept

# data[].attributes.body
1. Query Processing –--- send a question (SQL) to the database.

2. Query Compiler ---– Changes question into database language.

3. Query Plan ---– Makes steps to get the answer.

4. Query Optimizer ---– Finds the quickest way.

5. Catalog Manager –--- Gives info about tables and data.

6. Query Execution Plan --– Final plan to run.

7. Command Processor ---– Sends instructions to get data.

8. Data Manager ---– Brings the data from storage.

9. Query Result –--- Shows the answer.

# data[].attributes.body
1. Query Processing

This is the starting point where the system receives the user’s request (often written in SQL). At this stage, the system just knows what you want, not how to get it.

2. Query Compiler

The query compiler translates the user’s SQL query into an internal form that the database can understand.

It performs:

Parsing – checks syntax and meaning.

Translation – converts it into a lower-level representation.

Validation – ensures the tables and columns exist.

3. Query Plan

Here, the system creates a recipe of steps needed to get the data.

It describes what operations should be done but not necessarily in the most efficient way yet.

4. Query Optimizer

This is like a smart planner that finds the fastest and cheapest way to execute the query.

It considers,

Index usage

Join orders

Access paths

It may consult the System Catalog to get information like table sizes, indexes, and data statistics.

5. Catalog Manager

This manages the System Catalog, which stores metadata about the database

It provides the optimizer with information needed for efficient planning.

6. Query Execution Plan

After optimization, the system produces a detailed step-by-step guide for actually running the query.

This is the final, most efficient plan.

7. Command Processor

The command processor takes the execution plan and turns it into actual low-level operations that the Data Manager can run.

8. Data Manager

This component directly interacts with the physical database storage.

It reads and writes data blocks, handles transactions, and ensures data integrity.

9. Database

The actual storage where all your data lives tables, indexes.

10. Query Result

After the data manager fetches the required data and the command processor processes it, the final results are sent back to the user.

# data[].attributes.body
01 Query Processing

This is the overall activity where a user’s query usually in SQL is handled by the database system

02. Query compiler

It translates your high level sql query into an internal format so that the database understands.

03. Query plan

A detailed map or like you can say a set of steps on how the database will answer the query.

04.Query optimizer

Improves the query plan to make it run faster and use fewer resources.

05.Catalog manager

Looks into the database’s System Catalog to check information about tables, indexes and sizes, etc.

06.System Catalog

Stores data about the data base table structures, column types and the user permissions.

07.Query execution plan

It’s the final optimized instructions ready to run.

08.Command processor

Executes the plan and coordinates with the data manager.

09.Data Manager

It handles reading and writing actual data in the database storage.

10.Database

The physical storage where all data is kept.

11.Query result

It is the output you get after all steps are done.

# data[].attributes.body
1. Query Processing

The process a database follows to handle a user’s SQL request from start to finish.

2. Query Compiler

Changes the SQL command into a form the database understands and checks if it’s correct.

3. Query Plan

A list of steps the database will follow to get the answer.

4. Query Optimizer

Finds the fastest and most efficient way to run the query.

5. Catalog Manager

Provides the optimizer with details about tables, indexes, and rules.

6. System Catalog

Stores the database’s structure and design details.

7. Query Execution Plan

The final plan chosen to run the query.

8. Command Processor

Runs the plan and works with the data manager.

9. Data Manager

Gets the data from storage or saves it there.

10. Database

The place where all actual data is stored.

11. Query Result

The final answer shown to the user.

# data[].attributes.body
Week 9 - Storage & Query Processing

1. Query Processing is the entire process the database system goes through to handle and respond to a user's SQL query.

2. Query Compiler translates the SQL query into a form the system can work with. It also checks the query for any syntax or logical errors.

3. Query Plan is a set of steps the database will follow to get the requested data. This is created from the translated version of the original query.

4. Query Optimizer looks at different ways to run the query and picks the most efficient method. It decides things like the order of operations, which indexes to use, and how to handle joins.

5. Catalog Manager manages the metadata like information about tables, indexes, and constraints. It provides this information to the optimizer.

6. System Catalog is where all the database's metadata is stored, such as table structures, indexes, and storage details.

7. Query Execution Plan is the final version of the plan chosen by the optimizer. It's ready to be executed by the system.

8. Command Processor takes the execution plan and works with the data manager to actually retrieve or modify the data.

9. Data Manager handles direct access to the stored data, reading from and writing to the database.

10. Database is the actual place where the data is stored physically.

11. Query Result is the final output and the data that's been fetched or modified, and returned to the user in a usable format.

# data[].attributes.body
1. Query Processing

This is the whole process where the database takes a user’s SQL request, works on it, and gives back the results.

2. Query Compiler

This part of the system changes the SQL query into another form that the database can understand better. It also checks for mistakes in the query’s structure and meaning.

3. Query Plan

This is like a step-by-step guide the database follows to find the requested data. It’s created from the processed version of the query.

4. Query Optimizer

Looks at different ways to run the query and picks the fastest one.

Decides the order of steps, which indexes to use, and how to join tables.

5. Catalog Manager

Manages the database’s “catalog” (metadata) that stores details about tables, indexes, and rules.

Gives the optimizer the needed information to make decisions.

6. System Catalog

A storage area for metadata (info about the database structure, indexes, and storage details).

7. Query Execution Plan

The final, improved plan for running the query — ready for the database to execute.

8. Command Processor

Takes the execution plan and works with the data manager to get or change the data.

9. Data Manager

Handles the actual fetching and storing of data in the database.

10. Database

The place where all the real data is physically stored.

11. Query Result

The processed data is sent back to the user in the format they requested.

# data[].attributes.body
1. Query Processing

This is where the process starts.

The user’s SQL query (e.g., SELECT * FROM Students) is taken in for processing

2. Query Compiler

Translates the SQL query into an internal form that the database can understand better.

Checks the query syntax and semantics (making sure it’s valid and makes sense).

3. Query Plan

A raw plan showing possible steps to retrieve the requested data.

It’s like a “first draft” of how the database might execute the query.

4. Query Optimizer

Improves the raw query plan to make it faster and use fewer resources.

Chooses the most efficient way to access tables, indexes, and data.

5. Catalog Manager

Works with the System Catalog (metadata database that stores information about tables, columns, indexes, permissions, etc.).

Provides necessary information for optimization and execution planning.

6. Query Execution Plan

The final, optimized set of steps for executing the query.

Passed to the execution system.

7. Command Processor

Receives the execution plan and translates it into actual database commands.

Sends instructions to the Data Manager.

8. Data Manager

Directly interacts with the physical database storage.

Retrieves or updates the data based on the commands.

9. Database

The actual storage where all data resides (tables).

10. Query Result

The final output returned to the user after the query is executed.

# data[].attributes.body
1. Query Processing

This is the starting point where the system receives the user’s request (often written in SQL). At this stage, the system just knows what you want, not how to get it.

2. Query Compiler

The query compiler translates the user’s SQL query into an internal form that the database can understand.

It performs:

Parsing – checks syntax and meaning.

Translation – converts it into a lower-level representation.

Validation – ensures the tables and columns exist.

3. Query Plan

Here, the system creates a recipe of steps needed to get the data.

It describes what operations should be done but not necessarily in the most efficient way yet.

4. Query Optimizer

This is like a smart planner that finds the fastest and cheapest way to execute the query.

It considers,

Index usage

Join orders

Access paths

It may consult the System Catalog to get information like table sizes, indexes, and data statistics.

5. Catalog Manager

This manages the System Catalog, which stores metadata about the database

It provides the optimizer with information needed for efficient planning.

6. Query Execution Plan

After optimization, the system produces a detailed step-by-step guide for actually running the query.

This is the final, most efficient plan.

7. Command Processor

The command processor takes the execution plan and turns it into actual low-level operations that the Data Manager can run.

8. Data Manager

This component directly interacts with the physical database storage.

It reads and writes data blocks, handles transactions, and ensures data integrity.

9. Database

The actual storage where all your data lives tables, indexes.

10. Query Result

After the data manager fetches the required data and the command processor processes it, the final results are sent back to the user.

# data[].attributes.body
1. Query Processing

The overall activity where a user’s query is handled by the database system

2. Query Compiler

The query compiler makes translations of the high-level SQL query into an intermediate form. It checks syntax and semantics to ensure for the validation.

3. Query Plan

A query plan is a set of steps that used by the system to get the data. It is generated from the intermediate form of the query.

4. Query Optimizer

The optimizer looks at different possible ways to execute the query and chooses the most efficient one. It decides the order of operations, indexes to use, and join strategies.

5. Catalog Manager

The catalog manager manages the system catalog. It provides the optimizer with needed details about tables, indexes, and statistics.

6. System Catalog

A database’s metadata storage contains information like table structures, index definitions and storage details.

7. Query Execution Plan

The final optimized version of the plan, ready to be run by the database engine.

8. Command Processor

Takes the execution plan and coordinates with the data manager to retrieve or modify the data.

9. Data Manager

Handles actual data access fetching from and writing to the database storage.

10.Database

The physical storage where the actual data is kept.

11. Query Result

The processed and retrieved data is returned to the user in the requested format.

# data[].attributes.body
1. Query Processing – This is the whole process where the database handles a user’s request (often written in SQL).

2. Query Compiler – Translates the SQL request into a form the system can work with, and checks that it’s written correctly and makes sense.

3. Query Plan – A list of steps the system will follow to get the data, based on the translated query.

4. Query Optimizer – Looks at different ways to run the query and picks the fastest method, deciding things like order of steps, which indexes to use, and how to join tables.

5. Catalog Manager – Manages information about the database’s structure, indexes, and rules, and gives the optimizer details it needs.

6. System Catalog – The stored “map” of the database, including table layouts, indexes, and storage details.

7. Query Execution Plan – The final, improved version of the plan, ready to be run.

8. Command Processor – Takes the execution plan and works with the data manager to get or change the data.

9. Data Manager – Handles the actual reading and writing of data in storage.

10. Database – Where the real data is physically stored.

11. Query Result – The finished data is given back to the user in the format they asked for.

# data[].attributes.body
1. Query Processing – The whole process of handling a user’s request in the database.

2. Query Compiler – Converts the SQL query into an intermediate form and checks if it’s correct.

3. Query Plan – The list of steps the system will follow to get the data.

4. Query Optimizer – Chooses the fastest and most efficient way to run the query.

5. Catalog Manager – Manages information about the database’s structure and provides it to the optimizer.

6. System Catalog – The storage of database details like table structures, indexes, and storage info.

7. Query Execution Plan – The final optimized plan ready to be executed.

8. Command Processor – Executes the plan and works with the data manager.

9. Data Manager – Handles the actual reading and writing of data from storage.

10. Database – The physical storage where the data is kept.

11. Query Result – The final data returned to the user.

# data[].attributes.body
1. Query processing

● handling user's activity by database system

2. Query compiler

● translate high level query language to intermediate form and check for syntax and semantics for validation

3. Query plan

● set of steps used by system to get the data

4. Query optimizer

● looks for most efficienct way to execute the query

5. Catalog manager

● manage system catalog and provide needed details to optimizer

6. System catalog

● metadata storage of database like table structures, indexes definitions and storage details

7. Query execution plan

● ready to run, finally optimised plan

8. Command processor

● takes the execution plan and coordinate with data manager

9. Data manager

● handles actual data access

10. Database

● physical storage where data is actually stored

11. Query result

● processed and retrieved data is returned to user in requested format

# data[].attributes.body
1.Query processing is how a database system takes a user's request and figures out how to get the data.

2. Query Compilation is receiving the query and checks if it's valid, making sure the syntax is correct and the request makes sense.

3.  Query Plan creates a plan, which is a set of steps for getting the requested data.

4. Query Optimization  looks at all the possible ways to run the query and chooses the most efficient one.

5. Query Execution Plan is when Final, optimized plan is then ready to be executed by the database.

6.  Command Processing is a command processor that takes this plan and works with the data manager to actually retrieve or change the data in the database's physical storage.

7. Data Manager is Fetching data.

8. Query Result is processed data is returned to the user in the format they asked for.

# data[].attributes.body
1. Query Compiler - Translates SQL queries into an internal format the database can understand.

2. Query Optimizer - Finds the most efficient way to execute the query by considering different plans.

3. Catalog Manager - Maintains metadata about the database structure (tables, columns, indexes).

4. Command Processor - Coordinates the execution of the query by interacting with other components.

5. Query Execution Plan - The step-by-step instructions for how to retrieve the data.

# data[].attributes.body
Components in Query Processing

1. Query Processing – This is the overall job of handling a user’s request (like an SQL query) from start to finish.

2. Query Compiler – Reads the SQL query, checks for errors in grammar (syntax) and meaning (semantics), then changes it into an easier-to-handle form for the system.

3. Query Plan – A draft set of steps that shows how the database could get the required data.

4. Query Optimizer – Looks at all possible ways to run the query and picks the fastest and most efficient method, deciding on things like join order and which indexes to use.

5. Catalog Manager – Handles the database’s “dictionary” (metadata) containing details about tables, indexes, and constraints, and gives this info to the optimizer.

6. System Catalog – The storage space for metadata — information about how the database is structured and stored.

7. Query Execution Plan – The final, optimized set of instructions ready to be run by the database engine.

8. Command Processor – Takes the execution plan and works with the Data Manager to actually get or change the data.

9. Data Manager – Controls the real reading from and writing to the database storage.

10. Database – The physical place where all actual data is kept.

11. Query Result – The final data output that is sent back to the user in the format they requested.

# data[].attributes.body
1. Query Processing

This is the starting point where the system receives the user’s request (often written in SQL). At this stage, the system just knows what you want, not how to get it.

2. Query Compiler

The query compiler translates the user’s SQL query into an internal form that the database can understand.

It performs:

Parsing – checks syntax and meaning.

Translation – converts it into a lower-level representation.

Validation – ensures the tables and columns exist.

3. Query Plan

Here, the system creates a recipe of steps needed to get the data.

It describes what operations should be done but not necessarily in the most efficient way yet.

4. Query Optimizer

This is like a smart planner that finds the fastest and cheapest way to execute the query.

It considers,

Index usage

Join orders

Access paths

It may consult the System Catalog to get information like table sizes, indexes, and data statistics.

5. Catalog Manager

This manages the System Catalog, which stores metadata about the database

It provides the optimizer with information needed for efficient planning.

6. Query Execution Plan

After optimization, the system produces a detailed step-by-step guide for actually running the query.

This is the final, most efficient plan.

7. Command Processor

The command processor takes the execution plan and turns it into actual low-level operations that the Data Manager can run.

8. Data Manager

This component directly interacts with the physical database storage.

It reads and writes data blocks, handles transactions, and ensures data integrity.

9. Database

The actual storage where all your data lives tables, indexes.

10. Query Result

After the data manager fetches the required data and the command processor processes it, the final results are sent back to the user.

# data[].attributes.body
1. Query Processing – This is the whole process where the database handles a user’s request (often written in SQL).

2. Query Compiler – Translates the SQL request into a form the system can work with, and checks that it’s written correctly and makes sense.

3. Query Plan – A list of steps the system will follow to get the data, based on the translated query.

4. Query Optimizer – Looks at different ways to run the query and picks the fastest method, deciding things like order of steps, which indexes to use, and how to join tables.

5. Catalog Manager – Manages information about the database’s structure, indexes, and rules, and gives the optimizer details it needs.

6. System Catalog – The stored “map” of the database, including table layouts, indexes, and storage details.

7. Query Execution Plan – The final, improved version of the plan, ready to be run.

8. Command Processor – Takes the execution plan and works with the data manager to get or change the data.

9. Data Manager – Handles the actual reading and writing of data in storage.

10. Database – Where the real data is physically stored.

11. Query Result – The finished data is given back to the user in the format they asked for.

# data[].attributes.body
1. Query Processing
This refers to the complete process by which a database system handles a user’s query, often written in SQL.

2. Query Compiler
The query compiler converts the SQL query into an intermediate representation. During this stage, it also verifies that the query’s syntax and meaning are correct.

3. Query Plan
A query plan outlines the sequence of operations the system will perform to retrieve the requested data, based on the intermediate form of the query.

4. Query Optimizer
The optimizer evaluates various possible execution methods for a query and selects the most efficient approach. It determines the sequence of operations, the indexes to apply, and the join methods to use.

5. Catalog Manager
The catalog manager oversees the system catalog, which contains metadata describing the database’s structure, indexes, constraints, and more. It supplies the optimizer with essential information about tables, indexes, and statistical data.

6. System Catalog
This is the repository of a database’s metadata, containing details such as table designs, index configurations, and storage specifications.

7. Query Execution Plan
The finalized and optimized plan that the database engine will execute to process the query.

8. Command Processor
Executes the query by taking the final plan and working with the data manager to access or update the data.

9. Data Manager
Responsible for reading data from and writing data to the database’s physical storage.

10. Database
The physical location where all actual data is stored.

11. Query Result
The final output, consisting of the retrieved and processed data, presented to the user in the desired format.

# data[].attributes.body
Using your own words, explain the components inside the query processing

# data[].attributes.body
1. Varchar

2. Varchar

3. Int

4. Date

5. Varchar

6. Int

7. Boolean

8. Float

# data[].attributes.body
1. Varchar

2. Char

3. Number

4. Date

5. Varchar

6. Number

7. Char

8. Number

# data[].attributes.body
1. VARCHAR

2. VARCHAR

3. INT

4. DATE

5. VARCHAR

6. INT

7. BOOLEN

8. FLOAT INT

# data[].attributes.body
1. Varchar

2.Char

3.Number

4.Date

5.Varchar

6.Number

7.Char

8.Number

# data[].attributes.body
1. Varchar

2. Varchar

3. Int

4. Date

5. Varchar

6. Int

7. Boolean

8. Float

# data[].attributes.body
1. Varchar

2. Varchar

3. Number

4. Date

5. Varchar

6. Varchar

7. Boolean

8. Float

# data[].attributes.body
1.Varchar2

2.Varchar2-because it long

3.Number

4.Date

5.Varchar2-it has symbol

6.Varchar2-long number

7.Varchar2/ char - because it can be long and short

8. Number

# data[].attributes.body
1. VARCHAR

2. VARCHAR

3. NUMBER

4. DATE

5. VARCHAR

6. VARCHAR

7. BOOLEAN

8. NUMBER

# data[].attributes.body
1.varchar

2.char

3.number

4.date

5.varchar

6.number

7.char

8.number

# data[].attributes.body
Varchar

Char

Number

Date

Varchar

Number

Char

Number

# data[].attributes.body
1. Varchar

2. Char

3. Integer

4. Date

5. Varchar

6. Integer

7. Boolean

8. Float

# data[].attributes.body
1. Varchar

2. Varchar

3. Int

4. Date

5. Varchar

6. Int

7. Char

8. Number

# data[].attributes.body
1. Varchar

2. Char

3. Number

4. Date

5. Varchar

6. Number

7. Char

8. Number

# data[].attributes.body
1. Varcher

2. Varcher

3. Number/ Integer

4. Date

5. Varcher

6. Number/ Integer

7. Char

8. Number

# data[].attributes.body
1. Varchar

2. Char

3. Number

4. Date

5. Varchar

6. Number

7. Boolean

8. Float

# data[].attributes.body
1.StudentID - AIU1234 - VARCHAR

2. FullName - Siti Aisyah - VARCHAR

3. Age - 20 - NUMBER

4. DateOfBirth - 2005-08-21 - DATE

5. Email - aisyah@gmail.com - VARCHAR

6. PhoneNumber - 0123456789 - VARCHAR

7. IsActiveStudent - Yes or No - BOOLEAN

8. GPA - 3.75 -

DECIMAL

# data[].attributes.body
Varchar

Varchar

Number

Date

Varchar

Varchar

Char or Varchar

Number

# data[].attributes.body
1. VARCHAR

2. CHAR

3. NUMBER

4. DATE

5. VARCHAR

6. NUMBER

7. BOOLEAN

8. FLOAT

# data[].attributes.body
1. VARCHAR

2. CHAR

3. NUMBER

4. DATE

5. VARCHAR

6. NUMBER

7. BOOLEAN

8. FLOAT

# data[].attributes.body
1.Varchar

2.Varchar

3.Int

4.Date

5.Varchar

6.Int

7.Char

Number