1.

​ What is Databases
database is an organized collection of data or a type of data store based on the use of a
database management system (DBMS), the software that interacts with end users,
applications, and the database itself to capture and analyze the data. The DBMS
additionally encompasses the core facilities provided to administer the database. The
sum total of the database, the DBMS and the associated applications can be referred to
as a database system. Often the term "database" is also used loosely to refer to any of
the DBMS, the database system or an application associated with the database
Small databases can be stored on a file system, while large databases are hosted on
computer clusters or cloud storage. The design of databases spans formal techniques
and practical considerations, including data modeling, efficient data representation and
storage, query languages, security and privacy of sensitive data, and distributed
computing issues, including supporting concurrent access and fault tolerance.

Computer scientists may classify database management systems according to the

database models that they support. Relational databases became dominant in the 1980s.
These model data as rows and columns in a series of tables, and the vast majority use
SQL for writing and querying data. In the 2000s, non-relational databases became
popular, collectively referred to as NoSQL, because they use different query languages.
2 . What are the basic elements of ERD
An Entity-Relationship Diagram (ERD) is a visual tool used in database design to
illustrate the structure of data and the relationships between data entities. The basic
elements of an ERD are:
1. Entities:
These are objects or concepts that represent real-world things such as Student, Teacher,
or Course. Each entity is shown as a rectangle. Entities can be classified as strong
(independent) or weak (dependent on another entity).
2. Attributes:
Attributes provide specific details about entities. For example, a Student entity may have
attributes like StudentID, Name, and Date of Birth. Attributes are drawn as ovals
connected to their entities. Key attributes (which uniquely identify an entity) are
underlined.
3. Relationships:
Relationships show how entities are related to one another. For example, a Student may
enroll in a Course. These are illustrated with diamond shapes, connecting the related
entities.
4. Cardinality:
Cardinality indicates the number of instances of one entity that can or must be
associated with instances of another entity. Common types include one-to-one,
one-to-many, and many-to-many. This helps define the rules of the relationship.
5. Participation (or Modality):
Participation specifies whether the existence of an entity depends on being related to
another entity. Total participation (shown with a double line) means all instances must be
involved in the relationship, while partial participation (single line) means some may not
be.

Together, these elements make ERDs a powerful tool for understanding and designing
database structures clearly and effectively.

3 .What is a relational data model

The Relational Data Model is one of the most widely used and powerful models in
database management systems (DBMS). It was introduced by Dr. E. F. Codd in 1970 and
is based on the principles of set theory and first-order predicate logic.
Key Concepts of the Relational Data Model:
1. Tables (Relations):
The main structure in the relational model is the relation, which is represented as a table.
Each table has a unique name and consists of rows and columns.
2. Tuples (Rows):
Each row in a table represents a single record or instance of an entity. For example, a
row in a Student table may contain details about one student.
3. Attributes (Columns):
Each column represents a specific attribute or field of the entity. For example, in a
Student table, attributes could include StudentID, Name, Age, and Course.
4. Primary Key:
A primary key is a unique identifier for each record in a table. It ensures that no two rows
in a table are identical. Example: StudentID in the Student table.
5. Foreign Key:
A foreign key is an attribute that creates a link between two tables. It refers to the primary
key of another table, enabling relationships between data across tables.
6. Relations Between Tables:
The relational model supports relationships such as:
One-to-One
One-to-Many
Many-to-Many (usually broken into two one-to-many relationships using a junction table)
7. Normalization:
This is a process used in relational databases to eliminate redundancy and ensure data
integrity by organizing data into related tables.
8. Data Integrity Rules:
The relational model enforces several integrity rules:
Entity Integrity: Ensures primary keys are unique and not null.
Referential Integrity: Ensures foreign keys match primary keys in related tables.
9. Data Manipulation Using SQL:
The relational model supports
operations like:
INSERT (adding new data)
SELECT (retrieving data)
UPDATE (modifying data)
DELETE (removing data)
These are performed using Structured Query Language (SQL).
Advantages of the Relational Data Model:
Simple and easy to understand.
Supports complex queries and data relationships.
Ensures data accuracy and consistency.
Highly flexible and scalable for large databases.
Widely used in business, education, government, and more.
Example:
A Student table might look like this:

A separate Course table could be linked using a foreign key.

4 what is a one to many relationship? Give examples?
A One-to-Many relationship is a type of relationship between two entities in a database
where one record in the first table can be associated with many records in the second
table, but each record in the second table is linked to only one record in the first table.
Explanation:
This type of relationship is very common in relational databases. It helps organize data
efficiently and reduces redundancy.
How it Works:
The "one" side contains a primary key.
The "many" side contains a foreign key that refers to the primary key of the "one" side.
Example 1:
Entities: Teacher and Students

Teacher id Name

T01 Mr James

T02 Mr Clara

One Teacher can teach many Students

But each Student is taught by one Teacher
Teacher Table
Student Table:

Students id Name Teacher id

S01 Abebe T01

S02 Kebed T02

In this example:
Mr. James teaches Alice and John (One-to-Many)
Emma is taught by Ms. Clara (Still One-to-One from student side)
Example 2:
Entities: Customer and Orders
One Customer can place many Orders
But each Order is placed by one Customer
Customer Table:

Customer id Name

C001 Selam

C002 Weynshet
Orders Table:

Order id Order data Customer

id

O101 2025-04-01 C001

O102 2025-04-02 C002

O103 2025-04-03 C003

Conclusion:
A One-to-Many relationship improves data structure by reducing repetition and making
connections between related entities. It is one of the most important and commonly used
relationships in database design.

5 . What is use of table object in Microsoft access

In Microsoft Access, the Table object is one of the most essential components used to
store and manage data. A table is where all the data in a database is actually stored in a
structured format using rows and columns.

Main Uses of the Table Object:

1. Storing Data:

Tables hold all the actual data records in the database.

Each row (record) represents one item or entry (e.g., a student, product, or employee).
Each column (field) represents a property of that item (e.g., Name, ID, Age, Price).
2. Data Organization:

Tables help organize information into categories.

For example, you might have one table for Customers, another for Orders, and another
for Products.
3. Data Relationships:
Tables can be related to one another using primary keys and foreign keys to create
relationships such as one-to-many.
This supports relational database design, reducing data duplication and maintaining
consistency.
4. Data Entry and Editing:

Users can directly enter, view, or edit data through the table view in Access.

Tables can also be connected to forms for easier data entry.

5. Data Integrity and Validation:
Fields in a table can have data types (e.g., text, number, date) and validation rules to
ensure data accuracy.
Primary keys prevent duplicate entries and enforce uniqueness.
6. Query and Report Support:
Queries, forms, and reports in Access pull their data directly from tables.
Well-structured tables make it easier to generate accurate and meaningful results.
Example:
A Student table might look like this:
Here, the StudentID could be the primary key, uniquely identifying each student.
 Student id Name Age Course

S001 Michael 18 English

S002 Estifano 17 ICT

s

Conclusion:
The Table object is the foundation of any Microsoft Access database. It is used for
storing, organizing, and managing data efficiently and is central to all other database
operations like forms, queries, and reports.

6 What is use of query in Microsoft access

In Microsoft Access, a Query is a tool used to retrieve, manipulate, and analyze data from
one or more tables in a database. Queries allow users to filter, sort, calculate, and
summarize data based on specific criteria, without changing the original data in the
underlying tables. Queries are an essential feature for creating customized views and
reports.
Main Uses of Queries in Microsoft Access:
1. Data Retrieval:
Queries allow users to extract specific data from tables by defining search criteria.
For example, you can create a query to find all customers who live in a specific city or
have made purchases within a certain date range.
2. Data Filtering and Sorting:
Queries enable users to filter data to show only the records that meet certain conditions.
You can also sort the data in ascending or descending order, such as sorting customer
names alphabetically or sorting orders by date.
3. Data Calculation:
Queries can perform calculations such as totals, averages, or custom formulas.
For instance, you can create a query to calculate the total sales amount for each product
sold or find the average age of customers.
4. Joining Data from Multiple Tables:
Access queries can combine data from multiple tables using joins (such as inner join, left
join, etc.).
This helps users to analyze data that is spread across different tables, such as finding all
orders placed by a particular customer.
5. Data Updates and Modifications:
Queries are not just for retrieving data; they can also be used to update, insert, or delete
records in the tables.
For example, you can use an update query to change the price of all products in a certain
category or use a delete query to remove all records of customers who have not made
purchases in a year.
6. Creating Custom Views:
Queries allow users to create customized views of the data that can be used for reports,
forms, and dashboards.
You can design a query that shows a summary report of sales per month or display
customer orders with specific details.
7. Automating Repetitive Tasks:
Queries can be saved and reused, making it easier to automate repetitive tasks.
For example, you can create a query to automatically generate monthly sales summaries
or inventory reports.
Types of Queries in Access:
1. Select Queries:
Used to retrieve data based on specific criteria.
2. Action Queries:
Used to update, insert, or delete data (e.g., Update Query, Delete Query, Append Query).
3. Parameter Queries:
Prompts the user to input a value, and the query results depend on the value entered
(e.g., asking for a date range).
4. Crosstab Queries:
Used to summarize data into a cross-tabulated format (like a pivot table in Excel),
typically for reporting purposes.
Example:
Suppose you have a Customer table with columns CustomerID, Name, City, and
PurchaseAmount. You can create a query to find all customers who made purchases
above $500 and are located in "New York." The query might look like:
SELECT Name, PurchaseAmount
FROM Customer
WHERE PurchaseAmount > 500 AND City = 'New York';
This query will return a list of customers who meet the specified criteria.
SELECT Name, PurchaseAmount
FROM Customer
WHERE PurchaseAmount > 500 AND City = 'New York';
—
Conclusion:
Queries in Microsoft Access are versatile tools that enable users to efficiently interact
with the data in their database. They can be used to retrieve, update, and manipulate
data, making them indispensable for creating reports, summarizing information, and
automating tasks.