Internship Report Sample
Internship Report Sample
An Internship Report
On
“Structured Query Language”
Submitted by:
AKANKSHA PRIYA
20BBTCS008
CERTIFICATE
This is to certify that the Internship work entitled “SQL INTERNSHIP”, submitted to the CMR
University, Bangalore, in partial fulfillment of the requirements for the award of the degree of Bachelor of
Technology in Computer Science is a record of work done by Ms.Akanksha Priya bearing university
register number 20BBTCS008 during the academic year 2024-25 at School of Engineering and Technology,
CMR University, Bangalore under my supervision and guidance. The Internship report has been approved
as it satisfies the academic requirement in respect of internship work prescribed for the said degree.
I further declare that the work reported in this internship work has not been submitted and
will not be submitted, either in part or in full, for the award of any other degree in this university
or any other institute or University.
Place: Bangalore
i
ACKNOWLEDGEMENT
The satisfaction that accompanies the successful completion of this project would be
incomplete without the mention of the people who made it possible, without whose constant
guidance and encouragement would have made efforts go in vain.
I consider myself privileged to express gratitude and respect towards all those who
guided me through the completion of the project. I express my thanks to my Internal Internship
Guide Prof. Chethana RM, Asst. Professor, Department of Computer Science and
Engineering, School of Engineering and Technology, CMR University for her constant support.
I would like to express my sincere thanks and gratitude to our internship coordinator
Prof. Prabhakar K for his support, invaluable guidance and encouragement throughout the
tenure of this internship.
AKANKSHA PRIYA
ii
ABSTRACT
This internship report provides a comprehensive overview of the intern's experience in the
field of structured query language. The report outlines the importance of structured query language in
Database management systems. This SQL Internship offers a comprehensive introduction to database
management systems and SQL querying. Interns will gain practical experience in designing,
implementing, and querying databases, honing skills that are invaluable in data-driven environments.
Through a series of structured modules and real-world querying, interns will learn to create efficient
database schema, optimize queries for performance, and understand key concepts such as
normalization and indexing. The internship will also cover advanced topics such as transactions,
stored procedures, and triggers, providing a solid foundation for database administration and
development roles. By the end of the internship, participants will have a strong command of SQL and
the ability to work confidently with relational databases.
Duration: 2 months
Prerequisites: Basic understanding of databases and SQL is recommended but not required.
iii
TABLE OF CONTENTS
TITLE PAGENO
DECLARATION .................................................................................................................. i
ACKNOWLEDGEMENT ...................................................................................................ii
CHAPTER
2. INTRODUCTION .................................................................................................. 3
ABOUT DEVSKILLHUB.......................................................................... 3
STRUCTURED QUERY LANGUAGE ...................................................... 3
UNDERSTANDING DATABASE FUNDAMENTALS ............................. 4
MASTERING SQL SYNTAX ....................................................................5
DATABASE DESIGN ............................................................................... 7
QUERY OPTIMIZATION ......................................................................... 8
TRANSACTION AND CONCURRENCY ................................................. 9
STORED PROCEDURES .......................................................................... 9
DATABASE SECURITY ........................................................................ 10
4. CONCLUSION .......................................................................................................23
5. BIBLIOGRAPHY .....................................................................................................24
v
LIST OF FIGURES
SL NO FIGURES PAGE NO
1 Fig.1.STRUCTURED QUERY 12
LANGUAGE
vi
SQL Internship 2024-25
CHAPTER 1
INTERNSHIP OBJECTIVES
3. Database Design:
- Acquire skills to design efficient and normalized database schemas, considering factors
such as data integrity, scalability, and performance.
4. Query Optimization:
- Learn techniques to optimize SQL queries for improved performance
- Indexing strategies
- Query tuning.
7. Database Security:
- Learn about database security principles and best practices
- Access control
- Authentication
- Data encryption.
9. Real-World Projects:
- Work on real-world querying or case studies that simulate industry scenarios
- Applying SQL skills to solve practical problems
- Gain hands-on experience.
CHAPTER 2
INTRODUCTION
ABOUT DEVSKILLHUB
Mission:
- Empowering learners with tailored education to excel, innovate, and positively impact their
chosen fields.
Vision:
- Leading the future of learning with innovative programs, fostering excellence, and shaping
tomorrow's industry leaders.
SQL (Structured Query Language) is a powerful language used for managing and
manipulating relational databases. It allows users to perform tasks such as querying data, updating
data, and managing databases.
Normalization:
- Normalization is the process of organizing data in a database to reduce redundancy and
improve data integrity.
SQL Data Types:
- SQL supports various data types such as INTEGER, VARCHAR, DATE, etc., to define the
type of data that can be stored in a column.
SQL Queries:
- SQL (Structured Query Language) is used to query and manipulate data in a database.
- Common SQL commands include SELECT, INSERT, UPDATE, DELETE, and JOIN.
Indexes:
- Indexes are used to speed up data retrieval by creating a quick reference to the data in a
table.
Constraints:
- Constraints are rules that enforce data integrity, such as NOT NULL, UNIQUE, PRIMARY
KEY, and FOREIGN KEY constraints.
Transactions:
- A transaction is a sequence of SQL statements that are treated as a single unit of work.
- ACID properties (Atomicity, Consistency, Isolation, and Durability) ensure that
transactions are reliable.
Mastering SQL syntax is essential for effectively querying and manipulating data in a database.
During the internship, I learnt about the various SQL statements and their syntax
SELECT Statement:
- Used to retrieve data from one or more tables.
- Syntax: SELECT column1, column2 FROM table_name WHERE condition;
INSERT INTO Statement:
- Used to insert new records into a table.
- Syntax: INSERT INTO table_name (column1, column2) VALUES (value1, value2);
UPDATE Statement:
- Used to update existing records in a table.
- Syntax: UPDATE table_name SET column1 = value1, column2 = value2 WHERE
condition;
DELETE FROM Statement:
- Used to delete records from a table.
- Syntax: DELETE FROM table_name WHERE condition;
JOIN Clause:
- Used to combine rows from two or more tables based on a related column between them.
- Syntax: SELECT * FROM table1 INNER JOIN table2 ON table1.column = table2.column;
GROUP BY Clause:
- Used to group rows that have the same values into summary rows.
- Syntax: SELECT column1, COUNT(*) FROM table_name GROUP BY column1;
ORDER BY Clause:
- Used to sort the result set in ascending or descending order.
- Syntax: SELECT * FROM table_name ORDER BY column1 ASC/DESC;
Aggregate Functions:
- Used to perform calculations on a set of values.
- Examples: COUNT(), SUM(), AVG(), MIN(), MAX().
Subqueries:
- A query nested inside another query.
- Syntax: SELECT * FROM table_name WHERE column1 = (SELECT column2 FROM
another_table);
Views:
- A virtual table created from a query's result set.
- Syntax: CREATE VIEW view_name AS SELECT column1, column2 FROM table_name
WHERE condition;
Stored Procedures:
- Precompiled SQL queri es stored in the database for reuse.
- Syntax: CREATE PROCEDURE procedure_name AS SQL_statements;
3. Database Design:
Learning database design in an SQL internship is crucial for designing efficient and well-structured
databases.
Entity-Relationship (ER) Modeling:
- ER modeling is a technique used to design databases by identifying the entities within a
system and the relationships between them.
- Entities are objects or concepts that are important in the context of the database (e.g.,
customers, products).
- Relationships describe how entities are related to each other (e.g., one-to-many, many-to-
many).
Normalization:
- Normalization is the process of organizing data in a database to reduce redundancy and
improve data integrity.
- It involves dividing large tables into smaller tables and defining relationships between them.
Database Normal Forms:
- Normal forms are rules used to determine the level of normalization of a database schema.
- Common normal forms include 1NF (First Normal Form), 2NF (Second Normal Form), and
3NF (Third Normal Form).
Keys and Indexes:
- Primary keys uniquely identify each record in a table.
- Foreign keys establish relationships between tables by referencing the primary key of
another table.
- Indexes are used to speed up data retrieval by creating a quick reference to the data in a
table.
Denormalization:
- Denormalization is the process of adding redundancy to a database schema to improve
query performance.
- It is often used in data warehousing and reporting scenarios where read performance is more
critical than data redundancy.
During Internship, I learnt about Query optimization in SQL which is the process of improving the
performance of SQL queries to retrieve data from a database more efficiently.
- Use Indexes: Indexes help speed up data retrieval by creating a quick reference to the data
in a table. Use indexes on columns frequently used in WHERE clauses, JOIN conditions,
and ORDER BY clauses.
- *Avoid SELECT: Instead of selecting all columns using SELECT *, specify only the
columns you need. This reduces the amount of data that needs to be processed and retrieved.
- Use WHERE Clause Efficiently: Use the WHERE clause to filter data early in the query,
reducing the number of rows processed. Avoid using functions or calculations in the
WHERE clause that prevent the use of indexes.
- Use JOINs Carefully: Use the appropriate type of JOIN (INNER, LEFT, RIGHT, FULL)
based on your requirements. Ensure that JOIN conditions are efficient and use indexes if
possible.
- Limit the Result Set: Use LIMIT or TOP to limit the number of rows returned, especially
when you only need a subset of the data.
- Avoid Sub queries if Possible: Su bqueries can be less efficient than using JOINs or other
methods. Try to rewrite queries to eliminate or reduce the use of subqueries.
- Use EXPLAIN (or equivalent): Use the EXPLAIN keyword to analyze the query execution
plan. This can help identify areas for optimization, such as missing indexes or inefficient
JOINs.
- Avoid Functions in WHERE Clause: Functions in the WHERE clause can prevent the use
of indexes. If possible, move the function outside the WHERE clause or use a different
approach.
- Use Stored Procedures: Stored procedures can improve performance by reducing network
traffic and precompiling SQL statements.
During internship, I learnt about transactions and concurrency control in SQL to ensure that
database operations are performed reliably and efficiently in multi-user environments:
Transaction:
- A transaction is a sequence of operations treated as a single unit of work.
- It follows the ACID properties (Atomicity, Consistency, Isolation, and Durability).
- Atomicity ensures that either all operations in the transaction are completed successfully, or
none are.
- Consistency ensures that the database remains in a consistent state before and after the
transaction.
- Isolation ensures that the intermediate state of a transaction is invisible to other transactions.
- Durability ensures that once a transaction is committed, its effects are permanent.
Concurrency Control:
- Concurrency control ensures that multiple transactions can run concurrently without
interfering with each other.
- Techniques such as locking, timestamp ordering, and optimistic concurrency control are
used to manage concurrent access to data.
- Locking prevents conflicting operations from being performed concurrently on the same
data.
- Timestamp ordering uses timestamps to determine the order in which transactions should be
executed.
- Optimistic concurrency control allows transactions to proceed without locking, but checks
for conflicts before committing.
Stored procedures and triggers are two important features of SQL databases that help automate
tasks and enforce data integrity.
Stored Procedures:
- Stored procedures are precompiled SQL statements stored in the database.
- They can accept parameters, perform operations, and return results.
- Stored procedures can simplify complex operations and improve performance by reducing
network traffic.
- They are often used for tasks such as data validation, calculations, and business
logic implementation.
Triggers:
- Triggers are special types of stored procedures that are automatically executed in response
to certain events.
- They can be triggered before or after INSERT, UPDATE, or DELETE operations on a
table.
- Triggers are used to enforce business rules, maintain data integrity, and automate tasks.
7. Database Security
Database security in SQL is essential for protecting sensitive data from unauthorized access and
ensuring the integrity and availability of the database.
- Authentication and Authorization
- Encryption
- Access Control
- Auditing and Logging
- Backup and Recovery
- Patch Management
- Secure Coding Practices
- Database Hardening
CHAPTER 3
INTERNSHIP DISCUSSION
SQL, or Structured Query Language, is a programming language used to talk to databases. With
SQL, we can store, manipulate, and retrieve data from relational databases.
In relational databases, the data items are organized as a set of tables with columns and
rows. These data items have pre-defined relationships among them across different tables of a
database. It is a very common way to store information, whether it is for a small bookshop or
Amazon.
As an example, you have a books table. In this table, the books are stored as row items, and the
columns represent the attributes of each book such as its ID number, title, author, price, etc.
We may also have a sales table that includes order ID numbers, dates, and amounts of sales. But it
may also include the ID numbers of the books ordered, the ID number of the salesperson, and the
ID number of the corresponding bookstore. These ID numbers are references to other tables in the
database, such as books, salespeople, and stores. This means each piece of information is stored in
the database only once rather than duplicated in every table that may need it. For this reason,
relational databases are very efficient, and as a result, very popular across a variety of industries.
However, for data to be valuable, storing it efficiently is not enough. You must be able to retrieve it
efficiently. This is where SQL comes into play.
SQL is a standard language that lets you combine information from multiple tables based on
predefined relationships, analyze this information, and report the results. But SQL's capabilities go
far beyond mere retrieval of information; it also helps you create databases and keep them up to
date.
What is SQL?
SQL stands for Structured Query Language. SQL is a computer language used to interact with
relational database systems. SQL is a tool for organizing, managing, and retrieving archived data
from a computer database.
When data needs to be retrieved from a database, SQL is used to make the request. The DBMS
processes the SQL query retrieves the requested data and returns it to us. Rather, SQL statements
describe how a collection of data should be organized or what data should be extracted or added
to the database.
Databases
- Databases are structured collections of data organized into tables, rows, and columns. They
serve as repositories for storing information efficiently and provide a way to manage and
access data.
Tables
- Tables are the fundamental building blocks of a database, consisting of rows (records) and
columns (attributes or fields). They ensure data integrity and consistency by defining the
structure and relationships of the stored information.
Queries
- Queries are SQL commands used to interact with databases. They enable users to retrieve,
update, insert, or delete data from tables, allowing for efficient data manipulation and
retrieval.
Constraints
- Constraints are rules applied to tables to maintain data integrity. They define conditions that
data must meet to be stored in the database, ensuring accuracy and consistency.
Stored Procedures
- Stored procedures are pre-compiled SQL statements stored in the database. They can accept
parameters, execute complex operations, and return results, enhancing efficiency,
reusability, and security in database management.
-
Transactions
- Transactions are groups of SQL statements that are executed as a single unit of work. They
ensure data consistency and integrity by allowing for the rollback of changes if any part of
the transaction fails.
- Data Types
- Indexes
- Views
- Security and Permissions
- Joins
- SQL may be utilized by quite a number of users, which include people with very little
programming experience.
- SQL is a non-procedural language.
- We can without difficulty create and replace databases in SQL. It isn’t a time-consuming
process.
- SQL is primarily based totally on ANSI standards.
- SQL does now no longer have a continuation individual.
- SQL is entered into the SQL buffer on one or more lines.
- SQL makes use of a termination individual to execute instructions immediately. It makes
use of features to carry out a few formatting.
- It uses functions to perform some formatting.
Why SQL?
- SQL is an interactive question language. Users type SQL instructions into an interactive
SQL software to retrieve facts and show them on the screen, presenting a convenient, easy-
to-use device for ad hoc database queries.
- SQL is a database programming language. Programmers embed SQL instructions into their
utility packages to access the facts in a database. Both user-written packages and database
software packages (consisting of document writers and facts access tools) use this approach
for database access.
- SQL is a client/server language. Personal computer programs use SQL to communicate over
a network with database servers that save shared facts. This client/server architecture is
utilized by many famous enterprise-class applications.
- SQL is Internet facts access language. Internet net servers that interact with company facts
and Internet utility servers all use SQL as a widespread language for getting access to
company databases, frequently through embedding SQL databases get entry to inside
famous scripting languages like PHP or Perl.
- SQL is a distributed database language. Distributed database control structures use SQL to
assist distribute facts throughout many linked pc structures. The DBMS software program
on every gadget makes use of SQL to speak with the opposite structures, sending requests
for facts to get entry to.
- SQL is a database gateway language. In a pc community with a mixture of various DBMS
products, SQL is frequently utilized in a gateway that lets one logo of DBMS speak with
every other logo. SQL has for this reason emerged as a useful, effective device for linking
people, pc packages, and pc structures to the facts saved in a relational database.
Uses of SQL
SQL Queries
SQL (Structured Query Language) is a domain-specific language used for managing and
manipulating relational databases. In SQL Server, a query is a statement or command that you use
to interact with the database to retrieve, insert, update, or delete data. SQL queries are an integral
part of working with SQL Server and are used for a wide range of database-related tasks.
A SQL query is a structured command written in SQL syntax. It is used to communicate with a
SQL Server database to perform various operations on the data stored in tables.
SQL Clauses
SQL aggregate functions perform calculations on a set of values and return a single value. Some
common aggregate functions include:
COUNT(): Returns the number of rows that match a specified condition.
SUM(): Calculates the sum of a numeric column.
AVG(): Calculates the average value of a numeric column.
MIN(): Returns the smallest value in a column.
MAX(): Returns the largest value in a column.
GROUP_CONCAT(): Concatenates values from multiple rows into a single string.
SQL Constraints
SQL constraints are rules that are enforced on data columns in a table. These constraints maintain
the integrity and consistency of the data within the database. Here are some common SQL
constraints:
NOT NULL: Ensures that a column cannot have a NULL value.
UNIQUE: Ensures that all values in a column are unique.
PRIMARY KEY: A combination of NOT NULL and UNIQUE. Uniquely identifies each
record in a table.
FOREIGN KEY: Ensures that the values in a column match the values appearing in a column
in another table.
CHECK: Ensures that all values in a column satisfy a specific condition.
DEFAULT: Provides a default value for a column when no value is specified.
SQL Views
A SQL view is a virtual table that is based on the result-set of an SQL statement. It contains rows
and columns, just like a real table, but the data is not stored in the database. Instead, the view's data
is dynamically generated when the view is referenced in a query.
Views are used for the following purposes:
Simplifying complex queries: Views can hide the complexity of a query, making it easier for
users to query data.
Data security: Views can restrict the columns or rows that a user has access to, providing a
layer of security.
Reusability: Views can be used to encapsulate frequently used queries, allowing them to be
reused across multiple queries or applications.
Performance: Views can improve performance by precomputing expensive operations or by
limiting the amount of data retrieved from the database.
SQL Index
SQL indexes are structures that improve the speed of data retrieval operations on a database table at
the cost of additional space and decreased performance for write operations. They work similarly to
the index in a book, providing quick access to specific rows in a table.
Types of Indexes:
Primary Key: Uniquely identifies each record in a table. Automatically creates a clustered
index.
Unique: Ensures that the values in a column (or a group of columns) are unique.
Clustered: Orders the physical order of rows in a table based on the index key. A table can
have only one clustered index.
Non-clustered: A separate structure from the actual table that contains a sorted list of
references to the table rows.
In SQL, wildcard operators are special characters used with the LIKE operator in a WHERE clause
to search for a specified pattern in a column. There are two main wildcard operators:
Percentage (%): Represents zero or more characters.
For example, LIKE 'a%' finds any values that start with "a".
LIKE '%a' finds any values that end with "a".
LIKE '%or%' finds any values that have "or" in any position.
Underscore (_): Represents a single character.
For example, LIKE '_r%' finds any values that have "r" in the second position.
SQL performance tuning involves optimizing SQL queries and database structures to improve the
speed and efficiency of database operations. Here are some common strategies for SQL
performance tuning:
Use Indexes: Indexes can significantly speed up data retrieval operations. Ensure that tables are
properly indexed based on the queries being executed.
Limit the Use of Wildcards: Wildcard searches (LIKE '%value%') can be slow, especially on
large datasets. If possible, avoid using leading wildcards or consider full-text search solutions
for more complex text searches.
**Avoid SELECT ***: Instead of selecting all columns (SELECT *), specify only the columns
you need. This reduces the amount of data that needs to be retrieved and can improve
performance.
Use JOINs Efficiently: Use the appropriate type of JOIN (INNER JOIN, LEFT JOIN, etc.)
based on the relationship between tables. Ensure that JOIN conditions are indexed.
Avoid Nested Queries: Nested queries can be slow. Where possible, use JOINs or subqueries to
improve performance.
Optimize Data Retrieval: Use pagination (OFFSET and LIMIT in MySQL, ROWNUM in
Oracle) to retrieve data in smaller chunks rather than retrieving all data at once.
Minimize Transactions: Keep transactions short and minimize the number of round trips to the
database.
Use Stored Procedures: Stored procedures can reduce network traffic and improve performance
by executing multiple SQL statements in a single call to the database.
Use Database Profiling Tools: Use tools provided by the database system (e.g., EXPLAIN in
MySQL, SQL Server Profiler in SQL Server) to analyze query performance and identify
bottlenecks.
Monitor and Tune Regularly: Monitor database performance regularly and make adjustments
as needed. As data grows and usage patterns change, performance tuning requirements
may also change.
SKILLS LEARNT
The internship provided me with an opportunity to learn and develop various scientific and
professional skills. Some of the skills I learned include:
1. SQL querying : I gained hands-on experience in solving real world problems using
various optimization features present in SQL. I learned how to identify and exploit
vulnerabilities in different systems and applications.
2. Web Application Security: I learned about various web application security issues, such
as SQL injection. I learned how to use various encryption methods such as stored
procedures to identify and safeguard these vulnerabilities.
7. Data Analysis and Reporting: Used SQL for data analysis, including extracting and
transforming data, generating reports, and performing calculations and aggregations.
8. Query Optimization: Learnt techniques to optimize SQL queries for better performance,
including indexing strategies, query restructuring, and understanding query
execution plans.
WORK EXPERIENCE
During the internship, I worked on various projects that involved these technologies. Some of the
queries I worked on include:
Vendor Booth Assignments: I performed various querying related to the real world
database given by the instructor named vendor booth assignment wherein I learnt various
sorting techniques and rounding off numbers techniques in the most optimized manner.
Sub query and joins: I learnt how to deal with sub queries and solved various queries
which involved the join truncate and various other statements.
Aggregate functions: I performed basic database administration tasks, such as finding
min; max and using various others aggregate functions.
Encryption: Designed software to safeguard against SQL Injection attack for the
organization.
CHALLENGES FACED
Lack of Experience: Since I was new to some of the advanced features of SQL, I had to
spend extra time learning and practicing them.
Technical Issues: Sometimes, I faced technical issues with the tools and systems I was
working on, which caused delays in completing my tasks.
CHAPTER 4
CONCLUSION
In conclusion, this SQL internship offered a comprehensive and practical learning experience in
database management and querying, providing me with a valuable skill set that is in high demand
across industries. Throughout the internship, I gained hands-on experience with various aspects of
SQL, including database design, query optimization, transactions, and concurrency control.
I learnt how to design efficient and normalized database schemas, ensuring data integrity and
consistency. I also became proficient in writing complex SQL queries to retrieve, insert, update,
and delete data, as well as in using advanced SQL features such as joins, sub queries, and aggregate
functions to manipulate and analyze data effectively.
One of the key takeaways from this SQL internship is the ability to optimize SQL queries for
improved performance. I learnt techniques such as indexing strategies, query restructuring, and
understanding query execution plans to optimize the performance of database operations.
Overall, this SQL internship provided me with a solid foundation in SQL and database
management, preparing them for roles in database administration, data analysis, software
development, and other related fields. The skills and knowledge acquired during this SQL
internship are highly transferable and can open up exciting career opportunities in the ever-growing
field of data management.
CHAPTER 5
BIBLIOGRAPHY
[1] V. K. Myalapalli and P. R. Savarapu, "High Performance SQL," 2014 Annual IEEE India
Conference (INDICON), Pune, India, 2014, pp. 1-6, doi: 10.1109/INDICON.2014.7030467.
[3] Y. Zhao and R. Chen, "Spark SQL Query Optimization Based on Runtime Statistics
Collection," 2021 IEEE 6th International Conference on Cloud Computing and Big Data Analytics
(ICCCBDA), Chengdu, China, 2021, pp. 250-255, doi: 10.1109/ICCCBDA51879.2021.9442524 .
[5] A. Joshi and V. Geetha, "SQL Injection detection using machine learning," 2014
International Conference on Control, Instrumentation, Communication and Computational
Technologies (ICCICCT), Kanyakumari, India, 2014, pp. 1111-1115, doi:
10.1109/ICCICCT.2014.6993127.
Date :
Week#: 1
Student ID 20BBTCS008
Learnt about creation of database and tables and performed various functions
inside a database
Extraction of data from database and usage of SELECT statement
Work completed
this week Writing queries for database involving various constraints
Deliverables
submitted this Tasks which were given by the Mentor
week
Comment by Guide
Signature of
Students with
Date
Signature of Guide
with Date
Internship
Date :
Week#: 2
Student ID 20BBTCS008
Work completed Learnt how to create ER diagrams, learnt how to work with duplicated records,
this week learnt how to update a database, learnt about subquery and joins.
Deliverables
submitted this Tasks given by the Mentor
week
contribution for the Solve organization related queries with high end efficiency.
week
Comment by Guide
Signature of
Students with
Date
Signature of Guide
with Date
Internship
Date :
Week#: 3
Student ID 20BBTCS008
Learnt about the various types of joins and how to implement queries involving
Work completed joins.
this week Learnt about the aggregate functions.
Comment by Guide
Signature of
Students with
Date
Signature of Guide
with Date