Allan Gitobu - User contributions [en]

Main Page

2024-04-08T21:31:37Z

Leksy:

==Learning French==
I have decided to learn French. I do not have a specific purpose for doing that. Like many other technological inventions, that are made and then end users come up with uses for them, so is my French course. I will find a use for it. Technological inventions could also be made with a specific purpose in mind but turn out to be used in a completely different way. The inventor of the screwdriver did not know that she was making a tin can opener. I will log my struggles in learning French on a separate page and invite any help anyone could offer me.

==A prototype is a mannequin?==
Anyone who has developed software for someone else will easily agree that instructions are never clear – and if they are clear, they are never adequate. That “someone else” is a customer, and as in business – “the customer is always right”. As developers, though, we must find how to play back what we understood the customer to be saying. The one way to parrot back is using the prototype. This is one way by which stakeholders could tell if they were understood while it gives them a chance to clarify their instructions.
XCode and Android Studio are wired to create a type of app without updating the boilerplate code. It makes it easy to drop controls on it and create a mannequin – I mean a prototype. It is possible to create some navigation, and menu bars without much code. The mannequin will show how it will all fit together.

==ScrollView and StackView==
I said a StackView is much like a Home Depot packing box in a previous post. You place your controls in the StackView much like you place items in a packing box. The only thing you state regarding positioning is where the StackView sits.
A ScrollView is much like a floater thing in a swimming pool. We define the size of the pool and tell the float how much it can move around the pool.

I think I am right.

==Isn’t XCode’s StackView much like a Home Depot packing box?==
Autolayout in XCode can quickly come across as something difficult to understand. To a new learner, one may wonder how to use the StackView to manage the placement of controls on a screen. The problem is that we must tell a StackView where to sit and give some direction on the controls inside it on where to stay, what direction to face, how far they are to be away from one another etc. To ease the explanation, I think this view is very much like a storage box that then gets stacked away (stacked?) in a storage room. If we store tools in a storage box, those hammers and spanners do not have to know where they are in the store. They just need to know that they are in the storage box. We only must decide where the storage box gets placed, in which case we just set two dimensions (essentially). How far the package will be from the wall on the side, and how far it will be from the wall in the front. That’s it. The box is stored; hence the spanners and hammers stay put. Right?

==Who likes computers?==
I'm not too fond of computers. I don’t.

Being an IT professional, this might surprise many. I believe computers are nothing more than work tools that are supposed to enhance our productivity. We should be able to make computers work for us and not the other way around. This is not always the case. We have heard of having been more glued and tethered to technology, such that we were freer when there was less technology. This should not be the case. Technology is intended to add to our freedom and create greater flexibility.

[[File:network_part.jpeg|300px]]

That said, I like what computers do and what they can do. I love to explore technology and what it is capable of doing not only to support the business but our very lives. During the COVID-19-mandated lockdown, with people working remotely and school classes running online, we appear to need computers for our very lives. We cannot live and work without them.

My liking for what computers can do, and not a love for computers, has led me to develop a deep interest in telling computers what to do. And since computers run on software, I found myself becoming a software developer. My journey as a software developer has been guided by my interpretation of what information systems are – a science that guides the acquisition, storage, retrieval, and use of information. Computers can fall well on that food chain as they guide how we get information in whatever format it is, store it in database systems, retrieve and display it, and guide the use of it to promote life and business.

I started in telecommunications in Kenya in the early ’90s working on Public Switched Telephone Network (PSTN) maintaining switches. At the turn of the century, I took up a job as a cellular network switching engineer where I was, and still am, fascinated by how cell phone networks carry voice and data.

Coming to college in America I did my undergraduate in Computer Information Systems and a masters degree in Management Information Systems. That led me to the pursuit of a PhD in Information Systems and Technology at [https://cgu.edu Claremont Graduate University]. While working on these degrees I have held software development jobs with an emphasis on database development.

[[File:cgu.jpeg|350px]]

Allan Gitobu:About

2024-04-04T22:21:15Z

Leksy:

I do not like computers. I really don’t. I just like what they do and what they can do. I love to explore technology and what it is capable of doing not only to support business but our very lives. My liking for what computers can do, instead of a love for computers, has led me to develop a deep interest in telling computers what to do. And since computers run on software, I found myself becoming a software developer. My journey as a software developer has been guided by my interpretation of what information systems is – a science that guides the acquisition, storage, retrieval, and use of information. Computers can fall well on that food chain as they guide how we get information in whatever format it is, store it in database systems, retrieve and display it, and guide the use of it to promote life and business.

I started off in telecommunications in Kenya in the early 90’s working on a public switched telephone network (PSTN) maintaining switches. At the turn of the century, I took up a job as a cellular network switching engineer where I was and still am, fascinated by how cell phone networks carry voice and data.

Coming to college in America I did my undergraduate in Computer Information Systems and a master's degree in Management Information Systems. That led me to a pursuit of a PhD in Information Systems and Technology at Claremont Graduate University. While working on these degrees I have held software development jobs with an emphasis on database development.

I am an information system professional bridging business and Information Technology. I have proven experience in the entire spectrum of system development demonstrated by hands-on experience in designing and implementing information systems projects that add value to businesses and serve the end-users. In addition, I am actively involved in creating computer and mobile device systems that support business operations.

My skills center on how computer systems support the acquisition, storage, retrieval, and use of data to support business. My expertise lies in the data tasks space, including SQL, shell scripts, web, and mobile applications. For mobile apps, I develop in Android and XCode. My recent web development tasks have been on JSP. I have built systems using ColdFusion and Java. I have a working knowledge of Oracle SQL, MS Access, and anything Microsoft Office.

[[File:graduated.jpg|350px]]

I teach mobile app development, database management, and software engineering as a university professor. In addition, I tutor mobile app development, seeing students create functional business mobile apps.

I have completed studies in telecommunications, and I hold graduate degrees in Information systems and Technology. My Ph.D. research centered on how Technology can support safe and appropriate use of over-the-counter drugs using mobile apps.

Specialties: XCode, Android, SQL, ColdFusion programming, Database development, SQL Database Developer, MS Access Database Developer, Project Management.

Allan Gitobu:About

2024-04-04T22:20:09Z

Leksy:

I do not like computers. I really don’t. I just like what they do and what they can do. I love to explore technology and what it is capable of doing not only to support business but our very lives. My liking for what computers can do, instead of a love for computers, has led me to develop a deep interest in telling computers what to do. And since computers run on software, I found myself becoming a software developer. My journey as a software developer has been guided by my interpretation of what information systems is – a science that guides the acquisition, storage, retrieval, and use of information. Computers can fall well on that food chain as they guide how we get information in whatever format it is, store it in database systems, retrieve and display it, and guide the use of it to promote life and business.

I started off in telecommunications in Kenya in the early 90’s working on a public switched telephone network (PSTN) maintaining switches. At the turn of the century, I took up a job as a cellular network switching engineer where I was and still am, fascinated by how cell phone networks carry voice and data.

Coming to college in America I did my undergraduate in Computer Information Systems and a master's degree in Management Information Systems. That led me to a pursuit of a PhD in Information Systems and Technology at Claremont Graduate University. While working on these degrees I have held software development jobs with an emphasis on database development.

I am an information system professional bridging business and Information Technology. I have proven experience in the entire spectrum of system development demonstrated by hands-on experience in designing and implementing information systems projects that add value to businesses and serve the end-users. In addition, I am actively involved in creating computer and mobile device systems that support business operations.

My skills center on how computer systems support the acquisition, storage, retrieval, and use of data to support business. My expertise lies in the data tasks space, including SQL, shell scripts, web, and mobile applications. For mobile apps, I develop in Android and XCode. My recent web development tasks have been on JSP. I have built systems using ColdFusion and Java. I have a working knowledge of Oracle SQL, MS Access, and anything Microsoft Office.

[[File:cgu.jpeg|350px]]

I teach mobile app development, database management, and software engineering as a university professor. In addition, I tutor mobile app development, seeing students create functional business mobile apps.

I have completed studies in telecommunications, and I hold graduate degrees in Information systems and Technology. My Ph.D. research centered on how Technology can support safe and appropriate use of over-the-counter drugs using mobile apps.

Specialties: XCode, Android, SQL, ColdFusion programming, Database development, SQL Database Developer, MS Access Database Developer, Project Management.

File:Graduated.jpg

2024-04-04T22:14:56Z

Leksy: Graduated at CGU

== Summary ==
Graduated at CGU

SELECT queries

2024-02-08T23:38:25Z

Leksy: /* LEFT OUTER JOIN */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.BDATE, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME 
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME 
FROM EMPLOYEE E 
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong') 
UNION 
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
INTERSECT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
EXCEPT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
MINUS 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, 
E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:38:15Z

Leksy: /* FULL OUTER JOIN */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.BDATE, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME 
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME 
FROM EMPLOYEE E 
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong') 
UNION 
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
INTERSECT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
EXCEPT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
MINUS 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, 
E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:37:46Z

Leksy: /* Order by one value ascending (implied) */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.BDATE, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME 
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME 
FROM EMPLOYEE E 
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong') 
UNION 
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
INTERSECT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
EXCEPT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
MINUS 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, 
E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:37:13Z

Leksy: /* Order by one value DESC (implied) */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.BDATE, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME 
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME 
FROM EMPLOYEE E 
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong') 
UNION 
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
INTERSECT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
EXCEPT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
MINUS 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, 
E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:36:32Z

Leksy: /* Order by cascaded */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.BDATE, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME 
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME 
FROM EMPLOYEE E 
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong') 
UNION 
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
INTERSECT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
EXCEPT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
MINUS 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, 
E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:35:54Z

Leksy: /* Where subquery */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.BDATE, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME 
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME 
FROM EMPLOYEE E 
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong') 
UNION 
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
INTERSECT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
EXCEPT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
MINUS 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, 
E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:35:35Z

Leksy: /* UNION */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.BDATE, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME 
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong') 
UNION 
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
INTERSECT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
EXCEPT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
MINUS 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, 
E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:35:10Z

Leksy: /* INTERSECT */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.BDATE, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME 
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
INTERSECT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
EXCEPT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
MINUS 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, 
E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:34:46Z

Leksy: /* EXCEPT */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.BDATE, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME 
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other.

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
EXCEPT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
MINUS 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, 
E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:34:23Z

Leksy: /* EXCEPT */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.BDATE, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME 
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
EXCEPT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
MINUS 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, 
E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:33:54Z

Leksy: /* EXCEPT */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.BDATE, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME 
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
/*Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
EXCEPT 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
MINUS 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, 
E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:33:13Z

Leksy: /* MINUS */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.BDATE, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME 
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME 
FROM EMPLOYEE, DEPARTMENT 
WHERE SSN = MGR_SSN 
MINUS 
SELECT LNAME, FNAME 
FROM EMPLOYEE, WORKS_ON 
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, 
E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:32:32Z

Leksy: /* Order of operations for OR and AND */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.BDATE, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME 
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, 
E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.SEX, E.SALARY, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:31:02Z

Leksy: /* Having Clause */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.BDATE, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME 
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:30:47Z

Leksy: /* Grouping Data */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.BDATE, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ 
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER 
JOIN EMPLOYEE E ON WO.ESSN = E.SSN 
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:30:24Z

Leksy: /* BETWEEN Syntax */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, 
E.LNAME LAST_NAME, 
E.BDATE, 
E.SUPER_SSN MGR_NUMBER, 
M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:29:42Z

Leksy: /* IN Syntax */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:29:32Z

Leksy: /* Not Syntax */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:29:21Z

Leksy: /* AND Syntax */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:29:09Z

Leksy: /* OR Syntax */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:28:57Z

Leksy: /* WHERE Clause */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE M.LNAME = 'Wallace'; 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/ 

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN 
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:27:38Z

Leksy: /* Order by one value ascending (implied) */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME, 
MINIT "MIDDLE INITIAL" , 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE BIRTH_DATE, 
ADDRESS, 
SEX GENDER, 
SALARY, 
SUPER_SSN "SUPERVISOR NUMBER", 
DNO 
FROM EMPLOYEE 
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace';

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:27:05Z

Leksy: /* Recursive join */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME 
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace';

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:26:49Z

Leksy: /* RIGHT OUTER JOIN */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME 
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace';

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:26:29Z

Leksy: /* Using JOIN ON syntax */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT 
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace';

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:26:12Z

Leksy: /* Using the USING syntax */

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION 
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION
FROM DEPARTMENT
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace';

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:25:43Z

Leksy:

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/ 
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/ 
LNAME "LAST NAME", 
SSN "SOCIAL SECURITY NUMBER", 
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/ 
ADDRESS, 
SEX GENDER, /*Alias without AS keyword*/ 
SALARY, 
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/ 
DNO 
FROM EMPLOYEE; 

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION
FROM DEPARTMENT
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace';

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T23:19:05Z

Leksy:

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/
ADDRESS,
SEX GENDER, /*Alias without AS keyword*/
SALARY,
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/
DNO
FROM EMPLOYEE;

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

==Using the USING syntax==
Based on values with a common name

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

==Using JOIN ON syntax==

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION
FROM DEPARTMENT
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

==LEFT OUTER JOIN==
All data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==RIGHT OUTER JOIN==
All data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==FULL OUTER JOIN==

All data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

==Cross join ==

All attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

==Joining tables with an alias==

Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

==Recursive join==
A table joins itself

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME;

==Order by one value ascending (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

==Order by one value DESC (implied)==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

==Order by cascaded==

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

==WHERE Clause==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace';

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

==OR Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

==AND Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

==Not Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME != 'Wong';

==IN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong','Wallace');

==BETWEEN Syntax==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

==Grouping Data==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME

==Having Clause==

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

==Where subquery==

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

==UNION==

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

==INTERSECT==

Tuples that are found in both type compatible relations.

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==EXCEPT==
Results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==MINUS==
Tuples in one relation but not in the other

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

==Order of operations for OR and AND==

The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T22:45:01Z

Leksy:

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

==Using aliases==

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/
ADDRESS,
SEX GENDER, /*Alias without AS keyword*/
SALARY,
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/
DNO
FROM EMPLOYEE;

==Computed columns - example from oracle==

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

==Computed columns - date arithmetic==

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

==Listing distinct values==

SELECT DISTINCT ESSN
FROM WORKS_ON;

==Using Natural Join - based on values with a common name*/

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

/*Using the USING syntax - based on values with a common name*/

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

/*Using JOIN ON syntax*/

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION
FROM DEPARTMENT
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

/*LEFT OUTER JOIN - all data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

/*RIGHT OUTER JOIN - all data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

/*FULL OUTER JOIN - all data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

/*Cross join - all attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

/*Joining tables with an alias. Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

/*Recursive join - a table joins itself*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

/*Order by one value ascending (implied)*/

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME;

/*Order by one value ascending (implied)*/

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

/*Order by one value DESC (implied)*/

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

/*Order by cascaded*/

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

/*WHERE Clause*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace';

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

/*OR Syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

/*AND Syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

/*Not Syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME != 'Wong';

/*IN Syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong','Wallace');

/*BETWEEN Syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

/*Grouping Data*/

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME

/*Having Clause*/

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

/*Where subquery*/

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

/*UNION*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

/*INTERSECT - tuples that are found in both type compatible relations*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

/*EXCEPT - results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

/*MINUS - tuples in one relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

/*The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T22:44:09Z

Leksy:

==selecting all content from a table==

SELECT *
FROM EMPLOYEE;

==Specifying the selected columns from a table==

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

/*Using aliases*/

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/
ADDRESS,
SEX GENDER, /*Alias without AS keyword*/
SALARY,
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/
DNO
FROM EMPLOYEE;

/*Computed columns - example from oracle*/

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

/*Computed columns - date arithmetic*/

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

/*Listing distinct values*/

SELECT DISTINCT ESSN
FROM WORKS_ON;

/*Using Natural Join - based on values with a common name*/

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

/*Using the USING syntax - based on values with a common name*/

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

/*Using JOIN ON syntax*/

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION
FROM DEPARTMENT
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

/*LEFT OUTER JOIN - all data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

/*RIGHT OUTER JOIN - all data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

/*FULL OUTER JOIN - all data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

/*Cross join - all attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

/*Joining tables with an alias. Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

/*Recursive join - a table joins itself*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

/*Order by one value ascending (implied)*/

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME;

/*Order by one value ascending (implied)*/

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

/*Order by one value DESC (implied)*/

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

/*Order by cascaded*/

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

/*WHERE Clause*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace';

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

/*OR Syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

/*AND Syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

/*Not Syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME != 'Wong';

/*IN Syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong','Wallace');

/*BETWEEN Syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

/*Grouping Data*/

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME

/*Having Clause*/

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

/*Where subquery*/

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

/*UNION*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

/*INTERSECT - tuples that are found in both type compatible relations*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

/*EXCEPT - results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

/*MINUS - tuples in one relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

/*The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

SELECT queries

2024-02-08T22:41:55Z

Leksy: Created page with "/*selecting all content from a table*/ SELECT * FROM EMPLOYEE; /*Specifying the selected columns from a table*/ SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY..."

/*selecting all content from a table*/

SELECT *
FROM EMPLOYEE;

/*Specifying the selected columns from a table*/

SELECT FNAME, MINIT, LNAME, SSN, BDATE, ADDRESS, SEX, SALARY, SUPER_SSN, DNO
FROM EMPLOYEE;

/*Using aliases*/

SELECT FNAME FIRST_NAME, /*The FNAME column is renamed FIRST_NAME*/
MINIT "MIDDLE INITIAL" , /*Renaming with a space*/
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE AS BIRTH_DATE, /*Renaming with the AS keyword*/
ADDRESS,
SEX GENDER, /*Alias without AS keyword*/
SALARY,
SUPER_SSN "SUPERVISOR SOCIAL SECURITY NUMBER", /*A long alias. It might not work in all DBMS such as oracle*/
DNO
FROM EMPLOYEE;

/*Computed columns - example from oracle*/

SELECT FNAME, TRUNC((SYSDATE - BDATE) / 365) AS AGE

FROM EMPLOYEE;

/*Computed columns - date arithmetic*/

SELECT FNAME, BDATE BIRTH_DATE, BDATE + (65 * 365) as RETIREMENT_DATE

FROM EMPLOYEE;

/*Listing distinct values*/

SELECT DISTINCT ESSN
FROM WORKS_ON;

/*Using Natural Join - based on values with a common name*/

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION

FROM DEPARTMENT NATURAL JOIN DEPT_LOCATIONS;

/*Using the USING syntax - based on values with a common name*/

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION
FROM DEPARTMENT JOIN DEPT_LOCATIONS USING (DNUMBER);

/*Using JOIN ON syntax*/

SELECT DEPARTMENT.DNAME, DEPT_LOCATIONS.DLOCATION
FROM DEPARTMENT
JOIN DEPT_LOCATIONS ON DEPARTMENT.DNUMBER = DEPT_LOCATIONS.DNUMBER;

/*LEFT OUTER JOIN - all data on "left side" table and nulls, if no data, from right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE LEFT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

/*RIGHT OUTER JOIN - all data on the "right side" table and nulls, if no data, from the "left side" table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE RIGHT OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

/*FULL OUTER JOIN - all data on the "right side" table and nulls, if no data, from the "left side" table AND all data on the left side table and nulls, if no data, on the right side table*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE FULL OUTER JOIN DEPENDENT ON EMPLOYEE.SSN = DEPENDENT.ESSN;

/*Cross join - all attributes are joined in a cartesian product*/

SELECT EMPLOYEE.SSN, EMPLOYEE.FNAME, EMPLOYEE.LNAME, DEPENDENT.DEPENDENT_NAME
FROM EMPLOYEE CROSS JOIN DEPENDENT;

SELECT EMPLOYEE.*, DEPENDENT.*
FROM EMPLOYEE CROSS JOIN DEPENDENT;

/*Joining tables with an alias. Here EMPLOYEE is renamed E and DEPENDENT is renamed D*/

SELECT E.SSN, E.FNAME, E.LNAME, D.DEPENDENT_NAME
FROM EMPLOYEE E INNER JOIN DEPENDENT D ON E.SSN = D.ESSN;

/*Recursive join - a table joins itself*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN;

/*Order by one value ascending (implied)*/

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME;

/*Order by one value ascending (implied)*/

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME ASC;

/*Order by one value DESC (implied)*/

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY LNAME DESC;

/*Order by cascaded*/

SELECT FNAME FIRST_NAME,
MINIT "MIDDLE INITIAL" ,
LNAME "LAST NAME",
SSN "SOCIAL SECURITY NUMBER",
BDATE BIRTH_DATE,
ADDRESS,
SEX GENDER,
SALARY,
SUPER_SSN "SUPERVISOR NUMBER",
DNO
FROM EMPLOYEE
ORDER BY FNAME, LNAME;

/*WHERE Clause*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace';

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '01-JAN-1965'; /*ORACLE syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE <= '1965-01-01'; /*H2 syntax*/

/*OR Syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME = 'Wallace' OR M.LNAME = 'Borg';

/*AND Syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.LNAME = 'English' AND M.LNAME = 'Wong';

/*Not Syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME != 'Wong';

/*IN Syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong','Wallace');

/*BETWEEN Syntax*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.BDATE, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.BDATE BETWEEN '1960-01-01' AND '1969-12-31'

/*Grouping Data*/

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME

/*Having Clause*/

SELECT P.PNAME, COUNT(ESSN) AS NO_OF_EMP_ON_PROJ
FROM WORKS_ON WO JOIN PROJECT P ON WO.PNO = P.PNUMBER
JOIN EMPLOYEE E ON WO.ESSN = E.SSN
GROUP BY P.PNAME
HAVING COUNT(ESSN) <= 2

/*Where subquery*/

SELECT E.SSN, E.FNAME FIRST_NAME, E.LNAME LAST_NAME
FROM EMPLOYEE E
WHERE E.SSN IN (SELECT ESSN FROM DEPENDENT);

/*UNION*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wong')
UNION
SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE M.LNAME in ('Wallace');

/*INTERSECT - tuples that are found in both type compatible relations*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
INTERSECT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

/*EXCEPT - results in tuples that are in one type compatible relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

/*MINUS - tuples in one relation but not in the other*/

SELECT LNAME, FNAME
FROM EMPLOYEE, DEPARTMENT
WHERE SSN = MGR_SSN
EXCEPT
SELECT LNAME, FNAME
FROM EMPLOYEE, WORKS_ON
WHERE ESSN=SSN AND HOURS > 0

/*The order of operations is important in OR and AND operands. The following queries produce different results. The first has no parenthesis, which is adjudicated first*/

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555 AND E.SALARY > 40000.00;

SELECT E.SSN EMP_NUMBER, E.LNAME LAST_NAME, E.SEX, E.SALARY, E.SUPER_SSN MGR_NUMBER, M.LNAME MANAGER_LAST_NAME
FROM EMPLOYEE E JOIN EMPLOYEE M ON E.SUPER_SSN = M.SSN
WHERE (E.SUPER_SSN = 333445555 OR E.SUPER_SSN = 888665555) AND E.SALARY > 40000.00;

Algorithms

2022-11-13T15:13:32Z

Leksy:

Below is a collection of algorithms. The title of the algorithm describes (as much as possible) what the algorithm does.

==Java Graph Implementation with Search Methods==

The algorithm below implements the organization chart below:

Jimbo Jones is employee id 38 and is the President.

Mike McCobb, id 39, is a VP and reports to Jimbo Jones.

Elda Two, id 43, is a VP and reports to Jimbo Jones.

Simon Sneath, id 48, is a VP and reports to Jimbo Jones.

Tim Scott, id 56, is a Manager and reports to Mike McCobb.

Bob Tilman, id 58, is a Manager and reports to Mike McCobb.

Andrew Cole, id 78, is an Analyst and reports to Tim Scott.

Matt Lemon, id 83, is an Analyst and reports to Tim Scott.

Chris Lock, id 88, is an Analyst and reports to Tim Scott.

Agnes White, id 71, is an Accountant and reports to Bob Tilman.

George Mills, id 61, is a Manager and reports to Elda Two.

Thomas Wells, id 59, is a Manager and reports to Elda Two.

Zip Two, id 63, is Manager and also reports to Elda Two.

Rasta Him, id 73, is a Technician and reports to Thomas Wells.

Claire Collins, id 89, is a Supervisor and reports to George Mills.

Jim Four, id 95, is a Receptionist and reports to Claire Collins.

Tom Flat, id 104, is a Receptionist who reports to Claire Collins.

Grace Marks, id 64, is a Manager and reports to Simon Sneath.

Dan Four, id 68, is a Manager and reports to Simon Sneath.

Shad Fifty, id 117, is in Security and reports to Dan Four.

Tall Nephew, id 108, is in Legal and reports to Grace Marks.

Short Nephew, id 109, is in Legal and reports to Grace Marks.

import java.util.HashMap;
import java.util.LinkedList;

public class Chart {
static class Employee {
int id;
String firstName;
String lastName;
String jobTitle;
boolean mapped;

Employee(int id, String fn, String ln, String jt) {
this.id = id;
this.jobTitle = jt;
this.firstName = fn;
this.lastName = ln;
}

void map() {
mapped = true;
}

void unmap() {
mapped = false;
}
}

private final HashMap<Employee, LinkedList<Employee>> assignment;

public Chart(boolean directed) {
assignment = new HashMap<>();
}

public void addEdgeHelper(Employee a, Employee b) {
LinkedList<Employee> e = assignment.get(a);
if (e != null) {
assignment.remove(b);
} else
e = new LinkedList<>();
e.add(b);
assignment.put(a, e);
}

public void addEdge(Employee boss, Employee subordinate) {
if (!assignment.containsKey(boss))
assignment.put(boss, null);
if (!assignment.containsKey(subordinate))
assignment.put(subordinate, null);
addEdgeHelper(boss, subordinate);
}

public void depthFirstSearch(Employee employee) {
employee.map();
System.out.println(employee.firstName + " " + employee.lastName + " is a " + employee.jobTitle);
LinkedList<Employee> neighbors = assignment.get(employee);
if (neighbors == null)
return;
for (Employee e : neighbors) {
if (!e.mapped)
depthFirstSearch(e);
}
}

public void breadthFirstSearch(Employee employee) {
/*Check if target item is null - if so quit*/
if (employee == null)
return;
/*Declare a queue using LinkedList and add the target item*/
LinkedList<Employee> queue = new LinkedList<>();
queue.add(employee);
/*As long as the queue has data get the first in item .removeFirst*/
while (!queue.isEmpty()) {
Employee currentFirst = queue.removeFirst();
/*If visited move on*/
if (currentFirst.mapped) {
continue;
} else {
/*else visit it and print it*/
currentFirst.map();
System.out.println(currentFirst.id + ": " + currentFirst.firstName + " " + currentFirst.lastName + " - " + currentFirst.jobTitle);
}
/*Find neighbors of the current item*/
LinkedList<Employee> allNeighbors = assignment.get(currentFirst);
/*If there are none move on*/
if (allNeighbors == null)
continue;
/*else if there are some and not visited, add them to the queue and the process starts over*/
for (Employee e : allNeighbors) {
if (!e.mapped)
queue.add(e);
}
}
}

public void resetMapping() {
for (Employee e : assignment.keySet()) {
e.unmap();
}
}

public static void main(String args[]) {
Employee a = new Employee(38, "Jimbo", "Jones", "President");
Employee b = new Employee(39, "Mike", "McCobb", "VP");
Employee c = new Employee(43, "Elda", "Two", "VP");
Employee d = new Employee(48, "Simon", "Sneeth", "VP");
Employee e = new Employee(56, "Tim", "Scott", "Manager");
Employee f = new Employee(58, "Bob", "Tilman", "Manager");
Employee g = new Employee(78, "Andrew", "Cole", "Analyst");
Employee h = new Employee(83, "Matt", "Lemon", "Analyst");
Employee i = new Employee(88, "Chris", "Lock", "Analyst");
Employee j = new Employee(71, "Agnes", "White", "Accountant");
Employee k = new Employee(61, "George", "Mills", "Manager");
Employee l = new Employee(59, "Thomas", "Wells", "Manager");
Employee m = new Employee(63, "Zip", "Two", "Manager");
Employee n = new Employee(73, "Rasta", "Him", "Technician");
Employee o = new Employee(89, "Claire", "Collins", "Supervisor");
Employee p = new Employee(95, "Jim", "Four", "Receptionist");
Employee q = new Employee(104, "Tom", "Flat", "Receptionist");
Employee r = new Employee(64, "Grace", "Marks", "Manager");
Employee s = new Employee(68, "Dan", "Four", "Manager");
Employee t = new Employee(117, "Shad", "Fifty", "Security");
Employee u = new Employee(108, "Tall", "Nephew", "Legal");
Employee v = new Employee(109, "Short", "Nephew", "Legal");

Chart chart = new Chart(true);
chart.addEdge(a, b);
chart.addEdge(a, c);
chart.addEdge(a, d);
chart.addEdge(b, e);
chart.addEdge(b, f);
chart.addEdge(e, g);
chart.addEdge(e, h);
chart.addEdge(e, i);
chart.addEdge(f, j);
chart.addEdge(c, k);
chart.addEdge(c, l);
chart.addEdge(c, m);
chart.addEdge(l, n);
chart.addEdge(k, o);
chart.addEdge(o, p);
chart.addEdge(o, q);
chart.addEdge(d, r);
chart.addEdge(d, s);
chart.addEdge(s, t);
chart.addEdge(r, u);
chart.addEdge(r, v);
//System.out.println(a.firstName + " " + a.lastName + " " + a.jobTitle + " " + a.id);
chart.resetMapping();
//chart.depthFirstSearch(k);

chart.resetMapping();
chart.breadthFirstSearch(a);
}
}

==Find missing number==
You are given an array of positive numbers from 1 to n, such that all numbers from 1 to n are present except one number x. You have to find x. The input array is not sorted. Look at the below array and give it a try before checking the solution.

The missing number = a sum of the provided array subtracted from a sum of indices + 2
example 1, 2, 4 missing is 3 = (1 +2 +3+4) - (1 +2+4)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MissingNum {
public static int findMissing(List<Integer> l) {
int tot_prov = 0;
for (Integer integer : l) {
tot_prov += integer;
}
List<Integer> k = new ArrayList<>();
int tot_req = 0;
for (int i = 0; i < l.size() + 2; i++) {
k.add(i);
tot_req += k.get(i);
}
return tot_req - tot_prov;
}

public static void main(String[] args) {
List<Integer> g = Arrays.asList(8, 5, 3, 2, 4, 1, 7);
System.out.println("The missing number is " + findMissing(g));
}
}

==Mergesort==
public class MergeSort {

private static Comparable[] aux;

public static void sort(Comparable[] a) {
aux = new Comparable[a.length];
sort(a, 0, a.length - 1);
}

private static void merge(Comparable[] a, int lo, int mid, int hi) {
assert isSorted(a, lo, mid);
assert isSorted(a, mid + 1, hi);
//copy for [] a to [] aux
for (int k = lo; k <= hi; k++) {
aux[k] = a[k];
}
// the merging process
// i is the first index of the first half of the array
// j is the first index of the second half of the array
int i = lo, j = mid + 1;

// for every value of k - the indices of [] a
for (int k = lo; k <= hi; k++) {
/*Left half exhausted take from the right*/
if (i > mid)
a[k] = aux[j++];
/*Right half exhausted take from the left*/
else if (j > hi)
a[k] = aux[i++];
/*Current key on the right less than current key on the left take from the right*/
else if (less(aux[j], aux[i]))
a[k] = aux[j++];
/*Current key on the right greater than current key on the left take from the left */
else
a[k] = aux[i++];
}
assert isSorted(a, lo, hi);
}

private static void sort(Comparable[] a, int lo, int hi) {
if (hi <= lo)
return;
int mid = lo + (hi - lo) / 2;
sort(a, lo, mid);
sort(a, mid + 1, hi);
merge(a, lo, mid, hi);
}

private static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}

private static boolean isSorted(Comparable[] a, int lo, int hi) {
for (int i = lo + 1; i <= hi; i++)
if (less(a[i], a[i - 1])) return false;
return true;
}

public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
//System.out.print(a[i]);
System.out.println(a[i]);
}
}

public static void main(String args[]) {
// Comparable[] a = {"E", "E", "G", "M", "R", "A", "C", "E", "R", "T"};

Comparable[] aa = {"A", "X", "G", "M", "R"};
Comparable[] bb = {"H", "D", "J", "Y", "Z"};
/*Merge the two comparable arrays*/
Comparable[] a = new Comparable[aa.length + bb.length];
System.arraycopy(aa, 0, a, 0, aa.length);
System.arraycopy(bb, 0, a, aa.length, bb.length);

MergeSort.sort(a);
show(a);
}
}
==Binary Search==
public class BinarySearch {
public static int find(int[] arr, int target) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = left + (right - left);
if (arr[mid] == target)
return mid;
if (arr[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}

public static void main(String args[]) {
int[] f = {1, 10, 20, 47, 59, 63, 75, 88, 99, 107, 120, 133, 155, 162, 176, 188, 199, 200, 210, 222, 223};
int t = 162;
System.out.println(find(f, t));
}
}

==Validate Binary Search Tree==

Given a Binary Tree, figure out whether it’s a Binary Search Tree. In a binary search tree, each node’s key value is smaller than the key value of all nodes in the right subtree, and is greater than the key values of all nodes in the left subtree. Below is an example of a binary tree that is a valid BST.

public class BinarySearchTree {
static class Node {
int value;
Node left;
Node right;
Node(int value) {
this.value = value;
this.left = null;
this.right = null;
}
}
Node root;
public BinarySearchTree() {
root = null;
}
public boolean isbst(Node root, Node l, Node r) {
if (root == null)
return true;
if (l != null && l.value > root.value)
return false;
if (r != null && r.value < root.value)
return false;
return isbst(root.left, l, root) && isbst(root.right, root, r);
}

public static void main(String args[]) {
BinarySearchTree bt = new BinarySearchTree();
bt.root = new Node(10);
bt.root.left = new Node(5);
bt.root.right = new Node(15);
bt.root.left.left = new Node(4);
bt.root.left.right = new Node(7);
bt.root.right.left = new Node(13);
bt.root.right.right = new Node(26);
if (bt.isbst(bt.root, null, null))
System.out.println("Is a BST");
else
System.out.println("Is not a BST");
}
}

==Determine if two integers add up to given number==
Given an array of integers and a value, determine if there are any two integers in the array whose sum is equal to the given value. Return true if the sum exists and return false if it does not. Consider this array and the target sums:
public class SumOfTwo {
public static void main(String args[]) {
Set<Integer> set = new HashSet<>(); /*Populate this Set with target values*/
/*Array of target values*/
int[] g = {5, 6, 8, 39, 9, 11, 20, 59, 10, 1};
/*Insert the arrays values in the set*/
for (int i = 0; i < g.length; i++) {
set.add(g[i]);
}
/*Set a target number to check for*/
int y = 20;
/*If there are a set of numbers that would add up, increment this counter*/
int counter = 0;
/*Pick up a number in the set by turns and assign it to x*/
for (int i = 0; i < g.length; i++) {
int x = g[i];
/*Check to see if the set contains target minus found number.*/
if (set.contains(y - x)) { //if this is true
/*If so, increment the counter by 1*/
counter += 1;
}
}
if (counter > 0) { /*Some numbers add up*/
System.out.println("There are sets of numbers that add up to " + y);
} else { /*No numbers add up*/
System.out.println("There are no sets of numbers that add up to " + y);
}

}
}

==Merge two sorted lists==
Given two sorted linked lists, merge them so that the resulting linked list is also sorted. Consider two sorted linked lists and the merged list below them as an example.
import java.util.Stack;
/*This code merges two ordered lists into one keeping their increasing order
* the lists used for testing are in the main function*/
public class MergeLists {
static class Node {
int data;
Node next;
Node(int z) {
this.data = z;
next = null;
}
}

/*This function reads the values of a list and loads them on a Stack, then reads from the stack*/
public static void loadInStack(Node f) {
Stack<Integer> pack = new Stack<>();
if (f == null)
return;
pack.push(f.data);
loadInStack(f.next);
System.out.println(pack);
}

/*This function duplicates the provided list into another one*/
public static void duplicateList(Node m) {
Node hold = new Node(-1);
if (m == null)
return;
hold.data = m.data;
duplicateList(m.next);
System.out.println(hold.data);
}

/*This function reads from two lists picking the lesser of*/
/*It takes in two lists as variables a and b*/
public static void pickTwo(Node a, Node b) {
/*This is a dummy list initialized with -1*/
Node dummyList = new Node(-1);
while (a != null && b != null) {
if (a.data <= b.data) {
/*populate the dummy list from a, if smaller*/
dummyList.data = a.data;
/*Increment a*/
a = a.next;
} else {
/*populate the dummy list from b, if smaller*/
dummyList.data = b.data;
/*Increment b*/
b = b.next;
}
/*Print when done*/
System.out.print(dummyList.data + " -> ");
}
}

public static void main(String args[]) {
Node f = new Node(2);
Node g = new Node(7);
Node h = new Node(8);
Node i = new Node(11);

f.next = g;
g.next = h;
h.next = i;

//printNodes(f);

Node k = new Node(4);
Node l = new Node(6);
Node m = new Node(9);
Node n = new Node(10);
Node o = new Node(12);

k.next = l;
l.next = m;
m.next = n;
n.next = o;

//loadInStack(f);
//duplicateList(k);
pickTwo(f, k);
}
}
==Reverse String==

Reverse the order of words in a given sentence (an array of characters).

import java.util.Iterator;
import java.util.LinkedList;

public class ReverseString {
public static void lizy(String[] curr) {
LinkedList<String> y = new LinkedList<>();
for (int g = 0; g <= curr.length - 1; g++) {
y.add(curr[g]);
}
Iterator i = y.descendingIterator();
while (i.hasNext()) {
System.out.print(i.next() + " ");
}
}
public static void main(String args[]) {
String given = "Hello World";
String[] given_array = given.split(" ");
String lineOfCurrencies = "USD JPY AUD SGD HKD CAD CHF GBP EURO INR";
String multispace = "Kenya Uganda Tanzania Burundi Rwanda";
String[] currencies = lineOfCurrencies.split(" ");
String[] ms = multispace.split("\\s+");
ReverseString.lizy(given_array);
}
}
==Level Order Traversal of Binary Tree==

Given the root of a binary tree, display the node values at each level. Node values for all levels should be displayed on separate lines. Let’s take a look at the below binary tree.

import java.util.LinkedList;

public class Lot {
static class Node {
int value;
Node left;
Node right;
Node(int v) {
this.value = v;
this.left = this.right = null;
}
}
Node root;
public Lot() {
root = null;
}
void lot() {
LinkedList<Node> queue = new LinkedList<>();
//Queue<Node> queue = new LinkedList<Node>();
queue.add(root);
while (!queue.isEmpty()) {
Node tempNode = queue.removeFirst();
//Node tempNode = queue.poll();
System.out.print(tempNode.value + " ");
if (tempNode.left != null)
queue.add(tempNode.left);
if (tempNode.right != null)
queue.add(tempNode.right);
}
}
public static void main(String args[]) {
Lot l = new Lot();
l.root = new Node(100);
l.root.left = new Node(50);
l.root.right = new Node(200);
l.root.left.left = new Node(25);
l.root.left.right = new Node(75);
l.root.right.right = new Node(350);
System.out.println("Level order traversal is as follows: ");
l.lot();
}
}
==String Segmentation==
You are given a dictionary of words and a large input string. You have to find out whether the input string can be completely segmented into the words of a given dictionary. The following two examples elaborate on the problem further.
import java.util.HashSet;
import java.util.Set;

public class Dictionary {
boolean pair(Set<String> dictionary, String a) {
for (int i = 0; i < a.length(); i++) {
String first_word = a.substring(0, i);
if (dictionary.contains(first_word)) {
String second_word = a.substring(i);
if (dictionary.contains(second_word) || pair(dictionary, second_word)) {
return true;
}
}
}
return false;
}

public static void main(String[] args) {
Dictionary dictionary = new Dictionary();
Set<String> dict = new HashSet<>();
dict.add("geo");
dict.add("science");
dict.add("politics");
dict.add("thermal");
dict.add("physical");
dict.add("mis");
dict.add("under");
dict.add("stand");
dict.add("understand");
String word = "misunderstand";
if (dictionary.pair(dict, word)) {
System.out.println("The test word " + word + " fits in two words in the dictionary");
} else {
System.out.println("The test word " + word + " does not make dictionary words");
}
}
}
==Computing number combinations==
Suppose we have coin denominations of [1, 2, 5] and the total amount is 7. We can make changes in the following 6 ways:

public class Combinations {
static int changeOptions(int[] denominations, int amount) {
int[] solution = new int[amount + 1];
solution[0] = 1;
for (int x : denominations) {
for (int i = x; i < (amount + 1); ++i) {
solution[i] += solution[i - x];
}
}
return solution[solution.length - 1];
}

public static void main(String[] args) {
int[] denominations = new int[]{1, 2, 5, 10};
int amount = 5;
int result = changeOptions(denominations, amount);
System.out.println("There are " + result + " combinations in forming " + amount + " given the factors below: ");
for (int denomination : denominations) {
System.out.println(denomination);
}
}
}
==Sum of two numbers==
Are there two numbers in the provided set that add up to the given number?
===Brute force method===

We start with a brute force method that checks every number. Big 0(n).

import java.util.HashSet;
import java.util.Set;

public class SumOfTwo {
public static void main(String args[]) {
Set<Integer> set = new HashSet<>(); /*Populate this Set with target values*/
/*Array of target values*/
int[] g = {5, 6, 8, 39, 9, 11, 20, 59, 10, 1};
/*Insert the arrays values in the set*/
for (int i = 0; i < g.length; i++) {
set.add(g[i]);
}
/*Set a target number to check for*/
int y = 20;
/*If there are a set of numbers that would add up, increment this counter*/
int counter = 0;
/*Pick up a number in the set by turns and assign it to x*/
for (int i = 0; i < g.length; i++) {
int x = g[i];
/*Check to see if the set contains target minus found number.*/
if (set.contains(y - x)) { //if this is true
/*If so, increment the counter by 1*/
counter += 1;
}
}
if (counter > 0) { /*Some numbers add up*/
System.out.println("There are sets of numbers that add up to " + y);
} else { /*No numbers add up*/
System.out.println("There are no sets of numbers that add up to " + y);
}

}
}
===Two pointer method===
This method uses a function to find the two numbers then makes a determination
import java.util.Arrays;

public class Addends {
static void doTwoNumbersAdd(int[] a, int b) {
int[] z = findAddingNumbers(a, b);
if (z.length > 0) {
System.out.println("There are two numbers that add up to " + b);
} else {
System.out.println("There are no numbers that add up to " + b);
}
}

static int[] findAddingNumbers(int[] arr, int t) {
Arrays.sort(arr);
int lo = 0;
int hi = (arr.length - 1);
while (lo < hi) {
if (arr[lo] + arr[hi] == t) {
return new int[]{arr[lo], arr[hi]};
} else if (arr[lo] + arr[hi] < t) {
lo++;
} else {
hi--;
}
}
return new int[]{};
}

public static void main(String[] args) {
int[] provided = {8, 5, 7, 3, 2, 9, 6, 4};
int target = 12;
System.out.println("These two numbers that add up to " + target + " are " + Arrays.toString(Addends.findAddingNumbers(provided, target)));
Addends.doTwoNumbersAdd(provided, target);
}
}

==Find two numbers that add up==
You have a set of numbers and another number (target) that is comprised of two numbers in the set added up. How do you find if there are two numbers in the set that add up?
import java.util.Arrays;

public class TwoThatAdd {
static int[] showAdded(int[] set, int target) {
Arrays.sort(set);
int left = 0;
int right = (set.length - 1);
while (left < right) {
if (set[left] + set[right] == target) {
return new int[]{set[left], set[right]};
} else if (set[left] + set[right] < target) {
left++;
} else {
right--;
}
}
return new int[]{};
}

public static void main(String[] args) {
int[] options = {2, 4, 6, 7, 11, 13, 16};
int target = 18;
System.out.println(Arrays.toString(TwoThatAdd.showAdded(options, target)));
}
}
==Find distinct letters in a word==
import java.util.HashSet;
import java.util.Set;

public class Distinct {
void print_distinct(String given) {
/*Take the given word and split it with commas to create an array*/
String[] arrayed = given.split("");
/*Add the values of the arrays to a set*/
Set<String> set = new HashSet<>(Arrays.asList(arrayed));
/*A set contains distinct values. Print them*/
System.out.println("Print distinct contents" + Arrays.toString(set.toArray()));
}

public static void main(String[] args) {
Distinct d = new Distinct();
String given = "mississippi";
d.print_distinct(given);
}
}

Algorithms

2022-10-27T15:36:47Z

Leksy: /* Sum of two numbers */

Algorithms

2022-10-27T15:34:28Z

Leksy:

Below is a collection of algorithms. The title of the algorithm describes (as much as possible) what the algorithm does.

==Java Graph Implementation with Search Methods==

The algorithm below implements the organization chart below:

Jimbo Jones is employee id 38 and is the President.

Mike McCobb, id 39, is a VP and reports to Jimbo Jones.

Elda Two, id 43, is a VP and reports to Jimbo Jones.

Simon Sneath, id 48, is a VP and reports to Jimbo Jones.

Tim Scott, id 56, is a Manager and reports to Mike McCobb.

Bob Tilman, id 58, is a Manager and reports to Mike McCobb.

Andrew Cole, id 78, is an Analyst and reports to Tim Scott.

Matt Lemon, id 83, is an Analyst and reports to Tim Scott.

Chris Lock, id 88, is an Analyst and reports to Tim Scott.

Agnes White, id 71, is an Accountant and reports to Bob Tilman.

George Mills, id 61, is a Manager and reports to Elda Two.

Thomas Wells, id 59, is a Manager and reports to Elda Two.

Zip Two, id 63, is Manager and also reports to Elda Two.

Rasta Him, id 73, is a Technician and reports to Thomas Wells.

Claire Collins, id 89, is a Supervisor and reports to George Mills.

Jim Four, id 95, is a Receptionist and reports to Claire Collins.

Tom Flat, id 104, is a Receptionist who reports to Claire Collins.

Grace Marks, id 64, is a Manager and reports to Simon Sneath.

Dan Four, id 68, is a Manager and reports to Simon Sneath.

Shad Fifty, id 117, is in Security and reports to Dan Four.

Tall Nephew, id 108, is in Legal and reports to Grace Marks.

Short Nephew, id 109, is in Legal and reports to Grace Marks.

import java.util.HashMap;
import java.util.LinkedList;

public class Chart {
static class Employee {
int id;
String firstName;
String lastName;
String jobTitle;
boolean mapped;

Employee(int id, String fn, String ln, String jt) {
this.id = id;
this.jobTitle = jt;
this.firstName = fn;
this.lastName = ln;
}

void map() {
mapped = true;
}

void unmap() {
mapped = false;
}
}

private final HashMap<Employee, LinkedList<Employee>> assignment;

public Chart(boolean directed) {
assignment = new HashMap<>();
}

public void addEdgeHelper(Employee a, Employee b) {
LinkedList<Employee> e = assignment.get(a);
if (e != null) {
assignment.remove(b);
} else
e = new LinkedList<>();
e.add(b);
assignment.put(a, e);
}

public void addEdge(Employee boss, Employee subordinate) {
if (!assignment.containsKey(boss))
assignment.put(boss, null);
if (!assignment.containsKey(subordinate))
assignment.put(subordinate, null);
addEdgeHelper(boss, subordinate);
}

public void depthFirstSearch(Employee employee) {
employee.map();
System.out.println(employee.firstName + " " + employee.lastName + " is a " + employee.jobTitle);
LinkedList<Employee> neighbors = assignment.get(employee);
if (neighbors == null)
return;
for (Employee e : neighbors) {
if (!e.mapped)
depthFirstSearch(e);
}
}

public void breadthFirstSearch(Employee employee) {
/*Check if target item is null - if so quit*/
if (employee == null)
return;
/*Declare a queue using LinkedList and add the target item*/
LinkedList<Employee> queue = new LinkedList<>();
queue.add(employee);
/*As long as the queue has data get the first in item .removeFirst*/
while (!queue.isEmpty()) {
Employee currentFirst = queue.removeFirst();
/*If visited move on*/
if (currentFirst.mapped) {
continue;
} else {
/*else visit it and print it*/
currentFirst.map();
System.out.println(currentFirst.id + ": " + currentFirst.firstName + " " + currentFirst.lastName + " - " + currentFirst.jobTitle);
}
/*Find neighbors of the current item*/
LinkedList<Employee> allNeighbors = assignment.get(currentFirst);
/*If there are none move on*/
if (allNeighbors == null)
continue;
/*else if there are some and not visited, add them to the queue and the process starts over*/
for (Employee e : allNeighbors) {
if (!e.mapped)
queue.add(e);
}
}
}

public void resetMapping() {
for (Employee e : assignment.keySet()) {
e.unmap();
}
}

public static void main(String args[]) {
Employee a = new Employee(38, "Jimbo", "Jones", "President");
Employee b = new Employee(39, "Mike", "McCobb", "VP");
Employee c = new Employee(43, "Elda", "Two", "VP");
Employee d = new Employee(48, "Simon", "Sneeth", "VP");
Employee e = new Employee(56, "Tim", "Scott", "Manager");
Employee f = new Employee(58, "Bob", "Tilman", "Manager");
Employee g = new Employee(78, "Andrew", "Cole", "Analyst");
Employee h = new Employee(83, "Matt", "Lemon", "Analyst");
Employee i = new Employee(88, "Chris", "Lock", "Analyst");
Employee j = new Employee(71, "Agnes", "White", "Accountant");
Employee k = new Employee(61, "George", "Mills", "Manager");
Employee l = new Employee(59, "Thomas", "Wells", "Manager");
Employee m = new Employee(63, "Zip", "Two", "Manager");
Employee n = new Employee(73, "Rasta", "Him", "Technician");
Employee o = new Employee(89, "Claire", "Collins", "Supervisor");
Employee p = new Employee(95, "Jim", "Four", "Receptionist");
Employee q = new Employee(104, "Tom", "Flat", "Receptionist");
Employee r = new Employee(64, "Grace", "Marks", "Manager");
Employee s = new Employee(68, "Dan", "Four", "Manager");
Employee t = new Employee(117, "Shad", "Fifty", "Security");
Employee u = new Employee(108, "Tall", "Nephew", "Legal");
Employee v = new Employee(109, "Short", "Nephew", "Legal");

Chart chart = new Chart(true);
chart.addEdge(a, b);
chart.addEdge(a, c);
chart.addEdge(a, d);
chart.addEdge(b, e);
chart.addEdge(b, f);
chart.addEdge(e, g);
chart.addEdge(e, h);
chart.addEdge(e, i);
chart.addEdge(f, j);
chart.addEdge(c, k);
chart.addEdge(c, l);
chart.addEdge(c, m);
chart.addEdge(l, n);
chart.addEdge(k, o);
chart.addEdge(o, p);
chart.addEdge(o, q);
chart.addEdge(d, r);
chart.addEdge(d, s);
chart.addEdge(s, t);
chart.addEdge(r, u);
chart.addEdge(r, v);
//System.out.println(a.firstName + " " + a.lastName + " " + a.jobTitle + " " + a.id);
chart.resetMapping();
//chart.depthFirstSearch(k);

chart.resetMapping();
chart.breadthFirstSearch(a);
}
}

==Find missing number==
You are given an array of positive numbers from 1 to n, such that all numbers from 1 to n are present except one number x. You have to find x. The input array is not sorted. Look at the below array and give it a try before checking the solution.

The missing number = a sum of the provided array subtracted from a sum of indices + 2
example 1, 2, 4 missing is 3 = (1 +2 +3+4) - (1 +2+4)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MissingNum {
public static int findMissing(List<Integer> l) {
int tot_prov = 0;
for (Integer integer : l) {
tot_prov += integer;
}
List<Integer> k = new ArrayList<>();
int tot_req = 0;
for (int i = 0; i < l.size() + 2; i++) {
k.add(i);
tot_req += k.get(i);
}
return tot_req - tot_prov;
}

public static void main(String[] args) {
List<Integer> g = Arrays.asList(8, 5, 3, 2, 4, 1, 7);
System.out.println("The missing number is " + findMissing(g));
}
}

==Mergesort==
public class MergeSort {

private static Comparable[] aux;

public static void sort(Comparable[] a) {
aux = new Comparable[a.length];
sort(a, 0, a.length - 1);
}

private static void merge(Comparable[] a, int lo, int mid, int hi) {
assert isSorted(a, lo, mid);
assert isSorted(a, mid + 1, hi);
//copy for [] a to [] aux
for (int k = lo; k <= hi; k++) {
aux[k] = a[k];
}
// the merging process
// i is the first index of the first half of the array
// j is the first index of the second half of the array
int i = lo, j = mid + 1;

// for every value of k - the indices of [] a
for (int k = lo; k <= hi; k++) {
/*Left half exhausted take from the right*/
if (i > mid)
a[k] = aux[j++];
/*Right half exhausted take from the left*/
else if (j > hi)
a[k] = aux[i++];
/*Current key on the right less than current key on the left take from the right*/
else if (less(aux[j], aux[i]))
a[k] = aux[j++];
/*Current key on the right greater than current key on the left take from the left */
else
a[k] = aux[i++];
}
assert isSorted(a, lo, hi);
}

private static void sort(Comparable[] a, int lo, int hi) {
if (hi <= lo)
return;
int mid = lo + (hi - lo) / 2;
sort(a, lo, mid);
sort(a, mid + 1, hi);
merge(a, lo, mid, hi);
}

private static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}

private static boolean isSorted(Comparable[] a, int lo, int hi) {
for (int i = lo + 1; i <= hi; i++)
if (less(a[i], a[i - 1])) return false;
return true;
}

public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
//System.out.print(a[i]);
System.out.println(a[i]);
}
}

public static void main(String args[]) {
// Comparable[] a = {"E", "E", "G", "M", "R", "A", "C", "E", "R", "T"};

Comparable[] aa = {"A", "X", "G", "M", "R"};
Comparable[] bb = {"H", "D", "J", "Y", "Z"};
/*Merge the two comparable arrays*/
Comparable[] a = new Comparable[aa.length + bb.length];
System.arraycopy(aa, 0, a, 0, aa.length);
System.arraycopy(bb, 0, a, aa.length, bb.length);

MergeSort.sort(a);
show(a);
}
}
==Binary Search==
public class BinarySearch {
public static int find(int[] arr, int target) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = left + (right - left);
if (arr[mid] == target)
return mid;
if (arr[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}

public static void main(String args[]) {
int[] f = {1, 10, 20, 47, 59, 63, 75, 88, 99, 107, 120, 133, 155, 162, 176, 188, 199, 200, 210, 222, 223};
int t = 162;
System.out.println(find(f, t));
}
}

==Validate Binary Search Tree==

Given a Binary Tree, figure out whether it’s a Binary Search Tree. In a binary search tree, each node’s key value is smaller than the key value of all nodes in the right subtree, and is greater than the key values of all nodes in the left subtree. Below is an example of a binary tree that is a valid BST.

public class BinarySearchTree {
static class Node {
int value;
Node left;
Node right;
Node(int value) {
this.value = value;
this.left = null;
this.right = null;
}
}
Node root;
public BinarySearchTree() {
root = null;
}
public boolean isbst(Node root, Node l, Node r) {
if (root == null)
return true;
if (l != null && l.value > root.value)
return false;
if (r != null && r.value < root.value)
return false;
return isbst(root.left, l, root) && isbst(root.right, root, r);
}

public static void main(String args[]) {
BinarySearchTree bt = new BinarySearchTree();
bt.root = new Node(10);
bt.root.left = new Node(5);
bt.root.right = new Node(15);
bt.root.left.left = new Node(4);
bt.root.left.right = new Node(7);
bt.root.right.left = new Node(13);
bt.root.right.right = new Node(26);
if (bt.isbst(bt.root, null, null))
System.out.println("Is a BST");
else
System.out.println("Is not a BST");
}
}

==Determine if two integers add up to given number==
Given an array of integers and a value, determine if there are any two integers in the array whose sum is equal to the given value. Return true if the sum exists and return false if it does not. Consider this array and the target sums:
public class SumOfTwo {
public static void main(String args[]) {
Set<Integer> set = new HashSet<>(); /*Populate this Set with target values*/
/*Array of target values*/
int[] g = {5, 6, 8, 39, 9, 11, 20, 59, 10, 1};
/*Insert the arrays values in the set*/
for (int i = 0; i < g.length; i++) {
set.add(g[i]);
}
/*Set a target number to check for*/
int y = 20;
/*If there are a set of numbers that would add up, increment this counter*/
int counter = 0;
/*Pick up a number in the set by turns and assign it to x*/
for (int i = 0; i < g.length; i++) {
int x = g[i];
/*Check to see if the set contains target minus found number.*/
if (set.contains(y - x)) { //if this is true
/*If so, increment the counter by 1*/
counter += 1;
}
}
if (counter > 0) { /*Some numbers add up*/
System.out.println("There are sets of numbers that add up to " + y);
} else { /*No numbers add up*/
System.out.println("There are no sets of numbers that add up to " + y);
}

}
}

==Merge two sorted lists==
Given two sorted linked lists, merge them so that the resulting linked list is also sorted. Consider two sorted linked lists and the merged list below them as an example.
import java.util.Stack;
/*This code merges two ordered lists into one keeping their increasing order
* the lists used for testing are in the main function*/
public class MergeLists {
static class Node {
int data;
Node next;
Node(int z) {
this.data = z;
next = null;
}
}

/*This function reads the values of a list and loads them on a Stack, then reads from the stack*/
public static void loadInStack(Node f) {
Stack<Integer> pack = new Stack<>();
if (f == null)
return;
pack.push(f.data);
loadInStack(f.next);
System.out.println(pack);
}

/*This function duplicates the provided list into another one*/
public static void duplicateList(Node m) {
Node hold = new Node(-1);
if (m == null)
return;
hold.data = m.data;
duplicateList(m.next);
System.out.println(hold.data);
}

/*This function reads from two lists picking the lesser of*/
/*It takes in two lists as variables a and b*/
public static void pickTwo(Node a, Node b) {
/*This is a dummy list initialized with -1*/
Node dummyList = new Node(-1);
while (a != null && b != null) {
if (a.data <= b.data) {
/*populate the dummy list from a, if smaller*/
dummyList.data = a.data;
/*Increment a*/
a = a.next;
} else {
/*populate the dummy list from b, if smaller*/
dummyList.data = b.data;
/*Increment b*/
b = b.next;
}
/*Print when done*/
System.out.print(dummyList.data + " -> ");
}
}

public static void main(String args[]) {
Node f = new Node(2);
Node g = new Node(7);
Node h = new Node(8);
Node i = new Node(11);

f.next = g;
g.next = h;
h.next = i;

//printNodes(f);

Node k = new Node(4);
Node l = new Node(6);
Node m = new Node(9);
Node n = new Node(10);
Node o = new Node(12);

k.next = l;
l.next = m;
m.next = n;
n.next = o;

//loadInStack(f);
//duplicateList(k);
pickTwo(f, k);
}
}
==Reverse String==

Reverse the order of words in a given sentence (an array of characters).

import java.util.Iterator;
import java.util.LinkedList;

public class ReverseString {
public static void lizy(String[] curr) {
LinkedList<String> y = new LinkedList<>();
for (int g = 0; g <= curr.length - 1; g++) {
y.add(curr[g]);
}
Iterator i = y.descendingIterator();
while (i.hasNext()) {
System.out.print(i.next() + " ");
}
}
public static void main(String args[]) {
String given = "Hello World";
String[] given_array = given.split(" ");
String lineOfCurrencies = "USD JPY AUD SGD HKD CAD CHF GBP EURO INR";
String multispace = "Kenya Uganda Tanzania Burundi Rwanda";
String[] currencies = lineOfCurrencies.split(" ");
String[] ms = multispace.split("\\s+");
ReverseString.lizy(given_array);
}
}
==Level Order Traversal of Binary Tree==

Given the root of a binary tree, display the node values at each level. Node values for all levels should be displayed on separate lines. Let’s take a look at the below binary tree.

import java.util.LinkedList;

public class Lot {
static class Node {
int value;
Node left;
Node right;
Node(int v) {
this.value = v;
this.left = this.right = null;
}
}
Node root;
public Lot() {
root = null;
}
void lot() {
LinkedList<Node> queue = new LinkedList<>();
//Queue<Node> queue = new LinkedList<Node>();
queue.add(root);
while (!queue.isEmpty()) {
Node tempNode = queue.removeFirst();
//Node tempNode = queue.poll();
System.out.print(tempNode.value + " ");
if (tempNode.left != null)
queue.add(tempNode.left);
if (tempNode.right != null)
queue.add(tempNode.right);
}
}
public static void main(String args[]) {
Lot l = new Lot();
l.root = new Node(100);
l.root.left = new Node(50);
l.root.right = new Node(200);
l.root.left.left = new Node(25);
l.root.left.right = new Node(75);
l.root.right.right = new Node(350);
System.out.println("Level order traversal is as follows: ");
l.lot();
}
}
==String Segmentation==
You are given a dictionary of words and a large input string. You have to find out whether the input string can be completely segmented into the words of a given dictionary. The following two examples elaborate on the problem further.
import java.util.HashSet;
import java.util.Set;

public class Dictionary {
boolean pair(Set<String> dictionary, String a) {
for (int i = 0; i < a.length(); i++) {
String first_word = a.substring(0, i);
if (dictionary.contains(first_word)) {
String second_word = a.substring(i);
if (dictionary.contains(second_word) || pair(dictionary, second_word)) {
return true;
}
}
}
return false;
}

public static void main(String[] args) {
Dictionary dictionary = new Dictionary();
Set<String> dict = new HashSet<>();
dict.add("geo");
dict.add("science");
dict.add("politics");
dict.add("thermal");
dict.add("physical");
dict.add("mis");
dict.add("under");
dict.add("stand");
dict.add("understand");
String word = "misunderstand";
if (dictionary.pair(dict, word)) {
System.out.println("The test word " + word + " fits in two words in the dictionary");
} else {
System.out.println("The test word " + word + " does not make dictionary words");
}
}
}
==Computing number combinations==
Suppose we have coin denominations of [1, 2, 5] and the total amount is 7. We can make changes in the following 6 ways:

public class Combinations {
static int changeOptions(int[] denominations, int amount) {
int[] solution = new int[amount + 1];
solution[0] = 1;
for (int x : denominations) {
for (int i = x; i < (amount + 1); ++i) {
solution[i] += solution[i - x];
}
}
return solution[solution.length - 1];
}

public static void main(String[] args) {
int[] denominations = new int[]{1, 2, 5, 10};
int amount = 5;
int result = changeOptions(denominations, amount);
System.out.println("There are " + result + " combinations in forming " + amount + " given the factors below: ");
for (int denomination : denominations) {
System.out.println(denomination);
}
}
}
==Sum of two numbers==
Are there two numbers in the provided set that add up to the given number?

import java.util.HashSet;
import java.util.Set;

public class SumOfTwo {
public static void main(String args[]) {
Set<Integer> set = new HashSet<>(); /*Populate this Set with target values*/
/*Array of target values*/
int[] g = {5, 6, 8, 39, 9, 11, 20, 59, 10, 1};
/*Insert the arrays values in the set*/
for (int i = 0; i < g.length; i++) {
set.add(g[i]);
}
/*Set a target number to check for*/
int y = 20;
/*If there are a set of numbers that would add up, increment this counter*/
int counter = 0;
/*Pick up a number in the set by turns and assign it to x*/
for (int i = 0; i < g.length; i++) {
int x = g[i];
/*Check to see if the set contains target minus found number.*/
if (set.contains(y - x)) { //if this is true
/*If so, increment the counter by 1*/
counter += 1;
}
}
if (counter > 0) { /*Some numbers add up*/
System.out.println("There are sets of numbers that add up to " + y);
} else { /*No numbers add up*/
System.out.println("There are no sets of numbers that add up to " + y);
}

}
}
==Find two numbers that add up==
You have a set of numbers and another number (target) that is comprised of two numbers in the set added up. How do you find if there are two numbers in the set that add up?
import java.util.Arrays;

public class TwoThatAdd {
static int[] showAdded(int[] set, int target) {
Arrays.sort(set);
int left = 0;
int right = (set.length - 1);
while (left < right) {
if (set[left] + set[right] == target) {
return new int[]{set[left], set[right]};
} else if (set[left] + set[right] < target) {
left++;
} else {
right--;
}
}
return new int[]{};
}

public static void main(String[] args) {
int[] options = {2, 4, 6, 7, 11, 13, 16};
int target = 18;
System.out.println(Arrays.toString(TwoThatAdd.showAdded(options, target)));
}
}

Algorithms

2022-10-27T15:34:11Z

Leksy:

Below is a collection of algorithms. The title of the algorithm describes (as much as possible) what the algorithm does

==Java Graph Implementation with Search Methods==

The algorithm below implements the organization chart below:

Jimbo Jones is employee id 38 and is the President.

Mike McCobb, id 39, is a VP and reports to Jimbo Jones.

Elda Two, id 43, is a VP and reports to Jimbo Jones.

Simon Sneath, id 48, is a VP and reports to Jimbo Jones.

Tim Scott, id 56, is a Manager and reports to Mike McCobb.

Bob Tilman, id 58, is a Manager and reports to Mike McCobb.

Andrew Cole, id 78, is an Analyst and reports to Tim Scott.

Matt Lemon, id 83, is an Analyst and reports to Tim Scott.

Chris Lock, id 88, is an Analyst and reports to Tim Scott.

Agnes White, id 71, is an Accountant and reports to Bob Tilman.

George Mills, id 61, is a Manager and reports to Elda Two.

Thomas Wells, id 59, is a Manager and reports to Elda Two.

Zip Two, id 63, is Manager and also reports to Elda Two.

Rasta Him, id 73, is a Technician and reports to Thomas Wells.

Claire Collins, id 89, is a Supervisor and reports to George Mills.

Jim Four, id 95, is a Receptionist and reports to Claire Collins.

Tom Flat, id 104, is a Receptionist who reports to Claire Collins.

Grace Marks, id 64, is a Manager and reports to Simon Sneath.

Dan Four, id 68, is a Manager and reports to Simon Sneath.

Shad Fifty, id 117, is in Security and reports to Dan Four.

Tall Nephew, id 108, is in Legal and reports to Grace Marks.

Short Nephew, id 109, is in Legal and reports to Grace Marks.

import java.util.HashMap;
import java.util.LinkedList;

public class Chart {
static class Employee {
int id;
String firstName;
String lastName;
String jobTitle;
boolean mapped;

Employee(int id, String fn, String ln, String jt) {
this.id = id;
this.jobTitle = jt;
this.firstName = fn;
this.lastName = ln;
}

void map() {
mapped = true;
}

void unmap() {
mapped = false;
}
}

private final HashMap<Employee, LinkedList<Employee>> assignment;

public Chart(boolean directed) {
assignment = new HashMap<>();
}

public void addEdgeHelper(Employee a, Employee b) {
LinkedList<Employee> e = assignment.get(a);
if (e != null) {
assignment.remove(b);
} else
e = new LinkedList<>();
e.add(b);
assignment.put(a, e);
}

public void addEdge(Employee boss, Employee subordinate) {
if (!assignment.containsKey(boss))
assignment.put(boss, null);
if (!assignment.containsKey(subordinate))
assignment.put(subordinate, null);
addEdgeHelper(boss, subordinate);
}

public void depthFirstSearch(Employee employee) {
employee.map();
System.out.println(employee.firstName + " " + employee.lastName + " is a " + employee.jobTitle);
LinkedList<Employee> neighbors = assignment.get(employee);
if (neighbors == null)
return;
for (Employee e : neighbors) {
if (!e.mapped)
depthFirstSearch(e);
}
}

public void breadthFirstSearch(Employee employee) {
/*Check if target item is null - if so quit*/
if (employee == null)
return;
/*Declare a queue using LinkedList and add the target item*/
LinkedList<Employee> queue = new LinkedList<>();
queue.add(employee);
/*As long as the queue has data get the first in item .removeFirst*/
while (!queue.isEmpty()) {
Employee currentFirst = queue.removeFirst();
/*If visited move on*/
if (currentFirst.mapped) {
continue;
} else {
/*else visit it and print it*/
currentFirst.map();
System.out.println(currentFirst.id + ": " + currentFirst.firstName + " " + currentFirst.lastName + " - " + currentFirst.jobTitle);
}
/*Find neighbors of the current item*/
LinkedList<Employee> allNeighbors = assignment.get(currentFirst);
/*If there are none move on*/
if (allNeighbors == null)
continue;
/*else if there are some and not visited, add them to the queue and the process starts over*/
for (Employee e : allNeighbors) {
if (!e.mapped)
queue.add(e);
}
}
}

public void resetMapping() {
for (Employee e : assignment.keySet()) {
e.unmap();
}
}

public static void main(String args[]) {
Employee a = new Employee(38, "Jimbo", "Jones", "President");
Employee b = new Employee(39, "Mike", "McCobb", "VP");
Employee c = new Employee(43, "Elda", "Two", "VP");
Employee d = new Employee(48, "Simon", "Sneeth", "VP");
Employee e = new Employee(56, "Tim", "Scott", "Manager");
Employee f = new Employee(58, "Bob", "Tilman", "Manager");
Employee g = new Employee(78, "Andrew", "Cole", "Analyst");
Employee h = new Employee(83, "Matt", "Lemon", "Analyst");
Employee i = new Employee(88, "Chris", "Lock", "Analyst");
Employee j = new Employee(71, "Agnes", "White", "Accountant");
Employee k = new Employee(61, "George", "Mills", "Manager");
Employee l = new Employee(59, "Thomas", "Wells", "Manager");
Employee m = new Employee(63, "Zip", "Two", "Manager");
Employee n = new Employee(73, "Rasta", "Him", "Technician");
Employee o = new Employee(89, "Claire", "Collins", "Supervisor");
Employee p = new Employee(95, "Jim", "Four", "Receptionist");
Employee q = new Employee(104, "Tom", "Flat", "Receptionist");
Employee r = new Employee(64, "Grace", "Marks", "Manager");
Employee s = new Employee(68, "Dan", "Four", "Manager");
Employee t = new Employee(117, "Shad", "Fifty", "Security");
Employee u = new Employee(108, "Tall", "Nephew", "Legal");
Employee v = new Employee(109, "Short", "Nephew", "Legal");

Chart chart = new Chart(true);
chart.addEdge(a, b);
chart.addEdge(a, c);
chart.addEdge(a, d);
chart.addEdge(b, e);
chart.addEdge(b, f);
chart.addEdge(e, g);
chart.addEdge(e, h);
chart.addEdge(e, i);
chart.addEdge(f, j);
chart.addEdge(c, k);
chart.addEdge(c, l);
chart.addEdge(c, m);
chart.addEdge(l, n);
chart.addEdge(k, o);
chart.addEdge(o, p);
chart.addEdge(o, q);
chart.addEdge(d, r);
chart.addEdge(d, s);
chart.addEdge(s, t);
chart.addEdge(r, u);
chart.addEdge(r, v);
//System.out.println(a.firstName + " " + a.lastName + " " + a.jobTitle + " " + a.id);
chart.resetMapping();
//chart.depthFirstSearch(k);

chart.resetMapping();
chart.breadthFirstSearch(a);
}
}

==Find missing number==
You are given an array of positive numbers from 1 to n, such that all numbers from 1 to n are present except one number x. You have to find x. The input array is not sorted. Look at the below array and give it a try before checking the solution.

The missing number = a sum of the provided array subtracted from a sum of indices + 2
example 1, 2, 4 missing is 3 = (1 +2 +3+4) - (1 +2+4)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MissingNum {
public static int findMissing(List<Integer> l) {
int tot_prov = 0;
for (Integer integer : l) {
tot_prov += integer;
}
List<Integer> k = new ArrayList<>();
int tot_req = 0;
for (int i = 0; i < l.size() + 2; i++) {
k.add(i);
tot_req += k.get(i);
}
return tot_req - tot_prov;
}

public static void main(String[] args) {
List<Integer> g = Arrays.asList(8, 5, 3, 2, 4, 1, 7);
System.out.println("The missing number is " + findMissing(g));
}
}

==Mergesort==
public class MergeSort {

private static Comparable[] aux;

public static void sort(Comparable[] a) {
aux = new Comparable[a.length];
sort(a, 0, a.length - 1);
}

private static void merge(Comparable[] a, int lo, int mid, int hi) {
assert isSorted(a, lo, mid);
assert isSorted(a, mid + 1, hi);
//copy for [] a to [] aux
for (int k = lo; k <= hi; k++) {
aux[k] = a[k];
}
// the merging process
// i is the first index of the first half of the array
// j is the first index of the second half of the array
int i = lo, j = mid + 1;

// for every value of k - the indices of [] a
for (int k = lo; k <= hi; k++) {
/*Left half exhausted take from the right*/
if (i > mid)
a[k] = aux[j++];
/*Right half exhausted take from the left*/
else if (j > hi)
a[k] = aux[i++];
/*Current key on the right less than current key on the left take from the right*/
else if (less(aux[j], aux[i]))
a[k] = aux[j++];
/*Current key on the right greater than current key on the left take from the left */
else
a[k] = aux[i++];
}
assert isSorted(a, lo, hi);
}

private static void sort(Comparable[] a, int lo, int hi) {
if (hi <= lo)
return;
int mid = lo + (hi - lo) / 2;
sort(a, lo, mid);
sort(a, mid + 1, hi);
merge(a, lo, mid, hi);
}

private static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}

private static boolean isSorted(Comparable[] a, int lo, int hi) {
for (int i = lo + 1; i <= hi; i++)
if (less(a[i], a[i - 1])) return false;
return true;
}

public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
//System.out.print(a[i]);
System.out.println(a[i]);
}
}

public static void main(String args[]) {
// Comparable[] a = {"E", "E", "G", "M", "R", "A", "C", "E", "R", "T"};

Comparable[] aa = {"A", "X", "G", "M", "R"};
Comparable[] bb = {"H", "D", "J", "Y", "Z"};
/*Merge the two comparable arrays*/
Comparable[] a = new Comparable[aa.length + bb.length];
System.arraycopy(aa, 0, a, 0, aa.length);
System.arraycopy(bb, 0, a, aa.length, bb.length);

MergeSort.sort(a);
show(a);
}
}
==Binary Search==
public class BinarySearch {
public static int find(int[] arr, int target) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = left + (right - left);
if (arr[mid] == target)
return mid;
if (arr[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}

public static void main(String args[]) {
int[] f = {1, 10, 20, 47, 59, 63, 75, 88, 99, 107, 120, 133, 155, 162, 176, 188, 199, 200, 210, 222, 223};
int t = 162;
System.out.println(find(f, t));
}
}

==Validate Binary Search Tree==

Given a Binary Tree, figure out whether it’s a Binary Search Tree. In a binary search tree, each node’s key value is smaller than the key value of all nodes in the right subtree, and is greater than the key values of all nodes in the left subtree. Below is an example of a binary tree that is a valid BST.

public class BinarySearchTree {
static class Node {
int value;
Node left;
Node right;
Node(int value) {
this.value = value;
this.left = null;
this.right = null;
}
}
Node root;
public BinarySearchTree() {
root = null;
}
public boolean isbst(Node root, Node l, Node r) {
if (root == null)
return true;
if (l != null && l.value > root.value)
return false;
if (r != null && r.value < root.value)
return false;
return isbst(root.left, l, root) && isbst(root.right, root, r);
}

public static void main(String args[]) {
BinarySearchTree bt = new BinarySearchTree();
bt.root = new Node(10);
bt.root.left = new Node(5);
bt.root.right = new Node(15);
bt.root.left.left = new Node(4);
bt.root.left.right = new Node(7);
bt.root.right.left = new Node(13);
bt.root.right.right = new Node(26);
if (bt.isbst(bt.root, null, null))
System.out.println("Is a BST");
else
System.out.println("Is not a BST");
}
}

==Determine if two integers add up to given number==
Given an array of integers and a value, determine if there are any two integers in the array whose sum is equal to the given value. Return true if the sum exists and return false if it does not. Consider this array and the target sums:
public class SumOfTwo {
public static void main(String args[]) {
Set<Integer> set = new HashSet<>(); /*Populate this Set with target values*/
/*Array of target values*/
int[] g = {5, 6, 8, 39, 9, 11, 20, 59, 10, 1};
/*Insert the arrays values in the set*/
for (int i = 0; i < g.length; i++) {
set.add(g[i]);
}
/*Set a target number to check for*/
int y = 20;
/*If there are a set of numbers that would add up, increment this counter*/
int counter = 0;
/*Pick up a number in the set by turns and assign it to x*/
for (int i = 0; i < g.length; i++) {
int x = g[i];
/*Check to see if the set contains target minus found number.*/
if (set.contains(y - x)) { //if this is true
/*If so, increment the counter by 1*/
counter += 1;
}
}
if (counter > 0) { /*Some numbers add up*/
System.out.println("There are sets of numbers that add up to " + y);
} else { /*No numbers add up*/
System.out.println("There are no sets of numbers that add up to " + y);
}

}
}

==Merge two sorted lists==
Given two sorted linked lists, merge them so that the resulting linked list is also sorted. Consider two sorted linked lists and the merged list below them as an example.
import java.util.Stack;
/*This code merges two ordered lists into one keeping their increasing order
* the lists used for testing are in the main function*/
public class MergeLists {
static class Node {
int data;
Node next;
Node(int z) {
this.data = z;
next = null;
}
}

/*This function reads the values of a list and loads them on a Stack, then reads from the stack*/
public static void loadInStack(Node f) {
Stack<Integer> pack = new Stack<>();
if (f == null)
return;
pack.push(f.data);
loadInStack(f.next);
System.out.println(pack);
}

/*This function duplicates the provided list into another one*/
public static void duplicateList(Node m) {
Node hold = new Node(-1);
if (m == null)
return;
hold.data = m.data;
duplicateList(m.next);
System.out.println(hold.data);
}

/*This function reads from two lists picking the lesser of*/
/*It takes in two lists as variables a and b*/
public static void pickTwo(Node a, Node b) {
/*This is a dummy list initialized with -1*/
Node dummyList = new Node(-1);
while (a != null && b != null) {
if (a.data <= b.data) {
/*populate the dummy list from a, if smaller*/
dummyList.data = a.data;
/*Increment a*/
a = a.next;
} else {
/*populate the dummy list from b, if smaller*/
dummyList.data = b.data;
/*Increment b*/
b = b.next;
}
/*Print when done*/
System.out.print(dummyList.data + " -> ");
}
}

public static void main(String args[]) {
Node f = new Node(2);
Node g = new Node(7);
Node h = new Node(8);
Node i = new Node(11);

f.next = g;
g.next = h;
h.next = i;

//printNodes(f);

Node k = new Node(4);
Node l = new Node(6);
Node m = new Node(9);
Node n = new Node(10);
Node o = new Node(12);

k.next = l;
l.next = m;
m.next = n;
n.next = o;

//loadInStack(f);
//duplicateList(k);
pickTwo(f, k);
}
}
==Reverse String==

Reverse the order of words in a given sentence (an array of characters).

import java.util.Iterator;
import java.util.LinkedList;

public class ReverseString {
public static void lizy(String[] curr) {
LinkedList<String> y = new LinkedList<>();
for (int g = 0; g <= curr.length - 1; g++) {
y.add(curr[g]);
}
Iterator i = y.descendingIterator();
while (i.hasNext()) {
System.out.print(i.next() + " ");
}
}
public static void main(String args[]) {
String given = "Hello World";
String[] given_array = given.split(" ");
String lineOfCurrencies = "USD JPY AUD SGD HKD CAD CHF GBP EURO INR";
String multispace = "Kenya Uganda Tanzania Burundi Rwanda";
String[] currencies = lineOfCurrencies.split(" ");
String[] ms = multispace.split("\\s+");
ReverseString.lizy(given_array);
}
}
==Level Order Traversal of Binary Tree==

Given the root of a binary tree, display the node values at each level. Node values for all levels should be displayed on separate lines. Let’s take a look at the below binary tree.

import java.util.LinkedList;

public class Lot {
static class Node {
int value;
Node left;
Node right;
Node(int v) {
this.value = v;
this.left = this.right = null;
}
}
Node root;
public Lot() {
root = null;
}
void lot() {
LinkedList<Node> queue = new LinkedList<>();
//Queue<Node> queue = new LinkedList<Node>();
queue.add(root);
while (!queue.isEmpty()) {
Node tempNode = queue.removeFirst();
//Node tempNode = queue.poll();
System.out.print(tempNode.value + " ");
if (tempNode.left != null)
queue.add(tempNode.left);
if (tempNode.right != null)
queue.add(tempNode.right);
}
}
public static void main(String args[]) {
Lot l = new Lot();
l.root = new Node(100);
l.root.left = new Node(50);
l.root.right = new Node(200);
l.root.left.left = new Node(25);
l.root.left.right = new Node(75);
l.root.right.right = new Node(350);
System.out.println("Level order traversal is as follows: ");
l.lot();
}
}
==String Segmentation==
You are given a dictionary of words and a large input string. You have to find out whether the input string can be completely segmented into the words of a given dictionary. The following two examples elaborate on the problem further.
import java.util.HashSet;
import java.util.Set;

public class Dictionary {
boolean pair(Set<String> dictionary, String a) {
for (int i = 0; i < a.length(); i++) {
String first_word = a.substring(0, i);
if (dictionary.contains(first_word)) {
String second_word = a.substring(i);
if (dictionary.contains(second_word) || pair(dictionary, second_word)) {
return true;
}
}
}
return false;
}

public static void main(String[] args) {
Dictionary dictionary = new Dictionary();
Set<String> dict = new HashSet<>();
dict.add("geo");
dict.add("science");
dict.add("politics");
dict.add("thermal");
dict.add("physical");
dict.add("mis");
dict.add("under");
dict.add("stand");
dict.add("understand");
String word = "misunderstand";
if (dictionary.pair(dict, word)) {
System.out.println("The test word " + word + " fits in two words in the dictionary");
} else {
System.out.println("The test word " + word + " does not make dictionary words");
}
}
}
==Computing number combinations==
Suppose we have coin denominations of [1, 2, 5] and the total amount is 7. We can make changes in the following 6 ways:

public class Combinations {
static int changeOptions(int[] denominations, int amount) {
int[] solution = new int[amount + 1];
solution[0] = 1;
for (int x : denominations) {
for (int i = x; i < (amount + 1); ++i) {
solution[i] += solution[i - x];
}
}
return solution[solution.length - 1];
}

public static void main(String[] args) {
int[] denominations = new int[]{1, 2, 5, 10};
int amount = 5;
int result = changeOptions(denominations, amount);
System.out.println("There are " + result + " combinations in forming " + amount + " given the factors below: ");
for (int denomination : denominations) {
System.out.println(denomination);
}
}
}
==Sum of two numbers==
Are there two numbers in the provided set that add up to the given number?

import java.util.HashSet;
import java.util.Set;

public class SumOfTwo {
public static void main(String args[]) {
Set<Integer> set = new HashSet<>(); /*Populate this Set with target values*/
/*Array of target values*/
int[] g = {5, 6, 8, 39, 9, 11, 20, 59, 10, 1};
/*Insert the arrays values in the set*/
for (int i = 0; i < g.length; i++) {
set.add(g[i]);
}
/*Set a target number to check for*/
int y = 20;
/*If there are a set of numbers that would add up, increment this counter*/
int counter = 0;
/*Pick up a number in the set by turns and assign it to x*/
for (int i = 0; i < g.length; i++) {
int x = g[i];
/*Check to see if the set contains target minus found number.*/
if (set.contains(y - x)) { //if this is true
/*If so, increment the counter by 1*/
counter += 1;
}
}
if (counter > 0) { /*Some numbers add up*/
System.out.println("There are sets of numbers that add up to " + y);
} else { /*No numbers add up*/
System.out.println("There are no sets of numbers that add up to " + y);
}

}
}
==Find two numbers that add up==
You have a set of numbers and another number (target) that is comprised of two numbers in the set added up. How do you find if there are two numbers in the set that add up?
import java.util.Arrays;

public class TwoThatAdd {
static int[] showAdded(int[] set, int target) {
Arrays.sort(set);
int left = 0;
int right = (set.length - 1);
while (left < right) {
if (set[left] + set[right] == target) {
return new int[]{set[left], set[right]};
} else if (set[left] + set[right] < target) {
left++;
} else {
right--;
}
}
return new int[]{};
}

public static void main(String[] args) {
int[] options = {2, 4, 6, 7, 11, 13, 16};
int target = 18;
System.out.println(Arrays.toString(TwoThatAdd.showAdded(options, target)));
}
}

Algorithms

2022-10-26T05:47:42Z

Leksy:

==Java Graph Implementation with Search Methods==

The algorithm below implements the organization chart below:

Jimbo Jones is employee id 38 and is the President.

Mike McCobb, id 39, is a VP and reports to Jimbo Jones.

Elda Two, id 43, is a VP and reports to Jimbo Jones.

Simon Sneath, id 48, is a VP and reports to Jimbo Jones.

Tim Scott, id 56, is a Manager and reports to Mike McCobb.

Bob Tilman, id 58, is a Manager and reports to Mike McCobb.

Andrew Cole, id 78, is an Analyst and reports to Tim Scott.

Matt Lemon, id 83, is an Analyst and reports to Tim Scott.

Chris Lock, id 88, is an Analyst and reports to Tim Scott.

Agnes White, id 71, is an Accountant and reports to Bob Tilman.

George Mills, id 61, is a Manager and reports to Elda Two.

Thomas Wells, id 59, is a Manager and reports to Elda Two.

Zip Two, id 63, is Manager and also reports to Elda Two.

Rasta Him, id 73, is a Technician and reports to Thomas Wells.

Claire Collins, id 89, is a Supervisor and reports to George Mills.

Jim Four, id 95, is a Receptionist and reports to Claire Collins.

Tom Flat, id 104, is a Receptionist who reports to Claire Collins.

Grace Marks, id 64, is a Manager and reports to Simon Sneath.

Dan Four, id 68, is a Manager and reports to Simon Sneath.

Shad Fifty, id 117, is in Security and reports to Dan Four.

Tall Nephew, id 108, is in Legal and reports to Grace Marks.

Short Nephew, id 109, is in Legal and reports to Grace Marks.

import java.util.HashMap;
import java.util.LinkedList;

public class Chart {
static class Employee {
int id;
String firstName;
String lastName;
String jobTitle;
boolean mapped;

Employee(int id, String fn, String ln, String jt) {
this.id = id;
this.jobTitle = jt;
this.firstName = fn;
this.lastName = ln;
}

void map() {
mapped = true;
}

void unmap() {
mapped = false;
}
}

private final HashMap<Employee, LinkedList<Employee>> assignment;

public Chart(boolean directed) {
assignment = new HashMap<>();
}

public void addEdgeHelper(Employee a, Employee b) {
LinkedList<Employee> e = assignment.get(a);
if (e != null) {
assignment.remove(b);
} else
e = new LinkedList<>();
e.add(b);
assignment.put(a, e);
}

public void addEdge(Employee boss, Employee subordinate) {
if (!assignment.containsKey(boss))
assignment.put(boss, null);
if (!assignment.containsKey(subordinate))
assignment.put(subordinate, null);
addEdgeHelper(boss, subordinate);
}

public void depthFirstSearch(Employee employee) {
employee.map();
System.out.println(employee.firstName + " " + employee.lastName + " is a " + employee.jobTitle);
LinkedList<Employee> neighbors = assignment.get(employee);
if (neighbors == null)
return;
for (Employee e : neighbors) {
if (!e.mapped)
depthFirstSearch(e);
}
}

public void breadthFirstSearch(Employee employee) {
/*Check if target item is null - if so quit*/
if (employee == null)
return;
/*Declare a queue using LinkedList and add the target item*/
LinkedList<Employee> queue = new LinkedList<>();
queue.add(employee);
/*As long as the queue has data get the first in item .removeFirst*/
while (!queue.isEmpty()) {
Employee currentFirst = queue.removeFirst();
/*If visited move on*/
if (currentFirst.mapped) {
continue;
} else {
/*else visit it and print it*/
currentFirst.map();
System.out.println(currentFirst.id + ": " + currentFirst.firstName + " " + currentFirst.lastName + " - " + currentFirst.jobTitle);
}
/*Find neighbors of the current item*/
LinkedList<Employee> allNeighbors = assignment.get(currentFirst);
/*If there are none move on*/
if (allNeighbors == null)
continue;
/*else if there are some and not visited, add them to the queue and the process starts over*/
for (Employee e : allNeighbors) {
if (!e.mapped)
queue.add(e);
}
}
}

public void resetMapping() {
for (Employee e : assignment.keySet()) {
e.unmap();
}
}

public static void main(String args[]) {
Employee a = new Employee(38, "Jimbo", "Jones", "President");
Employee b = new Employee(39, "Mike", "McCobb", "VP");
Employee c = new Employee(43, "Elda", "Two", "VP");
Employee d = new Employee(48, "Simon", "Sneeth", "VP");
Employee e = new Employee(56, "Tim", "Scott", "Manager");
Employee f = new Employee(58, "Bob", "Tilman", "Manager");
Employee g = new Employee(78, "Andrew", "Cole", "Analyst");
Employee h = new Employee(83, "Matt", "Lemon", "Analyst");
Employee i = new Employee(88, "Chris", "Lock", "Analyst");
Employee j = new Employee(71, "Agnes", "White", "Accountant");
Employee k = new Employee(61, "George", "Mills", "Manager");
Employee l = new Employee(59, "Thomas", "Wells", "Manager");
Employee m = new Employee(63, "Zip", "Two", "Manager");
Employee n = new Employee(73, "Rasta", "Him", "Technician");
Employee o = new Employee(89, "Claire", "Collins", "Supervisor");
Employee p = new Employee(95, "Jim", "Four", "Receptionist");
Employee q = new Employee(104, "Tom", "Flat", "Receptionist");
Employee r = new Employee(64, "Grace", "Marks", "Manager");
Employee s = new Employee(68, "Dan", "Four", "Manager");
Employee t = new Employee(117, "Shad", "Fifty", "Security");
Employee u = new Employee(108, "Tall", "Nephew", "Legal");
Employee v = new Employee(109, "Short", "Nephew", "Legal");

Chart chart = new Chart(true);
chart.addEdge(a, b);
chart.addEdge(a, c);
chart.addEdge(a, d);
chart.addEdge(b, e);
chart.addEdge(b, f);
chart.addEdge(e, g);
chart.addEdge(e, h);
chart.addEdge(e, i);
chart.addEdge(f, j);
chart.addEdge(c, k);
chart.addEdge(c, l);
chart.addEdge(c, m);
chart.addEdge(l, n);
chart.addEdge(k, o);
chart.addEdge(o, p);
chart.addEdge(o, q);
chart.addEdge(d, r);
chart.addEdge(d, s);
chart.addEdge(s, t);
chart.addEdge(r, u);
chart.addEdge(r, v);
//System.out.println(a.firstName + " " + a.lastName + " " + a.jobTitle + " " + a.id);
chart.resetMapping();
//chart.depthFirstSearch(k);

chart.resetMapping();
chart.breadthFirstSearch(a);
}
}

==Find missing number==
You are given an array of positive numbers from 1 to n, such that all numbers from 1 to n are present except one number x. You have to find x. The input array is not sorted. Look at the below array and give it a try before checking the solution.

The missing number = a sum of the provided array subtracted from a sum of indices + 2
example 1, 2, 4 missing is 3 = (1 +2 +3+4) - (1 +2+4)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MissingNum {
public static int findMissing(List<Integer> l) {
int tot_prov = 0;
for (Integer integer : l) {
tot_prov += integer;
}
List<Integer> k = new ArrayList<>();
int tot_req = 0;
for (int i = 0; i < l.size() + 2; i++) {
k.add(i);
tot_req += k.get(i);
}
return tot_req - tot_prov;
}

public static void main(String[] args) {
List<Integer> g = Arrays.asList(8, 5, 3, 2, 4, 1, 7);
System.out.println("The missing number is " + findMissing(g));
}
}

==Mergesort==
public class MergeSort {

private static Comparable[] aux;

public static void sort(Comparable[] a) {
aux = new Comparable[a.length];
sort(a, 0, a.length - 1);
}

private static void merge(Comparable[] a, int lo, int mid, int hi) {
assert isSorted(a, lo, mid);
assert isSorted(a, mid + 1, hi);
//copy for [] a to [] aux
for (int k = lo; k <= hi; k++) {
aux[k] = a[k];
}
// the merging process
// i is the first index of the first half of the array
// j is the first index of the second half of the array
int i = lo, j = mid + 1;

// for every value of k - the indices of [] a
for (int k = lo; k <= hi; k++) {
/*Left half exhausted take from the right*/
if (i > mid)
a[k] = aux[j++];
/*Right half exhausted take from the left*/
else if (j > hi)
a[k] = aux[i++];
/*Current key on the right less than current key on the left take from the right*/
else if (less(aux[j], aux[i]))
a[k] = aux[j++];
/*Current key on the right greater than current key on the left take from the left */
else
a[k] = aux[i++];
}
assert isSorted(a, lo, hi);
}

private static void sort(Comparable[] a, int lo, int hi) {
if (hi <= lo)
return;
int mid = lo + (hi - lo) / 2;
sort(a, lo, mid);
sort(a, mid + 1, hi);
merge(a, lo, mid, hi);
}

private static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}

private static boolean isSorted(Comparable[] a, int lo, int hi) {
for (int i = lo + 1; i <= hi; i++)
if (less(a[i], a[i - 1])) return false;
return true;
}

public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
//System.out.print(a[i]);
System.out.println(a[i]);
}
}

public static void main(String args[]) {
// Comparable[] a = {"E", "E", "G", "M", "R", "A", "C", "E", "R", "T"};

Comparable[] aa = {"A", "X", "G", "M", "R"};
Comparable[] bb = {"H", "D", "J", "Y", "Z"};
/*Merge the two comparable arrays*/
Comparable[] a = new Comparable[aa.length + bb.length];
System.arraycopy(aa, 0, a, 0, aa.length);
System.arraycopy(bb, 0, a, aa.length, bb.length);

MergeSort.sort(a);
show(a);
}
}
==Binary Search==
public class BinarySearch {
public static int find(int[] arr, int target) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = left + (right - left);
if (arr[mid] == target)
return mid;
if (arr[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}

public static void main(String args[]) {
int[] f = {1, 10, 20, 47, 59, 63, 75, 88, 99, 107, 120, 133, 155, 162, 176, 188, 199, 200, 210, 222, 223};
int t = 162;
System.out.println(find(f, t));
}
}

==Validate Binary Search Tree==

Given a Binary Tree, figure out whether it’s a Binary Search Tree. In a binary search tree, each node’s key value is smaller than the key value of all nodes in the right subtree, and is greater than the key values of all nodes in the left subtree. Below is an example of a binary tree that is a valid BST.

public class BinarySearchTree {
static class Node {
int value;
Node left;
Node right;
Node(int value) {
this.value = value;
this.left = null;
this.right = null;
}
}
Node root;
public BinarySearchTree() {
root = null;
}
public boolean isbst(Node root, Node l, Node r) {
if (root == null)
return true;
if (l != null && l.value > root.value)
return false;
if (r != null && r.value < root.value)
return false;
return isbst(root.left, l, root) && isbst(root.right, root, r);
}

public static void main(String args[]) {
BinarySearchTree bt = new BinarySearchTree();
bt.root = new Node(10);
bt.root.left = new Node(5);
bt.root.right = new Node(15);
bt.root.left.left = new Node(4);
bt.root.left.right = new Node(7);
bt.root.right.left = new Node(13);
bt.root.right.right = new Node(26);
if (bt.isbst(bt.root, null, null))
System.out.println("Is a BST");
else
System.out.println("Is not a BST");
}
}

==Determine if two integers add up to given number==
Given an array of integers and a value, determine if there are any two integers in the array whose sum is equal to the given value. Return true if the sum exists and return false if it does not. Consider this array and the target sums:
public class SumOfTwo {
public static void main(String args[]) {
Set<Integer> set = new HashSet<>(); /*Populate this Set with target values*/
/*Array of target values*/
int[] g = {5, 6, 8, 39, 9, 11, 20, 59, 10, 1};
/*Insert the arrays values in the set*/
for (int i = 0; i < g.length; i++) {
set.add(g[i]);
}
/*Set a target number to check for*/
int y = 20;
/*If there are a set of numbers that would add up, increment this counter*/
int counter = 0;
/*Pick up a number in the set by turns and assign it to x*/
for (int i = 0; i < g.length; i++) {
int x = g[i];
/*Check to see if the set contains target minus found number.*/
if (set.contains(y - x)) { //if this is true
/*If so, increment the counter by 1*/
counter += 1;
}
}
if (counter > 0) { /*Some numbers add up*/
System.out.println("There are sets of numbers that add up to " + y);
} else { /*No numbers add up*/
System.out.println("There are no sets of numbers that add up to " + y);
}

}
}

==Merge two sorted lists==
Given two sorted linked lists, merge them so that the resulting linked list is also sorted. Consider two sorted linked lists and the merged list below them as an example.
import java.util.Stack;
/*This code merges two ordered lists into one keeping their increasing order
* the lists used for testing are in the main function*/
public class MergeLists {
static class Node {
int data;
Node next;
Node(int z) {
this.data = z;
next = null;
}
}

/*This function reads the values of a list and loads them on a Stack, then reads from the stack*/
public static void loadInStack(Node f) {
Stack<Integer> pack = new Stack<>();
if (f == null)
return;
pack.push(f.data);
loadInStack(f.next);
System.out.println(pack);
}

/*This function duplicates the provided list into another one*/
public static void duplicateList(Node m) {
Node hold = new Node(-1);
if (m == null)
return;
hold.data = m.data;
duplicateList(m.next);
System.out.println(hold.data);
}

/*This function reads from two lists picking the lesser of*/
/*It takes in two lists as variables a and b*/
public static void pickTwo(Node a, Node b) {
/*This is a dummy list initialized with -1*/
Node dummyList = new Node(-1);
while (a != null && b != null) {
if (a.data <= b.data) {
/*populate the dummy list from a, if smaller*/
dummyList.data = a.data;
/*Increment a*/
a = a.next;
} else {
/*populate the dummy list from b, if smaller*/
dummyList.data = b.data;
/*Increment b*/
b = b.next;
}
/*Print when done*/
System.out.print(dummyList.data + " -> ");
}
}

public static void main(String args[]) {
Node f = new Node(2);
Node g = new Node(7);
Node h = new Node(8);
Node i = new Node(11);

f.next = g;
g.next = h;
h.next = i;

//printNodes(f);

Node k = new Node(4);
Node l = new Node(6);
Node m = new Node(9);
Node n = new Node(10);
Node o = new Node(12);

k.next = l;
l.next = m;
m.next = n;
n.next = o;

//loadInStack(f);
//duplicateList(k);
pickTwo(f, k);
}
}
==Reverse String==

Reverse the order of words in a given sentence (an array of characters).

import java.util.Iterator;
import java.util.LinkedList;

public class ReverseString {
public static void lizy(String[] curr) {
LinkedList<String> y = new LinkedList<>();
for (int g = 0; g <= curr.length - 1; g++) {
y.add(curr[g]);
}
Iterator i = y.descendingIterator();
while (i.hasNext()) {
System.out.print(i.next() + " ");
}
}
public static void main(String args[]) {
String given = "Hello World";
String[] given_array = given.split(" ");
String lineOfCurrencies = "USD JPY AUD SGD HKD CAD CHF GBP EURO INR";
String multispace = "Kenya Uganda Tanzania Burundi Rwanda";
String[] currencies = lineOfCurrencies.split(" ");
String[] ms = multispace.split("\\s+");
ReverseString.lizy(given_array);
}
}
==Level Order Traversal of Binary Tree==

Given the root of a binary tree, display the node values at each level. Node values for all levels should be displayed on separate lines. Let’s take a look at the below binary tree.

import java.util.LinkedList;

public class Lot {
static class Node {
int value;
Node left;
Node right;
Node(int v) {
this.value = v;
this.left = this.right = null;
}
}
Node root;
public Lot() {
root = null;
}
void lot() {
LinkedList<Node> queue = new LinkedList<>();
//Queue<Node> queue = new LinkedList<Node>();
queue.add(root);
while (!queue.isEmpty()) {
Node tempNode = queue.removeFirst();
//Node tempNode = queue.poll();
System.out.print(tempNode.value + " ");
if (tempNode.left != null)
queue.add(tempNode.left);
if (tempNode.right != null)
queue.add(tempNode.right);
}
}
public static void main(String args[]) {
Lot l = new Lot();
l.root = new Node(100);
l.root.left = new Node(50);
l.root.right = new Node(200);
l.root.left.left = new Node(25);
l.root.left.right = new Node(75);
l.root.right.right = new Node(350);
System.out.println("Level order traversal is as follows: ");
l.lot();
}
}
==String Segmentation==
You are given a dictionary of words and a large input string. You have to find out whether the input string can be completely segmented into the words of a given dictionary. The following two examples elaborate on the problem further.
import java.util.HashSet;
import java.util.Set;

public class Dictionary {
boolean pair(Set<String> dictionary, String a) {
for (int i = 0; i < a.length(); i++) {
String first_word = a.substring(0, i);
if (dictionary.contains(first_word)) {
String second_word = a.substring(i);
if (dictionary.contains(second_word) || pair(dictionary, second_word)) {
return true;
}
}
}
return false;
}

public static void main(String[] args) {
Dictionary dictionary = new Dictionary();
Set<String> dict = new HashSet<>();
dict.add("geo");
dict.add("science");
dict.add("politics");
dict.add("thermal");
dict.add("physical");
dict.add("mis");
dict.add("under");
dict.add("stand");
dict.add("understand");
String word = "misunderstand";
if (dictionary.pair(dict, word)) {
System.out.println("The test word " + word + " fits in two words in the dictionary");
} else {
System.out.println("The test word " + word + " does not make dictionary words");
}
}
}
==Computing number combinations==
Suppose we have coin denominations of [1, 2, 5] and the total amount is 7. We can make changes in the following 6 ways:

public class Combinations {
static int changeOptions(int[] denominations, int amount) {
int[] solution = new int[amount + 1];
solution[0] = 1;
for (int x : denominations) {
for (int i = x; i < (amount + 1); ++i) {
solution[i] += solution[i - x];
}
}
return solution[solution.length - 1];
}

public static void main(String[] args) {
int[] denominations = new int[]{1, 2, 5, 10};
int amount = 5;
int result = changeOptions(denominations, amount);
System.out.println("There are " + result + " combinations in forming " + amount + " given the factors below: ");
for (int denomination : denominations) {
System.out.println(denomination);
}
}
}
==Sum of two numbers==
Are there two numbers in the provided set that add up to the given number?

import java.util.HashSet;
import java.util.Set;

public class SumOfTwo {
public static void main(String args[]) {
Set<Integer> set = new HashSet<>(); /*Populate this Set with target values*/
/*Array of target values*/
int[] g = {5, 6, 8, 39, 9, 11, 20, 59, 10, 1};
/*Insert the arrays values in the set*/
for (int i = 0; i < g.length; i++) {
set.add(g[i]);
}
/*Set a target number to check for*/
int y = 20;
/*If there are a set of numbers that would add up, increment this counter*/
int counter = 0;
/*Pick up a number in the set by turns and assign it to x*/
for (int i = 0; i < g.length; i++) {
int x = g[i];
/*Check to see if the set contains target minus found number.*/
if (set.contains(y - x)) { //if this is true
/*If so, increment the counter by 1*/
counter += 1;
}
}
if (counter > 0) { /*Some numbers add up*/
System.out.println("There are sets of numbers that add up to " + y);
} else { /*No numbers add up*/
System.out.println("There are no sets of numbers that add up to " + y);
}

}
}
==Find two numbers that add up==
You have a set of numbers and another number (target) that is comprised of two numbers in the set added up. How do you find if there are two numbers in the set that add up?
import java.util.Arrays;

public class TwoThatAdd {
static int[] showAdded(int[] set, int target) {
Arrays.sort(set);
int left = 0;
int right = (set.length - 1);
while (left < right) {
if (set[left] + set[right] == target) {
return new int[]{set[left], set[right]};
} else if (set[left] + set[right] < target) {
left++;
} else {
right--;
}
}
return new int[]{};
}

public static void main(String[] args) {
int[] options = {2, 4, 6, 7, 11, 13, 16};
int target = 18;
System.out.println(Arrays.toString(TwoThatAdd.showAdded(options, target)));
}
}

Algorithms

2022-10-26T03:29:51Z

Leksy:

Algorithms

2022-10-25T16:44:11Z

Leksy:

Algorithms

2022-10-25T16:43:42Z

Leksy: /* Java Graph Implementation with Search Methods */

Algorithms

2022-10-25T16:41:33Z

Leksy:

==Java Graph Implementation with Search Methods==

The algorithm below implements the organization chart below:

Jimbo Jones is employee id 38 and is the President.
Mike McCobb, id 39, is a VP and reports to Jimbo Jones.
Elda Two, id 43, is a VP and reports to Jimbo Jones.
Simon Sneath, id 48, is a VP and reports to Jimbo Jones.
Tim Scott, id 56, is a Manager and reports to Mike McCobb.
Bob Tilman, id 58, is a Manager and reports to Mike McCobb.
Andrew Cole, id 78, is an Analyst and reports to Tim Scott.
Matt Lemon, id 83, is an Analyst and reports to Tim Scott.
Chris Lock, id 88, is an Analyst and reports to Tim Scott.
Agnes White, id 71, is an Accountant and reports to Bob Tilman.
George Mills, id 61, is a Manager and reports to Elda Two.
Thomas Wells, id 59, is a Manager and reports to Elda Two.
Zip Two, id 63, is Manager and also reports to Elda Two.
Rasta Him, id 73, is a Technician and reports to Thomas Wells.
Claire Collins, id 89, is a Supervisor and reports to George Mills.
Jim Four, id 95, is a Receptionist and reports to Claire Collins.
Tom Flat, id 104, is a Receptionist who reports to Claire Collins.
Grace Marks, id 64, is a Manager and reports to Simon Sneath.
Dan Four, id 68, is a Manager and reports to Simon Sneath.
Shad Fifty, id 117, is in Security and reports to Dan Four.
Tall Nephew, id 108, is in Legal and reports to Grace Marks
Short Nephew, id 109, is in Legal and reports to Grace Marks

import java.util.HashMap;
import java.util.LinkedList;

public class Chart {
static class Employee {
int id;
String firstName;
String lastName;
String jobTitle;
boolean mapped;

Employee(int id, String fn, String ln, String jt) {
this.id = id;
this.jobTitle = jt;
this.firstName = fn;
this.lastName = ln;
}

void map() {
mapped = true;
}

void unmap() {
mapped = false;
}
}

private final HashMap<Employee, LinkedList<Employee>> assignment;

public Chart(boolean directed) {
assignment = new HashMap<>();
}

public void addEdgeHelper(Employee a, Employee b) {
LinkedList<Employee> e = assignment.get(a);
if (e != null) {
assignment.remove(b);
} else
e = new LinkedList<>();
e.add(b);
assignment.put(a, e);
}

public void addEdge(Employee boss, Employee subordinate) {
if (!assignment.containsKey(boss))
assignment.put(boss, null);
if (!assignment.containsKey(subordinate))
assignment.put(subordinate, null);
addEdgeHelper(boss, subordinate);
}

public void depthFirstSearch(Employee employee) {
employee.map();
System.out.println(employee.firstName + " " + employee.lastName + " is a " + employee.jobTitle);
LinkedList<Employee> neighbors = assignment.get(employee);
if (neighbors == null)
return;
for (Employee e : neighbors) {
if (!e.mapped)
depthFirstSearch(e);
}
}

public void breadthFirstSearch(Employee employee) {
/*Check if target item is null - if so quit*/
if (employee == null)
return;
/*Declare a queue using LinkedList and add the target item*/
LinkedList<Employee> queue = new LinkedList<>();
queue.add(employee);
/*As long as the queue has data get the first in item .removeFirst*/
while (!queue.isEmpty()) {
Employee currentFirst = queue.removeFirst();
/*If visited move on*/
if (currentFirst.mapped) {
continue;
} else {
/*else visit it and print it*/
currentFirst.map();
System.out.println(currentFirst.id + ": " + currentFirst.firstName + " " + currentFirst.lastName + " - " + currentFirst.jobTitle);
}
/*Find neighbors of the current item*/
LinkedList<Employee> allNeighbors = assignment.get(currentFirst);
/*If there are none move on*/
if (allNeighbors == null)
continue;
/*else if there are some and not visited, add them to the queue and the process starts over*/
for (Employee e : allNeighbors) {
if (!e.mapped)
queue.add(e);
}
}
}

public void resetMapping() {
for (Employee e : assignment.keySet()) {
e.unmap();
}
}

public static void main(String args[]) {
Employee a = new Employee(38, "Jimbo", "Jones", "President");
Employee b = new Employee(39, "Mike", "McCobb", "VP");
Employee c = new Employee(43, "Elda", "Two", "VP");
Employee d = new Employee(48, "Simon", "Sneeth", "VP");
Employee e = new Employee(56, "Tim", "Scott", "Manager");
Employee f = new Employee(58, "Bob", "Tilman", "Manager");
Employee g = new Employee(78, "Andrew", "Cole", "Analyst");
Employee h = new Employee(83, "Matt", "Lemon", "Analyst");
Employee i = new Employee(88, "Chris", "Lock", "Analyst");
Employee j = new Employee(71, "Agnes", "White", "Accountant");
Employee k = new Employee(61, "George", "Mills", "Manager");
Employee l = new Employee(59, "Thomas", "Wells", "Manager");
Employee m = new Employee(63, "Zip", "Two", "Manager");
Employee n = new Employee(73, "Rasta", "Him", "Technician");
Employee o = new Employee(89, "Claire", "Collins", "Supervisor");
Employee p = new Employee(95, "Jim", "Four", "Receptionist");
Employee q = new Employee(104, "Tom", "Flat", "Receptionist");
Employee r = new Employee(64, "Grace", "Marks", "Manager");
Employee s = new Employee(68, "Dan", "Four", "Manager");
Employee t = new Employee(117, "Shad", "Fifty", "Security");
Employee u = new Employee(108, "Tall", "Nephew", "Legal");
Employee v = new Employee(109, "Short", "Nephew", "Legal");

Chart chart = new Chart(true);
chart.addEdge(a, b);
chart.addEdge(a, c);
chart.addEdge(a, d);
chart.addEdge(b, e);
chart.addEdge(b, f);
chart.addEdge(e, g);
chart.addEdge(e, h);
chart.addEdge(e, i);
chart.addEdge(f, j);
chart.addEdge(c, k);
chart.addEdge(c, l);
chart.addEdge(c, m);
chart.addEdge(l, n);
chart.addEdge(k, o);
chart.addEdge(o, p);
chart.addEdge(o, q);
chart.addEdge(d, r);
chart.addEdge(d, s);
chart.addEdge(s, t);
chart.addEdge(r, u);
chart.addEdge(r, v);
//System.out.println(a.firstName + " " + a.lastName + " " + a.jobTitle + " " + a.id);
chart.resetMapping();
//chart.depthFirstSearch(k);

chart.resetMapping();
chart.breadthFirstSearch(a);
}
}

==Find missing number==
You are given an array of positive numbers from 1 to n, such that all numbers from 1 to n are present except one number x. You have to find x. The input array is not sorted. Look at the below array and give it a try before checking the solution.

The missing number = a sum of the provided array subtracted from a sum of indices + 2
example 1, 2, 4 missing is 3 = (1 +2 +3+4) - (1 +2+4)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MissingNum {
public static int findMissing(List<Integer> l) {
int tot_prov = 0;
for (Integer integer : l) {
tot_prov += integer;
}
List<Integer> k = new ArrayList<>();
int tot_req = 0;
for (int i = 0; i < l.size() + 2; i++) {
k.add(i);
tot_req += k.get(i);
}
return tot_req - tot_prov;
}

public static void main(String[] args) {
List<Integer> g = Arrays.asList(8, 5, 3, 2, 4, 1, 7);
System.out.println("The missing number is " + findMissing(g));
}
}

==Mergesort==
public class MergeSort {

private static Comparable[] aux;

public static void sort(Comparable[] a) {
aux = new Comparable[a.length];
sort(a, 0, a.length - 1);
}

private static void merge(Comparable[] a, int lo, int mid, int hi) {
assert isSorted(a, lo, mid);
assert isSorted(a, mid + 1, hi);
//copy for [] a to [] aux
for (int k = lo; k <= hi; k++) {
aux[k] = a[k];
}
// the merging process
// i is the first index of the first half of the array
// j is the first index of the second half of the array
int i = lo, j = mid + 1;

// for every value of k - the indices of [] a
for (int k = lo; k <= hi; k++) {
/*Left half exhausted take from the right*/
if (i > mid)
a[k] = aux[j++];
/*Right half exhausted take from the left*/
else if (j > hi)
a[k] = aux[i++];
/*Current key on the right less than current key on the left take from the right*/
else if (less(aux[j], aux[i]))
a[k] = aux[j++];
/*Current key on the right greater than current key on the left take from the left */
else
a[k] = aux[i++];
}
assert isSorted(a, lo, hi);
}

private static void sort(Comparable[] a, int lo, int hi) {
if (hi <= lo)
return;
int mid = lo + (hi - lo) / 2;
sort(a, lo, mid);
sort(a, mid + 1, hi);
merge(a, lo, mid, hi);
}

private static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}

private static boolean isSorted(Comparable[] a, int lo, int hi) {
for (int i = lo + 1; i <= hi; i++)
if (less(a[i], a[i - 1])) return false;
return true;
}

public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
//System.out.print(a[i]);
System.out.println(a[i]);
}
}

public static void main(String args[]) {
// Comparable[] a = {"E", "E", "G", "M", "R", "A", "C", "E", "R", "T"};

Comparable[] aa = {"A", "X", "G", "M", "R"};
Comparable[] bb = {"H", "D", "J", "Y", "Z"};
/*Merge the two comparable arrays*/
Comparable[] a = new Comparable[aa.length + bb.length];
System.arraycopy(aa, 0, a, 0, aa.length);
System.arraycopy(bb, 0, a, aa.length, bb.length);

MergeSort.sort(a);
show(a);
}
}
==Binary Search==
public class BinarySearch {
public static int find(int[] arr, int target) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = left + (right - left);
if (arr[mid] == target)
return mid;
if (arr[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}

public static void main(String args[]) {
int[] f = {1, 10, 20, 47, 59, 63, 75, 88, 99, 107, 120, 133, 155, 162, 176, 188, 199, 200, 210, 222, 223};
int t = 162;
System.out.println(find(f, t));
}
}

==Validate Binary Search Tree==

Given a Binary Tree, figure out whether it’s a Binary Search Tree. In a binary search tree, each node’s key value is smaller than the key value of all nodes in the right subtree, and is greater than the key values of all nodes in the left subtree. Below is an example of a binary tree that is a valid BST.

public class BinarySearchTree {
static class Node {
int value;
Node left;
Node right;
Node(int value) {
this.value = value;
this.left = null;
this.right = null;
}
}
Node root;
public BinarySearchTree() {
root = null;
}
public boolean isbst(Node root, Node l, Node r) {
if (root == null)
return true;
if (l != null && l.value > root.value)
return false;
if (r != null && r.value < root.value)
return false;
return isbst(root.left, l, root) && isbst(root.right, root, r);
}

public static void main(String args[]) {
BinarySearchTree bt = new BinarySearchTree();
bt.root = new Node(10);
bt.root.left = new Node(5);
bt.root.right = new Node(15);
bt.root.left.left = new Node(4);
bt.root.left.right = new Node(7);
bt.root.right.left = new Node(13);
bt.root.right.right = new Node(26);
if (bt.isbst(bt.root, null, null))
System.out.println("Is a BST");
else
System.out.println("Is not a BST");
}
}

==Determine if two integers add up to given number==
Given an array of integers and a value, determine if there are any two integers in the array whose sum is equal to the given value. Return true if the sum exists and return false if it does not. Consider this array and the target sums:
public class SumOfTwo {
public static void main(String args[]) {
Set<Integer> set = new HashSet<>(); /*Populate this Set with target values*/
/*Array of target values*/
int[] g = {5, 6, 8, 39, 9, 11, 20, 59, 10, 1};
/*Insert the arrays values in the set*/
for (int i = 0; i < g.length; i++) {
set.add(g[i]);
}
/*Set a target number to check for*/
int y = 20;
/*If there are a set of numbers that would add up, increment this counter*/
int counter = 0;
/*Pick up a number in the set by turns and assign it to x*/
for (int i = 0; i < g.length; i++) {
int x = g[i];
/*Check to see if the set contains target minus found number.*/
if (set.contains(y - x)) { //if this is true
/*If so, increment the counter by 1*/
counter += 1;
}
}
if (counter > 0) { /*Some numbers add up*/
System.out.println("There are sets of numbers that add up to " + y);
} else { /*No numbers add up*/
System.out.println("There are no sets of numbers that add up to " + y);
}

}
}

==Merge two sorted lists==
Given two sorted linked lists, merge them so that the resulting linked list is also sorted. Consider two sorted linked lists and the merged list below them as an example.
import java.util.Stack;
/*This code merges two ordered lists into one keeping their increasing order
* the lists used for testing are in the main function*/
public class MergeLists {
static class Node {
int data;
Node next;
Node(int z) {
this.data = z;
next = null;
}
}

/*This function reads the values of a list and loads them on a Stack, then reads from the stack*/
public static void loadInStack(Node f) {
Stack<Integer> pack = new Stack<>();
if (f == null)
return;
pack.push(f.data);
loadInStack(f.next);
System.out.println(pack);
}

/*This function duplicates the provided list into another one*/
public static void duplicateList(Node m) {
Node hold = new Node(-1);
if (m == null)
return;
hold.data = m.data;
duplicateList(m.next);
System.out.println(hold.data);
}

/*This function reads from two lists picking the lesser of*/
/*It takes in two lists as variables a and b*/
public static void pickTwo(Node a, Node b) {
/*This is a dummy list initialized with -1*/
Node dummyList = new Node(-1);
while (a != null && b != null) {
if (a.data <= b.data) {
/*populate the dummy list from a, if smaller*/
dummyList.data = a.data;
/*Increment a*/
a = a.next;
} else {
/*populate the dummy list from b, if smaller*/
dummyList.data = b.data;
/*Increment b*/
b = b.next;
}
/*Print when done*/
System.out.print(dummyList.data + " -> ");
}
}

public static void main(String args[]) {
Node f = new Node(2);
Node g = new Node(7);
Node h = new Node(8);
Node i = new Node(11);

f.next = g;
g.next = h;
h.next = i;

//printNodes(f);

Node k = new Node(4);
Node l = new Node(6);
Node m = new Node(9);
Node n = new Node(10);
Node o = new Node(12);

k.next = l;
l.next = m;
m.next = n;
n.next = o;

//loadInStack(f);
//duplicateList(k);
pickTwo(f, k);
}
}
==Reverse String==

Reverse the order of words in a given sentence (an array of characters).

import java.util.Iterator;
import java.util.LinkedList;

public class ReverseString {
public static void lizy(String[] curr) {
LinkedList<String> y = new LinkedList<>();
for (int g = 0; g <= curr.length - 1; g++) {
y.add(curr[g]);
}
Iterator i = y.descendingIterator();
while (i.hasNext()) {
System.out.print(i.next() + " ");
}
}
public static void main(String args[]) {
String given = "Hello World";
String[] given_array = given.split(" ");
String lineOfCurrencies = "USD JPY AUD SGD HKD CAD CHF GBP EURO INR";
String multispace = "Kenya Uganda Tanzania Burundi Rwanda";
String[] currencies = lineOfCurrencies.split(" ");
String[] ms = multispace.split("\\s+");
ReverseString.lizy(given_array);
}
}
==Level Order Traversal of Binary Tree==

Given the root of a binary tree, display the node values at each level. Node values for all levels should be displayed on separate lines. Let’s take a look at the below binary tree.

import java.util.LinkedList;

public class Lot {
static class Node {
int value;
Node left;
Node right;
Node(int v) {
this.value = v;
this.left = this.right = null;
}
}
Node root;
public Lot() {
root = null;
}
void lot() {
LinkedList<Node> queue = new LinkedList<>();
//Queue<Node> queue = new LinkedList<Node>();
queue.add(root);
while (!queue.isEmpty()) {
Node tempNode = queue.removeFirst();
//Node tempNode = queue.poll();
System.out.print(tempNode.value + " ");
if (tempNode.left != null)
queue.add(tempNode.left);
if (tempNode.right != null)
queue.add(tempNode.right);
}
}
public static void main(String args[]) {
Lot l = new Lot();
l.root = new Node(100);
l.root.left = new Node(50);
l.root.right = new Node(200);
l.root.left.left = new Node(25);
l.root.left.right = new Node(75);
l.root.right.right = new Node(350);
System.out.println("Level order traversal is as follows: ");
l.lot();
}
}
==String Segmentation==
You are given a dictionary of words and a large input string. You have to find out whether the input string can be completely segmented into the words of a given dictionary. The following two examples elaborate on the problem further.
import java.util.HashSet;
import java.util.Set;

public class Dictionary {
boolean pair(Set<String> dictionary, String a) {
for (int i = 0; i < a.length(); i++) {
String first_word = a.substring(0, i);
if (dictionary.contains(first_word)) {
String second_word = a.substring(i);
if (dictionary.contains(second_word) || pair(dictionary, second_word)) {
return true;
}
}
}
return false;
}

public static void main(String[] args) {
Dictionary dictionary = new Dictionary();
Set<String> dict = new HashSet<>();
dict.add("geo");
dict.add("science");
dict.add("politics");
dict.add("thermal");
dict.add("physical");
dict.add("mis");
dict.add("under");
dict.add("stand");
dict.add("understand");
String word = "misunderstand";
if (dictionary.pair(dict, word)) {
System.out.println("The test word " + word + " fits in two words in the dictionary");
} else {
System.out.println("The test word " + word + " does not make dictionary words");
}
}
}
==Computing number combinations==
Suppose we have coin denominations of [1, 2, 5] and the total amount is 7. We can make changes in the following 6 ways:

public class Combinations {
static int changeOptions(int[] denominations, int amount) {
int[] solution = new int[amount + 1];
solution[0] = 1;
for (int x : denominations) {
for (int i = x; i < (amount + 1); ++i) {
solution[i] += solution[i - x];
}
}
return solution[solution.length - 1];
}

public static void main(String[] args) {
int[] denominations = new int[]{1, 2, 5, 10};
int amount = 5;
int result = changeOptions(denominations, amount);
System.out.println("There are " + result + " combinations in forming " + amount + " given the factors below: ");
for (int denomination : denominations) {
System.out.println(denomination);
}
}
}

Algorithms

2022-10-25T16:14:10Z

Leksy: /* Computing number combinations */

==Java Graph Implementation with Search Methods==
import java.util.HashMap;
import java.util.LinkedList;

public class Chart {
static class Employee {
int id;
String firstName;
String lastName;
String jobTitle;
boolean mapped;

Employee(int id, String fn, String ln, String jt) {
this.id = id;
this.jobTitle = jt;
this.firstName = fn;
this.lastName = ln;
}

void map() {
mapped = true;
}

void unmap() {
mapped = false;
}
}

private final HashMap<Employee, LinkedList<Employee>> assignment;

public Chart(boolean directed) {
assignment = new HashMap<>();
}

public void addEdgeHelper(Employee a, Employee b) {
LinkedList<Employee> e = assignment.get(a);
if (e != null) {
assignment.remove(b);
} else
e = new LinkedList<>();
e.add(b);
assignment.put(a, e);
}

public void addEdge(Employee boss, Employee subordinate) {
if (!assignment.containsKey(boss))
assignment.put(boss, null);
if (!assignment.containsKey(subordinate))
assignment.put(subordinate, null);
addEdgeHelper(boss, subordinate);
}

public void depthFirstSearch(Employee employee) {
employee.map();
System.out.println(employee.firstName + " " + employee.lastName + " is a " + employee.jobTitle);
LinkedList<Employee> neighbors = assignment.get(employee);
if (neighbors == null)
return;
for (Employee e : neighbors) {
if (!e.mapped)
depthFirstSearch(e);
}
}

public void breadthFirstSearch(Employee employee) {
/*Check if target item is null - if so quit*/
if (employee == null)
return;
/*Declare a queue using LinkedList and add the target item*/
LinkedList<Employee> queue = new LinkedList<>();
queue.add(employee);
/*As long as the queue has data get the first in item .removeFirst*/
while (!queue.isEmpty()) {
Employee currentFirst = queue.removeFirst();
/*If visited move on*/
if (currentFirst.mapped) {
continue;
} else {
/*else visit it and print it*/
currentFirst.map();
System.out.println(currentFirst.id + ": " + currentFirst.firstName + " " + currentFirst.lastName + " - " + currentFirst.jobTitle);
}
/*Find neighbors of the current item*/
LinkedList<Employee> allNeighbors = assignment.get(currentFirst);
/*If there are none move on*/
if (allNeighbors == null)
continue;
/*else if there are some and not visited, add them to the queue and the process starts over*/
for (Employee e : allNeighbors) {
if (!e.mapped)
queue.add(e);
}
}
}

public void resetMapping() {
for (Employee e : assignment.keySet()) {
e.unmap();
}
}

public static void main(String args[]) {
Employee a = new Employee(38, "Jimbo", "Jones", "President");
Employee b = new Employee(39, "Mike", "McCobb", "VP");
Employee c = new Employee(43, "Elda", "Two", "VP");
Employee d = new Employee(48, "Simon", "Sneeth", "VP");
Employee e = new Employee(56, "Tim", "Scott", "Manager");
Employee f = new Employee(58, "Bob", "Tilman", "Manager");
Employee g = new Employee(78, "Andrew", "Cole", "Analyst");
Employee h = new Employee(83, "Matt", "Lemon", "Analyst");
Employee i = new Employee(88, "Chris", "Lock", "Analyst");
Employee j = new Employee(71, "Agnes", "White", "Accountant");
Employee k = new Employee(61, "George", "Mills", "Manager");
Employee l = new Employee(59, "Thomas", "Wells", "Manager");
Employee m = new Employee(63, "Zip", "Two", "Manager");
Employee n = new Employee(73, "Rasta", "Him", "Technician");
Employee o = new Employee(89, "Claire", "Collins", "Supervisor");
Employee p = new Employee(95, "Jim", "Four", "Receptionist");
Employee q = new Employee(104, "Tom", "Flat", "Receptionist");
Employee r = new Employee(64, "Grace", "Marks", "Manager");
Employee s = new Employee(68, "Dan", "Four", "Manager");
Employee t = new Employee(117, "Shad", "Fifty", "Security");
Employee u = new Employee(108, "Tall", "Nephew", "Legal");
Employee v = new Employee(109, "Short", "Nephew", "Legal");

Chart chart = new Chart(true);
chart.addEdge(a, b);
chart.addEdge(a, c);
chart.addEdge(a, d);
chart.addEdge(b, e);
chart.addEdge(b, f);
chart.addEdge(e, g);
chart.addEdge(e, h);
chart.addEdge(e, i);
chart.addEdge(f, j);
chart.addEdge(c, k);
chart.addEdge(c, l);
chart.addEdge(c, m);
chart.addEdge(l, n);
chart.addEdge(k, o);
chart.addEdge(o, p);
chart.addEdge(o, q);
chart.addEdge(d, r);
chart.addEdge(d, s);
chart.addEdge(s, t);
chart.addEdge(r, u);
chart.addEdge(r, v);
//System.out.println(a.firstName + " " + a.lastName + " " + a.jobTitle + " " + a.id);
chart.resetMapping();
//chart.depthFirstSearch(k);

chart.resetMapping();
chart.breadthFirstSearch(a);
}
}

==Find missing number==
You are given an array of positive numbers from 1 to n, such that all numbers from 1 to n are present except one number x. You have to find x. The input array is not sorted. Look at the below array and give it a try before checking the solution.

The missing number = a sum of the provided array subtracted from a sum of indices + 2
example 1, 2, 4 missing is 3 = (1 +2 +3+4) - (1 +2+4)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MissingNum {
public static int findMissing(List<Integer> l) {
int tot_prov = 0;
for (Integer integer : l) {
tot_prov += integer;
}
List<Integer> k = new ArrayList<>();
int tot_req = 0;
for (int i = 0; i < l.size() + 2; i++) {
k.add(i);
tot_req += k.get(i);
}
return tot_req - tot_prov;
}

public static void main(String[] args) {
List<Integer> g = Arrays.asList(8, 5, 3, 2, 4, 1, 7);
System.out.println("The missing number is " + findMissing(g));
}
}

==Mergesort==
public class MergeSort {

private static Comparable[] aux;

public static void sort(Comparable[] a) {
aux = new Comparable[a.length];
sort(a, 0, a.length - 1);
}

private static void merge(Comparable[] a, int lo, int mid, int hi) {
assert isSorted(a, lo, mid);
assert isSorted(a, mid + 1, hi);
//copy for [] a to [] aux
for (int k = lo; k <= hi; k++) {
aux[k] = a[k];
}
// the merging process
// i is the first index of the first half of the array
// j is the first index of the second half of the array
int i = lo, j = mid + 1;

// for every value of k - the indices of [] a
for (int k = lo; k <= hi; k++) {
/*Left half exhausted take from the right*/
if (i > mid)
a[k] = aux[j++];
/*Right half exhausted take from the left*/
else if (j > hi)
a[k] = aux[i++];
/*Current key on the right less than current key on the left take from the right*/
else if (less(aux[j], aux[i]))
a[k] = aux[j++];
/*Current key on the right greater than current key on the left take from the left */
else
a[k] = aux[i++];
}
assert isSorted(a, lo, hi);
}

private static void sort(Comparable[] a, int lo, int hi) {
if (hi <= lo)
return;
int mid = lo + (hi - lo) / 2;
sort(a, lo, mid);
sort(a, mid + 1, hi);
merge(a, lo, mid, hi);
}

private static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}

private static boolean isSorted(Comparable[] a, int lo, int hi) {
for (int i = lo + 1; i <= hi; i++)
if (less(a[i], a[i - 1])) return false;
return true;
}

public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
//System.out.print(a[i]);
System.out.println(a[i]);
}
}

public static void main(String args[]) {
// Comparable[] a = {"E", "E", "G", "M", "R", "A", "C", "E", "R", "T"};

Comparable[] aa = {"A", "X", "G", "M", "R"};
Comparable[] bb = {"H", "D", "J", "Y", "Z"};
/*Merge the two comparable arrays*/
Comparable[] a = new Comparable[aa.length + bb.length];
System.arraycopy(aa, 0, a, 0, aa.length);
System.arraycopy(bb, 0, a, aa.length, bb.length);

MergeSort.sort(a);
show(a);
}
}
==Binary Search==
public class BinarySearch {
public static int find(int[] arr, int target) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = left + (right - left);
if (arr[mid] == target)
return mid;
if (arr[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}

public static void main(String args[]) {
int[] f = {1, 10, 20, 47, 59, 63, 75, 88, 99, 107, 120, 133, 155, 162, 176, 188, 199, 200, 210, 222, 223};
int t = 162;
System.out.println(find(f, t));
}
}

==Validate Binary Search Tree==

Given a Binary Tree, figure out whether it’s a Binary Search Tree. In a binary search tree, each node’s key value is smaller than the key value of all nodes in the right subtree, and is greater than the key values of all nodes in the left subtree. Below is an example of a binary tree that is a valid BST.

public class BinarySearchTree {
static class Node {
int value;
Node left;
Node right;
Node(int value) {
this.value = value;
this.left = null;
this.right = null;
}
}
Node root;
public BinarySearchTree() {
root = null;
}
public boolean isbst(Node root, Node l, Node r) {
if (root == null)
return true;
if (l != null && l.value > root.value)
return false;
if (r != null && r.value < root.value)
return false;
return isbst(root.left, l, root) && isbst(root.right, root, r);
}

public static void main(String args[]) {
BinarySearchTree bt = new BinarySearchTree();
bt.root = new Node(10);
bt.root.left = new Node(5);
bt.root.right = new Node(15);
bt.root.left.left = new Node(4);
bt.root.left.right = new Node(7);
bt.root.right.left = new Node(13);
bt.root.right.right = new Node(26);
if (bt.isbst(bt.root, null, null))
System.out.println("Is a BST");
else
System.out.println("Is not a BST");
}
}

==Determine if two integers add up to given number==
Given an array of integers and a value, determine if there are any two integers in the array whose sum is equal to the given value. Return true if the sum exists and return false if it does not. Consider this array and the target sums:
public class SumOfTwo {
public static void main(String args[]) {
Set<Integer> set = new HashSet<>(); /*Populate this Set with target values*/
/*Array of target values*/
int[] g = {5, 6, 8, 39, 9, 11, 20, 59, 10, 1};
/*Insert the arrays values in the set*/
for (int i = 0; i < g.length; i++) {
set.add(g[i]);
}
/*Set a target number to check for*/
int y = 20;
/*If there are a set of numbers that would add up, increment this counter*/
int counter = 0;
/*Pick up a number in the set by turns and assign it to x*/
for (int i = 0; i < g.length; i++) {
int x = g[i];
/*Check to see if the set contains target minus found number.*/
if (set.contains(y - x)) { //if this is true
/*If so, increment the counter by 1*/
counter += 1;
}
}
if (counter > 0) { /*Some numbers add up*/
System.out.println("There are sets of numbers that add up to " + y);
} else { /*No numbers add up*/
System.out.println("There are no sets of numbers that add up to " + y);
}

}
}

==Merge two sorted lists==
Given two sorted linked lists, merge them so that the resulting linked list is also sorted. Consider two sorted linked lists and the merged list below them as an example.
import java.util.Stack;
/*This code merges two ordered lists into one keeping their increasing order
* the lists used for testing are in the main function*/
public class MergeLists {
static class Node {
int data;
Node next;
Node(int z) {
this.data = z;
next = null;
}
}

/*This function reads the values of a list and loads them on a Stack, then reads from the stack*/
public static void loadInStack(Node f) {
Stack<Integer> pack = new Stack<>();
if (f == null)
return;
pack.push(f.data);
loadInStack(f.next);
System.out.println(pack);
}

/*This function duplicates the provided list into another one*/
public static void duplicateList(Node m) {
Node hold = new Node(-1);
if (m == null)
return;
hold.data = m.data;
duplicateList(m.next);
System.out.println(hold.data);
}

/*This function reads from two lists picking the lesser of*/
/*It takes in two lists as variables a and b*/
public static void pickTwo(Node a, Node b) {
/*This is a dummy list initialized with -1*/
Node dummyList = new Node(-1);
while (a != null && b != null) {
if (a.data <= b.data) {
/*populate the dummy list from a, if smaller*/
dummyList.data = a.data;
/*Increment a*/
a = a.next;
} else {
/*populate the dummy list from b, if smaller*/
dummyList.data = b.data;
/*Increment b*/
b = b.next;
}
/*Print when done*/
System.out.print(dummyList.data + " -> ");
}
}

public static void main(String args[]) {
Node f = new Node(2);
Node g = new Node(7);
Node h = new Node(8);
Node i = new Node(11);

f.next = g;
g.next = h;
h.next = i;

//printNodes(f);

Node k = new Node(4);
Node l = new Node(6);
Node m = new Node(9);
Node n = new Node(10);
Node o = new Node(12);

k.next = l;
l.next = m;
m.next = n;
n.next = o;

//loadInStack(f);
//duplicateList(k);
pickTwo(f, k);
}
}
==Reverse String==

Reverse the order of words in a given sentence (an array of characters).

import java.util.Iterator;
import java.util.LinkedList;

public class ReverseString {
public static void lizy(String[] curr) {
LinkedList<String> y = new LinkedList<>();
for (int g = 0; g <= curr.length - 1; g++) {
y.add(curr[g]);
}
Iterator i = y.descendingIterator();
while (i.hasNext()) {
System.out.print(i.next() + " ");
}
}
public static void main(String args[]) {
String given = "Hello World";
String[] given_array = given.split(" ");
String lineOfCurrencies = "USD JPY AUD SGD HKD CAD CHF GBP EURO INR";
String multispace = "Kenya Uganda Tanzania Burundi Rwanda";
String[] currencies = lineOfCurrencies.split(" ");
String[] ms = multispace.split("\\s+");
ReverseString.lizy(given_array);
}
}
==Level Order Traversal of Binary Tree==

Given the root of a binary tree, display the node values at each level. Node values for all levels should be displayed on separate lines. Let’s take a look at the below binary tree.

import java.util.LinkedList;

public class Lot {
static class Node {
int value;
Node left;
Node right;
Node(int v) {
this.value = v;
this.left = this.right = null;
}
}
Node root;
public Lot() {
root = null;
}
void lot() {
LinkedList<Node> queue = new LinkedList<>();
//Queue<Node> queue = new LinkedList<Node>();
queue.add(root);
while (!queue.isEmpty()) {
Node tempNode = queue.removeFirst();
//Node tempNode = queue.poll();
System.out.print(tempNode.value + " ");
if (tempNode.left != null)
queue.add(tempNode.left);
if (tempNode.right != null)
queue.add(tempNode.right);
}
}
public static void main(String args[]) {
Lot l = new Lot();
l.root = new Node(100);
l.root.left = new Node(50);
l.root.right = new Node(200);
l.root.left.left = new Node(25);
l.root.left.right = new Node(75);
l.root.right.right = new Node(350);
System.out.println("Level order traversal is as follows: ");
l.lot();
}
}
==String Segmentation==
You are given a dictionary of words and a large input string. You have to find out whether the input string can be completely segmented into the words of a given dictionary. The following two examples elaborate on the problem further.
import java.util.HashSet;
import java.util.Set;

public class Dictionary {
boolean pair(Set<String> dictionary, String a) {
for (int i = 0; i < a.length(); i++) {
String first_word = a.substring(0, i);
if (dictionary.contains(first_word)) {
String second_word = a.substring(i);
if (dictionary.contains(second_word) || pair(dictionary, second_word)) {
return true;
}
}
}
return false;
}

public static void main(String[] args) {
Dictionary dictionary = new Dictionary();
Set<String> dict = new HashSet<>();
dict.add("geo");
dict.add("science");
dict.add("politics");
dict.add("thermal");
dict.add("physical");
dict.add("mis");
dict.add("under");
dict.add("stand");
dict.add("understand");
String word = "misunderstand";
if (dictionary.pair(dict, word)) {
System.out.println("The test word " + word + " fits in two words in the dictionary");
} else {
System.out.println("The test word " + word + " does not make dictionary words");
}
}
}
==Computing number combinations==
Suppose we have coin denominations of [1, 2, 5] and the total amount is 7. We can make changes in the following 6 ways:

public class Combinations {
static int changeOptions(int[] denominations, int amount) {
int[] solution = new int[amount + 1];
solution[0] = 1;
for (int x : denominations) {
for (int i = x; i < (amount + 1); ++i) {
solution[i] += solution[i - x];
}
}
return solution[solution.length - 1];
}

public static void main(String[] args) {
int[] denominations = new int[]{1, 2, 5, 10};
int amount = 5;
int result = changeOptions(denominations, amount);
System.out.println("There are " + result + " combinations in forming " + amount + " given the factors below: ");
for (int denomination : denominations) {
System.out.println(denomination);
}
}
}

Algorithms

2022-10-25T16:13:45Z

Leksy:

==Java Graph Implementation with Search Methods==
import java.util.HashMap;
import java.util.LinkedList;

public class Chart {
static class Employee {
int id;
String firstName;
String lastName;
String jobTitle;
boolean mapped;

Employee(int id, String fn, String ln, String jt) {
this.id = id;
this.jobTitle = jt;
this.firstName = fn;
this.lastName = ln;
}

void map() {
mapped = true;
}

void unmap() {
mapped = false;
}
}

private final HashMap<Employee, LinkedList<Employee>> assignment;

public Chart(boolean directed) {
assignment = new HashMap<>();
}

public void addEdgeHelper(Employee a, Employee b) {
LinkedList<Employee> e = assignment.get(a);
if (e != null) {
assignment.remove(b);
} else
e = new LinkedList<>();
e.add(b);
assignment.put(a, e);
}

public void addEdge(Employee boss, Employee subordinate) {
if (!assignment.containsKey(boss))
assignment.put(boss, null);
if (!assignment.containsKey(subordinate))
assignment.put(subordinate, null);
addEdgeHelper(boss, subordinate);
}

public void depthFirstSearch(Employee employee) {
employee.map();
System.out.println(employee.firstName + " " + employee.lastName + " is a " + employee.jobTitle);
LinkedList<Employee> neighbors = assignment.get(employee);
if (neighbors == null)
return;
for (Employee e : neighbors) {
if (!e.mapped)
depthFirstSearch(e);
}
}

public void breadthFirstSearch(Employee employee) {
/*Check if target item is null - if so quit*/
if (employee == null)
return;
/*Declare a queue using LinkedList and add the target item*/
LinkedList<Employee> queue = new LinkedList<>();
queue.add(employee);
/*As long as the queue has data get the first in item .removeFirst*/
while (!queue.isEmpty()) {
Employee currentFirst = queue.removeFirst();
/*If visited move on*/
if (currentFirst.mapped) {
continue;
} else {
/*else visit it and print it*/
currentFirst.map();
System.out.println(currentFirst.id + ": " + currentFirst.firstName + " " + currentFirst.lastName + " - " + currentFirst.jobTitle);
}
/*Find neighbors of the current item*/
LinkedList<Employee> allNeighbors = assignment.get(currentFirst);
/*If there are none move on*/
if (allNeighbors == null)
continue;
/*else if there are some and not visited, add them to the queue and the process starts over*/
for (Employee e : allNeighbors) {
if (!e.mapped)
queue.add(e);
}
}
}

public void resetMapping() {
for (Employee e : assignment.keySet()) {
e.unmap();
}
}

public static void main(String args[]) {
Employee a = new Employee(38, "Jimbo", "Jones", "President");
Employee b = new Employee(39, "Mike", "McCobb", "VP");
Employee c = new Employee(43, "Elda", "Two", "VP");
Employee d = new Employee(48, "Simon", "Sneeth", "VP");
Employee e = new Employee(56, "Tim", "Scott", "Manager");
Employee f = new Employee(58, "Bob", "Tilman", "Manager");
Employee g = new Employee(78, "Andrew", "Cole", "Analyst");
Employee h = new Employee(83, "Matt", "Lemon", "Analyst");
Employee i = new Employee(88, "Chris", "Lock", "Analyst");
Employee j = new Employee(71, "Agnes", "White", "Accountant");
Employee k = new Employee(61, "George", "Mills", "Manager");
Employee l = new Employee(59, "Thomas", "Wells", "Manager");
Employee m = new Employee(63, "Zip", "Two", "Manager");
Employee n = new Employee(73, "Rasta", "Him", "Technician");
Employee o = new Employee(89, "Claire", "Collins", "Supervisor");
Employee p = new Employee(95, "Jim", "Four", "Receptionist");
Employee q = new Employee(104, "Tom", "Flat", "Receptionist");
Employee r = new Employee(64, "Grace", "Marks", "Manager");
Employee s = new Employee(68, "Dan", "Four", "Manager");
Employee t = new Employee(117, "Shad", "Fifty", "Security");
Employee u = new Employee(108, "Tall", "Nephew", "Legal");
Employee v = new Employee(109, "Short", "Nephew", "Legal");

Chart chart = new Chart(true);
chart.addEdge(a, b);
chart.addEdge(a, c);
chart.addEdge(a, d);
chart.addEdge(b, e);
chart.addEdge(b, f);
chart.addEdge(e, g);
chart.addEdge(e, h);
chart.addEdge(e, i);
chart.addEdge(f, j);
chart.addEdge(c, k);
chart.addEdge(c, l);
chart.addEdge(c, m);
chart.addEdge(l, n);
chart.addEdge(k, o);
chart.addEdge(o, p);
chart.addEdge(o, q);
chart.addEdge(d, r);
chart.addEdge(d, s);
chart.addEdge(s, t);
chart.addEdge(r, u);
chart.addEdge(r, v);
//System.out.println(a.firstName + " " + a.lastName + " " + a.jobTitle + " " + a.id);
chart.resetMapping();
//chart.depthFirstSearch(k);

chart.resetMapping();
chart.breadthFirstSearch(a);
}
}

==Find missing number==
You are given an array of positive numbers from 1 to n, such that all numbers from 1 to n are present except one number x. You have to find x. The input array is not sorted. Look at the below array and give it a try before checking the solution.

The missing number = a sum of the provided array subtracted from a sum of indices + 2
example 1, 2, 4 missing is 3 = (1 +2 +3+4) - (1 +2+4)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MissingNum {
public static int findMissing(List<Integer> l) {
int tot_prov = 0;
for (Integer integer : l) {
tot_prov += integer;
}
List<Integer> k = new ArrayList<>();
int tot_req = 0;
for (int i = 0; i < l.size() + 2; i++) {
k.add(i);
tot_req += k.get(i);
}
return tot_req - tot_prov;
}

public static void main(String[] args) {
List<Integer> g = Arrays.asList(8, 5, 3, 2, 4, 1, 7);
System.out.println("The missing number is " + findMissing(g));
}
}

==Mergesort==
public class MergeSort {

private static Comparable[] aux;

public static void sort(Comparable[] a) {
aux = new Comparable[a.length];
sort(a, 0, a.length - 1);
}

private static void merge(Comparable[] a, int lo, int mid, int hi) {
assert isSorted(a, lo, mid);
assert isSorted(a, mid + 1, hi);
//copy for [] a to [] aux
for (int k = lo; k <= hi; k++) {
aux[k] = a[k];
}
// the merging process
// i is the first index of the first half of the array
// j is the first index of the second half of the array
int i = lo, j = mid + 1;

// for every value of k - the indices of [] a
for (int k = lo; k <= hi; k++) {
/*Left half exhausted take from the right*/
if (i > mid)
a[k] = aux[j++];
/*Right half exhausted take from the left*/
else if (j > hi)
a[k] = aux[i++];
/*Current key on the right less than current key on the left take from the right*/
else if (less(aux[j], aux[i]))
a[k] = aux[j++];
/*Current key on the right greater than current key on the left take from the left */
else
a[k] = aux[i++];
}
assert isSorted(a, lo, hi);
}

private static void sort(Comparable[] a, int lo, int hi) {
if (hi <= lo)
return;
int mid = lo + (hi - lo) / 2;
sort(a, lo, mid);
sort(a, mid + 1, hi);
merge(a, lo, mid, hi);
}

private static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}

private static boolean isSorted(Comparable[] a, int lo, int hi) {
for (int i = lo + 1; i <= hi; i++)
if (less(a[i], a[i - 1])) return false;
return true;
}

public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
//System.out.print(a[i]);
System.out.println(a[i]);
}
}

public static void main(String args[]) {
// Comparable[] a = {"E", "E", "G", "M", "R", "A", "C", "E", "R", "T"};

Comparable[] aa = {"A", "X", "G", "M", "R"};
Comparable[] bb = {"H", "D", "J", "Y", "Z"};
/*Merge the two comparable arrays*/
Comparable[] a = new Comparable[aa.length + bb.length];
System.arraycopy(aa, 0, a, 0, aa.length);
System.arraycopy(bb, 0, a, aa.length, bb.length);

MergeSort.sort(a);
show(a);
}
}
==Binary Search==
public class BinarySearch {
public static int find(int[] arr, int target) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = left + (right - left);
if (arr[mid] == target)
return mid;
if (arr[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}

public static void main(String args[]) {
int[] f = {1, 10, 20, 47, 59, 63, 75, 88, 99, 107, 120, 133, 155, 162, 176, 188, 199, 200, 210, 222, 223};
int t = 162;
System.out.println(find(f, t));
}
}

==Validate Binary Search Tree==

Given a Binary Tree, figure out whether it’s a Binary Search Tree. In a binary search tree, each node’s key value is smaller than the key value of all nodes in the right subtree, and is greater than the key values of all nodes in the left subtree. Below is an example of a binary tree that is a valid BST.

public class BinarySearchTree {
static class Node {
int value;
Node left;
Node right;
Node(int value) {
this.value = value;
this.left = null;
this.right = null;
}
}
Node root;
public BinarySearchTree() {
root = null;
}
public boolean isbst(Node root, Node l, Node r) {
if (root == null)
return true;
if (l != null && l.value > root.value)
return false;
if (r != null && r.value < root.value)
return false;
return isbst(root.left, l, root) && isbst(root.right, root, r);
}

public static void main(String args[]) {
BinarySearchTree bt = new BinarySearchTree();
bt.root = new Node(10);
bt.root.left = new Node(5);
bt.root.right = new Node(15);
bt.root.left.left = new Node(4);
bt.root.left.right = new Node(7);
bt.root.right.left = new Node(13);
bt.root.right.right = new Node(26);
if (bt.isbst(bt.root, null, null))
System.out.println("Is a BST");
else
System.out.println("Is not a BST");
}
}

==Determine if two integers add up to given number==
Given an array of integers and a value, determine if there are any two integers in the array whose sum is equal to the given value. Return true if the sum exists and return false if it does not. Consider this array and the target sums:
public class SumOfTwo {
public static void main(String args[]) {
Set<Integer> set = new HashSet<>(); /*Populate this Set with target values*/
/*Array of target values*/
int[] g = {5, 6, 8, 39, 9, 11, 20, 59, 10, 1};
/*Insert the arrays values in the set*/
for (int i = 0; i < g.length; i++) {
set.add(g[i]);
}
/*Set a target number to check for*/
int y = 20;
/*If there are a set of numbers that would add up, increment this counter*/
int counter = 0;
/*Pick up a number in the set by turns and assign it to x*/
for (int i = 0; i < g.length; i++) {
int x = g[i];
/*Check to see if the set contains target minus found number.*/
if (set.contains(y - x)) { //if this is true
/*If so, increment the counter by 1*/
counter += 1;
}
}
if (counter > 0) { /*Some numbers add up*/
System.out.println("There are sets of numbers that add up to " + y);
} else { /*No numbers add up*/
System.out.println("There are no sets of numbers that add up to " + y);
}

}
}

==Merge two sorted lists==
Given two sorted linked lists, merge them so that the resulting linked list is also sorted. Consider two sorted linked lists and the merged list below them as an example.
import java.util.Stack;
/*This code merges two ordered lists into one keeping their increasing order
* the lists used for testing are in the main function*/
public class MergeLists {
static class Node {
int data;
Node next;
Node(int z) {
this.data = z;
next = null;
}
}

/*This function reads the values of a list and loads them on a Stack, then reads from the stack*/
public static void loadInStack(Node f) {
Stack<Integer> pack = new Stack<>();
if (f == null)
return;
pack.push(f.data);
loadInStack(f.next);
System.out.println(pack);
}

/*This function duplicates the provided list into another one*/
public static void duplicateList(Node m) {
Node hold = new Node(-1);
if (m == null)
return;
hold.data = m.data;
duplicateList(m.next);
System.out.println(hold.data);
}

/*This function reads from two lists picking the lesser of*/
/*It takes in two lists as variables a and b*/
public static void pickTwo(Node a, Node b) {
/*This is a dummy list initialized with -1*/
Node dummyList = new Node(-1);
while (a != null && b != null) {
if (a.data <= b.data) {
/*populate the dummy list from a, if smaller*/
dummyList.data = a.data;
/*Increment a*/
a = a.next;
} else {
/*populate the dummy list from b, if smaller*/
dummyList.data = b.data;
/*Increment b*/
b = b.next;
}
/*Print when done*/
System.out.print(dummyList.data + " -> ");
}
}

public static void main(String args[]) {
Node f = new Node(2);
Node g = new Node(7);
Node h = new Node(8);
Node i = new Node(11);

f.next = g;
g.next = h;
h.next = i;

//printNodes(f);

Node k = new Node(4);
Node l = new Node(6);
Node m = new Node(9);
Node n = new Node(10);
Node o = new Node(12);

k.next = l;
l.next = m;
m.next = n;
n.next = o;

//loadInStack(f);
//duplicateList(k);
pickTwo(f, k);
}
}
==Reverse String==

Reverse the order of words in a given sentence (an array of characters).

import java.util.Iterator;
import java.util.LinkedList;

public class ReverseString {
public static void lizy(String[] curr) {
LinkedList<String> y = new LinkedList<>();
for (int g = 0; g <= curr.length - 1; g++) {
y.add(curr[g]);
}
Iterator i = y.descendingIterator();
while (i.hasNext()) {
System.out.print(i.next() + " ");
}
}
public static void main(String args[]) {
String given = "Hello World";
String[] given_array = given.split(" ");
String lineOfCurrencies = "USD JPY AUD SGD HKD CAD CHF GBP EURO INR";
String multispace = "Kenya Uganda Tanzania Burundi Rwanda";
String[] currencies = lineOfCurrencies.split(" ");
String[] ms = multispace.split("\\s+");
ReverseString.lizy(given_array);
}
}
==Level Order Traversal of Binary Tree==

Given the root of a binary tree, display the node values at each level. Node values for all levels should be displayed on separate lines. Let’s take a look at the below binary tree.

import java.util.LinkedList;

public class Lot {
static class Node {
int value;
Node left;
Node right;
Node(int v) {
this.value = v;
this.left = this.right = null;
}
}
Node root;
public Lot() {
root = null;
}
void lot() {
LinkedList<Node> queue = new LinkedList<>();
//Queue<Node> queue = new LinkedList<Node>();
queue.add(root);
while (!queue.isEmpty()) {
Node tempNode = queue.removeFirst();
//Node tempNode = queue.poll();
System.out.print(tempNode.value + " ");
if (tempNode.left != null)
queue.add(tempNode.left);
if (tempNode.right != null)
queue.add(tempNode.right);
}
}
public static void main(String args[]) {
Lot l = new Lot();
l.root = new Node(100);
l.root.left = new Node(50);
l.root.right = new Node(200);
l.root.left.left = new Node(25);
l.root.left.right = new Node(75);
l.root.right.right = new Node(350);
System.out.println("Level order traversal is as follows: ");
l.lot();
}
}
==String Segmentation==
You are given a dictionary of words and a large input string. You have to find out whether the input string can be completely segmented into the words of a given dictionary. The following two examples elaborate on the problem further.
import java.util.HashSet;
import java.util.Set;

public class Dictionary {
boolean pair(Set<String> dictionary, String a) {
for (int i = 0; i < a.length(); i++) {
String first_word = a.substring(0, i);
if (dictionary.contains(first_word)) {
String second_word = a.substring(i);
if (dictionary.contains(second_word) || pair(dictionary, second_word)) {
return true;
}
}
}
return false;
}

public static void main(String[] args) {
Dictionary dictionary = new Dictionary();
Set<String> dict = new HashSet<>();
dict.add("geo");
dict.add("science");
dict.add("politics");
dict.add("thermal");
dict.add("physical");
dict.add("mis");
dict.add("under");
dict.add("stand");
dict.add("understand");
String word = "misunderstand";
if (dictionary.pair(dict, word)) {
System.out.println("The test word " + word + " fits in two words in the dictionary");
} else {
System.out.println("The test word " + word + " does not make dictionary words");
}
}
}
==Computing number combinations==
Suppose we have coin denominations of [1, 2, 5] and the total amount is 7. We can make changes in the following 6 ways:

public class Arrays {
static int changeOptions(int[] denominations, int amount) {
int[] solution = new int[amount + 1];
solution[0] = 1;
for (int x : denominations) {
for (int i = x; i < (amount + 1); ++i) {
solution[i] += solution[i - x];
}
}
return solution[solution.length - 1];
}

public static void main(String[] args) {
int[] denominations = new int[]{1, 2, 5, 10};
int amount = 5;
int result = changeOptions(denominations, amount);
System.out.println("There are " + result + " combinations in forming " + amount + " given the factors below: ");
for (int denomination : denominations) {
System.out.println(denomination);
}
}
}

Algorithms

2022-10-25T00:02:56Z

Leksy:

Algorithms

2022-10-24T19:55:19Z

Leksy: /* Level Order Traversal of Binary Tree */

Algorithms

2022-10-24T19:55:00Z

Leksy: /* Level Order Traversal of Binary Tree */

Algorithms

2022-10-24T19:54:40Z

Leksy: /* Level Order Traversal of Binary Tree */

==Java Graph Implementation with Search Methods==
import java.util.HashMap;
import java.util.LinkedList;

public class Chart {
static class Employee {
int id;
String firstName;
String lastName;
String jobTitle;
boolean mapped;

Employee(int id, String fn, String ln, String jt) {
this.id = id;
this.jobTitle = jt;
this.firstName = fn;
this.lastName = ln;
}

void map() {
mapped = true;
}

void unmap() {
mapped = false;
}
}

private final HashMap<Employee, LinkedList<Employee>> assignment;

public Chart(boolean directed) {
assignment = new HashMap<>();
}

public void addEdgeHelper(Employee a, Employee b) {
LinkedList<Employee> e = assignment.get(a);
if (e != null) {
assignment.remove(b);
} else
e = new LinkedList<>();
e.add(b);
assignment.put(a, e);
}

public void addEdge(Employee boss, Employee subordinate) {
if (!assignment.containsKey(boss))
assignment.put(boss, null);
if (!assignment.containsKey(subordinate))
assignment.put(subordinate, null);
addEdgeHelper(boss, subordinate);
}

public void depthFirstSearch(Employee employee) {
employee.map();
System.out.println(employee.firstName + " " + employee.lastName + " is a " + employee.jobTitle);
LinkedList<Employee> neighbors = assignment.get(employee);
if (neighbors == null)
return;
for (Employee e : neighbors) {
if (!e.mapped)
depthFirstSearch(e);
}
}

public void breadthFirstSearch(Employee employee) {
/*Check if target item is null - if so quit*/
if (employee == null)
return;
/*Declare a queue using LinkedList and add the target item*/
LinkedList<Employee> queue = new LinkedList<>();
queue.add(employee);
/*As long as the queue has data get the first in item .removeFirst*/
while (!queue.isEmpty()) {
Employee currentFirst = queue.removeFirst();
/*If visited move on*/
if (currentFirst.mapped) {
continue;
} else {
/*else visit it and print it*/
currentFirst.map();
System.out.println(currentFirst.id + ": " + currentFirst.firstName + " " + currentFirst.lastName + " - " + currentFirst.jobTitle);
}
/*Find neighbors of the current item*/
LinkedList<Employee> allNeighbors = assignment.get(currentFirst);
/*If there are none move on*/
if (allNeighbors == null)
continue;
/*else if there are some and not visited, add them to the queue and the process starts over*/
for (Employee e : allNeighbors) {
if (!e.mapped)
queue.add(e);
}
}
}

public void resetMapping() {
for (Employee e : assignment.keySet()) {
e.unmap();
}
}

public static void main(String args[]) {
Employee a = new Employee(38, "Jimbo", "Jones", "President");
Employee b = new Employee(39, "Mike", "McCobb", "VP");
Employee c = new Employee(43, "Elda", "Two", "VP");
Employee d = new Employee(48, "Simon", "Sneeth", "VP");
Employee e = new Employee(56, "Tim", "Scott", "Manager");
Employee f = new Employee(58, "Bob", "Tilman", "Manager");
Employee g = new Employee(78, "Andrew", "Cole", "Analyst");
Employee h = new Employee(83, "Matt", "Lemon", "Analyst");
Employee i = new Employee(88, "Chris", "Lock", "Analyst");
Employee j = new Employee(71, "Agnes", "White", "Accountant");
Employee k = new Employee(61, "George", "Mills", "Manager");
Employee l = new Employee(59, "Thomas", "Wells", "Manager");
Employee m = new Employee(63, "Zip", "Two", "Manager");
Employee n = new Employee(73, "Rasta", "Him", "Technician");
Employee o = new Employee(89, "Claire", "Collins", "Supervisor");
Employee p = new Employee(95, "Jim", "Four", "Receptionist");
Employee q = new Employee(104, "Tom", "Flat", "Receptionist");
Employee r = new Employee(64, "Grace", "Marks", "Manager");
Employee s = new Employee(68, "Dan", "Four", "Manager");
Employee t = new Employee(117, "Shad", "Fifty", "Security");
Employee u = new Employee(108, "Tall", "Nephew", "Legal");
Employee v = new Employee(109, "Short", "Nephew", "Legal");

Chart chart = new Chart(true);
chart.addEdge(a, b);
chart.addEdge(a, c);
chart.addEdge(a, d);
chart.addEdge(b, e);
chart.addEdge(b, f);
chart.addEdge(e, g);
chart.addEdge(e, h);
chart.addEdge(e, i);
chart.addEdge(f, j);
chart.addEdge(c, k);
chart.addEdge(c, l);
chart.addEdge(c, m);
chart.addEdge(l, n);
chart.addEdge(k, o);
chart.addEdge(o, p);
chart.addEdge(o, q);
chart.addEdge(d, r);
chart.addEdge(d, s);
chart.addEdge(s, t);
chart.addEdge(r, u);
chart.addEdge(r, v);
//System.out.println(a.firstName + " " + a.lastName + " " + a.jobTitle + " " + a.id);
chart.resetMapping();
//chart.depthFirstSearch(k);

chart.resetMapping();
chart.breadthFirstSearch(a);
}
}

==Find missing number==
You are given an array of positive numbers from 1 to n, such that all numbers from 1 to n are present except one number x. You have to find x. The input array is not sorted. Look at the below array and give it a try before checking the solution.

The missing number = a sum of the provided array subtracted from a sum of indices + 2
example 1, 2, 4 missing is 3 = (1 +2 +3+4) - (1 +2+4)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MissingNum {
public static int findMissing(List<Integer> l) {
int tot_prov = 0;
for (Integer integer : l) {
tot_prov += integer;
}
List<Integer> k = new ArrayList<>();
int tot_req = 0;
for (int i = 0; i < l.size() + 2; i++) {
k.add(i);
tot_req += k.get(i);
}
return tot_req - tot_prov;
}

public static void main(String[] args) {
List<Integer> g = Arrays.asList(8, 5, 3, 2, 4, 1, 7);
System.out.println("The missing number is " + findMissing(g));
}
}

==Mergesort==
public class MergeSort {

private static Comparable[] aux;

public static void sort(Comparable[] a) {
aux = new Comparable[a.length];
sort(a, 0, a.length - 1);
}

private static void merge(Comparable[] a, int lo, int mid, int hi) {
assert isSorted(a, lo, mid);
assert isSorted(a, mid + 1, hi);
//copy for [] a to [] aux
for (int k = lo; k <= hi; k++) {
aux[k] = a[k];
}
// the merging process
// i is the first index of the first half of the array
// j is the first index of the second half of the array
int i = lo, j = mid + 1;

// for every value of k - the indices of [] a
for (int k = lo; k <= hi; k++) {
/*Left half exhausted take from the right*/
if (i > mid)
a[k] = aux[j++];
/*Right half exhausted take from the left*/
else if (j > hi)
a[k] = aux[i++];
/*Current key on the right less than current key on the left take from the right*/
else if (less(aux[j], aux[i]))
a[k] = aux[j++];
/*Current key on the right greater than current key on the left take from the left */
else
a[k] = aux[i++];
}
assert isSorted(a, lo, hi);
}

private static void sort(Comparable[] a, int lo, int hi) {
if (hi <= lo)
return;
int mid = lo + (hi - lo) / 2;
sort(a, lo, mid);
sort(a, mid + 1, hi);
merge(a, lo, mid, hi);
}

private static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}

private static boolean isSorted(Comparable[] a, int lo, int hi) {
for (int i = lo + 1; i <= hi; i++)
if (less(a[i], a[i - 1])) return false;
return true;
}

public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
//System.out.print(a[i]);
System.out.println(a[i]);
}
}

public static void main(String args[]) {
// Comparable[] a = {"E", "E", "G", "M", "R", "A", "C", "E", "R", "T"};

Comparable[] aa = {"A", "X", "G", "M", "R"};
Comparable[] bb = {"H", "D", "J", "Y", "Z"};
/*Merge the two comparable arrays*/
Comparable[] a = new Comparable[aa.length + bb.length];
System.arraycopy(aa, 0, a, 0, aa.length);
System.arraycopy(bb, 0, a, aa.length, bb.length);

MergeSort.sort(a);
show(a);
}
}
==Binary Search==
public class BinarySearch {
public static int find(int[] arr, int target) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = left + (right - left);
if (arr[mid] == target)
return mid;
if (arr[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}

public static void main(String args[]) {
int[] f = {1, 10, 20, 47, 59, 63, 75, 88, 99, 107, 120, 133, 155, 162, 176, 188, 199, 200, 210, 222, 223};
int t = 162;
System.out.println(find(f, t));
}
}

==Validate Binary Search Tree==

Given a Binary Tree, figure out whether it’s a Binary Search Tree. In a binary search tree, each node’s key value is smaller than the key value of all nodes in the right subtree, and is greater than the key values of all nodes in the left subtree. Below is an example of a binary tree that is a valid BST.

public class BinarySearchTree {
static class Node {
int value;
Node left;
Node right;
Node(int value) {
this.value = value;
this.left = null;
this.right = null;
}
}
Node root;
public BinarySearchTree() {
root = null;
}
public boolean isbst(Node root, Node l, Node r) {
if (root == null)
return true;
if (l != null && l.value > root.value)
return false;
if (r != null && r.value < root.value)
return false;
return isbst(root.left, l, root) && isbst(root.right, root, r);
}

public static void main(String args[]) {
BinarySearchTree bt = new BinarySearchTree();
bt.root = new Node(10);
bt.root.left = new Node(5);
bt.root.right = new Node(15);
bt.root.left.left = new Node(4);
bt.root.left.right = new Node(7);
bt.root.right.left = new Node(13);
bt.root.right.right = new Node(26);
if (bt.isbst(bt.root, null, null))
System.out.println("Is a BST");
else
System.out.println("Is not a BST");
}
}

==Determine if two integers add up to given number==
Given an array of integers and a value, determine if there are any two integers in the array whose sum is equal to the given value. Return true if the sum exists and return false if it does not. Consider this array and the target sums:
public class SumOfTwo {
public static void main(String args[]) {
Set<Integer> set = new HashSet<>(); /*Populate this Set with target values*/
/*Array of target values*/
int[] g = {5, 6, 8, 39, 9, 11, 20, 59, 10, 1};
/*Insert the arrays values in the set*/
for (int i = 0; i < g.length; i++) {
set.add(g[i]);
}
/*Set a target number to check for*/
int y = 20;
/*If there are a set of numbers that would add up, increment this counter*/
int counter = 0;
/*Pick up a number in the set by turns and assign it to x*/
for (int i = 0; i < g.length; i++) {
int x = g[i];
/*Check to see if the set contains target minus found number.*/
if (set.contains(y - x)) { //if this is true
/*If so, increment the counter by 1*/
counter += 1;
}
}
if (counter > 0) { /*Some numbers add up*/
System.out.println("There are sets of numbers that add up to " + y);
} else { /*No numbers add up*/
System.out.println("There are no sets of numbers that add up to " + y);
}

}
}

==Merge two sorted lists==
Given two sorted linked lists, merge them so that the resulting linked list is also sorted. Consider two sorted linked lists and the merged list below them as an example.
import java.util.Stack;
/*This code merges two ordered lists into one keeping their increasing order
* the lists used for testing are in the main function*/
public class MergeLists {
static class Node {
int data;
Node next;
Node(int z) {
this.data = z;
next = null;
}
}

/*This function reads the values of a list and loads them on a Stack, then reads from the stack*/
public static void loadInStack(Node f) {
Stack<Integer> pack = new Stack<>();
if (f == null)
return;
pack.push(f.data);
loadInStack(f.next);
System.out.println(pack);
}

/*This function duplicates the provided list into another one*/
public static void duplicateList(Node m) {
Node hold = new Node(-1);
if (m == null)
return;
hold.data = m.data;
duplicateList(m.next);
System.out.println(hold.data);
}

/*This function reads from two lists picking the lesser of*/
/*It takes in two lists as variables a and b*/
public static void pickTwo(Node a, Node b) {
/*This is a dummy list initialized with -1*/
Node dummyList = new Node(-1);
while (a != null && b != null) {
if (a.data <= b.data) {
/*populate the dummy list from a, if smaller*/
dummyList.data = a.data;
/*Increment a*/
a = a.next;
} else {
/*populate the dummy list from b, if smaller*/
dummyList.data = b.data;
/*Increment b*/
b = b.next;
}
/*Print when done*/
System.out.print(dummyList.data + " -> ");
}
}

public static void main(String args[]) {
Node f = new Node(2);
Node g = new Node(7);
Node h = new Node(8);
Node i = new Node(11);

f.next = g;
g.next = h;
h.next = i;

//printNodes(f);

Node k = new Node(4);
Node l = new Node(6);
Node m = new Node(9);
Node n = new Node(10);
Node o = new Node(12);

k.next = l;
l.next = m;
m.next = n;
n.next = o;

//loadInStack(f);
//duplicateList(k);
pickTwo(f, k);
}
}
==Reverse String==

Reverse the order of words in a given sentence (an array of characters).

import java.util.Iterator;
import java.util.LinkedList;

public class ReverseString {
public static void lizy(String[] curr) {
LinkedList<String> y = new LinkedList<>();
for (int g = 0; g <= curr.length - 1; g++) {
y.add(curr[g]);
}
Iterator i = y.descendingIterator();
while (i.hasNext()) {
System.out.print(i.next() + " ");
}
}
public static void main(String args[]) {
String given = "Hello World";
String[] given_array = given.split(" ");
String lineOfCurrencies = "USD JPY AUD SGD HKD CAD CHF GBP EURO INR";
String multispace = "Kenya Uganda Tanzania Burundi Rwanda";
String[] currencies = lineOfCurrencies.split(" ");
String[] ms = multispace.split("\\s+");
ReverseString.lizy(given_array);
}
}
==Level Order Traversal of Binary Tree==

Given the root of a binary tree, display the node values at each level. Node values for all levels should be displayed on separate lines. Let’s take a look at the below binary tree.

import java.util.LinkedList;

public class Lot {
static class Node {
int value;
Node left;
Node right;

Node(int v) {
this.value = v;
this.left = this.right = null;
}
}
Node root;
public Lot() {
root = null;
}
void lot() {
LinkedList<Node> queue = new LinkedList<>();
//Queue<Node> queue = new LinkedList<Node>();
queue.add(root);
while (!queue.isEmpty()) {
Node tempNode = queue.removeFirst();
//Node tempNode = queue.poll();
System.out.print(tempNode.value + " ");
if (tempNode.left != null)
queue.add(tempNode.left);
if (tempNode.right != null)
queue.add(tempNode.right);
}
}
public static void main(String args[]) {
Lot l = new Lot();
l.root = new Node(100);
l.root.left = new Node(50);
l.root.right = new Node(200);
l.root.left.left = new Node(25);
l.root.left.right = new Node(75);
l.root.right.right = new Node(350);
System.out.println("Level order traversal is as follows: ");
l.lot();

}
}