Embed Size (px)
DESCRIPTION
j2ee sql functions
Citation preview
MySQL Aggregate Function
The group (aggregate) functions that operate on set of values. Sometimes we need information that is not actually stored in the database but we can compute it by operating on some set of stored data. Aggregate functions can be used for this purpose.Aggregate functions perform a calculation on a set of records and return a single value. An aggregate function ignores NULL values when it performs the calculation except the COUNT function. The aggregate functions are often used with GROUP BY clause in the SELECT statement. In the following section, we will discuss the most common aggregate functions in MySQL.
The following are the Aggregate function:
Name Description
AVG() It Return the average value of the argument
BIT_AND() It Return bitwise and
BIT_OR() It Return bitwise or
BIT_XOR() It Return bitwise xor
COUNT(DISTINCT) It Return the count of a number of different values
COUNT() It Return a count of the number of rows returned
GROUP_CONCAT() It Return a concatenated string
MAX() It Return the maximum value
MIN() It Return the minimum value
STD() It Return the population standard deviation
STDDEV_POP() It Return the population standard deviation
STDDEV_SAMP() It Return the sample standard deviation
STDDEV() It Return the population standard deviation
SUM() It Return the sum
VAR_POP() It Return the population standard variance
VAR_SAMP() It Return the sample variance
VARIANCE() It Return the population standard variance
The 'COUNT' function is used to count the all rows of the table.
Query SELECT COUNT(*) FROM employee;
Output+----------+| COUNT(*) |+----------+| 8 |+----------+
The 'MIN' function is used to find the minimum value of the specific field and the 'MAX' function is used to find the maximum value of the field.
QuerySELECT designation, MIN(salary), MAX(salary) FROM employee GROUP BY designation;
Output
+----------------------+-------------+-------------+| designation | MIN(salary) | MAX(salary) |+----------------------+-------------+-------------+| content writer | 110 | 110 || graphic designer | 50 | 120 || programmer | 105 | 160 || sr. graphic designer | 101 | 101 |+----------------------+-------------+-------------+
The 'SUM' function is used to sum all the values of the specific column of the table.
Query select SUM(salary) FROM employee;
Output+-------------+| SUM(salary) |+-------------+| 926 |+-------------+
SUM FunctionSUM function returns the sum of all values in an expression.To get the total sales of each product, we can use the SUM function and GROUP BY clause as follows:
SELECT productCode,sum(priceEach * quantityOrdered) totalFROM orderdetails GROUP by productCode
productCode total----------- ---------S10_1678 90157.77S10_1949 190017.96S10_2016 109998.82S10_4698 170686S10_4757 127924.32S10_4962 123123.01S12_1099 161531.48
To see the result more detail, we can join the orderdetails table with the product table.
SELECT P.productCode,P.productName,SUM(priceEach * quantityOrdered) totalFROM orderdetails O INNER JOIN products P ON O.productCode=P.productCodeGROUP by productCode ORDER BY total
productCode productName total----------- ------------------------------------------- ---------S24_1937 1939 Chevrolet Deluxe Coupe 28052.94S24_3969 1936 Mercedes Benz 500k Roadster 29763.39S24_2972 1982 Lamborghini Diablo 30972.87S24_2840 1958 Chevy Corvette Limited Edition 31627.96S32_2206 1982 Ducati 996 R 33268.76S24_2022 1938 Cadillac V-16 Presidential Limousine 38449.09S50_1341 1930 Buick Marquette Phaeton 41599.24S24_1628 1966 Shelby Cobra 427 S/C 42015.54S72_1253 Boeing X-32A JSF 42692.53
AVG FunctionAVG is used to calculate average value of an expression. It ignores NULL values.
AVG(expression)AVG function is used to calculate the average price of all products by executing the following query:
SELECT AVG(buyPrice) average_buy_priceFROM Products
average_buy_price----------------- 54.395181818182
MAX and MIN FunctionMAX and MIN function returns the maximum and minimum values of a set of values in expression.
MAX(expression)For example, we can use MIN and MAX functions to retrieve the highest and lowest-price products as follows:
SELECT MAX(buyPrice) highest_price, MIN(buyPrice) lowest_priceFROM Products
highest_price lowest_price------------- ------------ 103.42 15.91
COUNT FunctionThe COUNT function returns the number of the items in expression. You can use the COUNT function to get the number of products in the products table as follows:
SELECT COUNT(*) AS TotalFROM productsTotal------ 110
Ordering: order table using JDBC application
ORDER BY Clause :There may be times when a specific order is required in a SQL query which cannot be done using either ASC or DESC or using a special sort field. MySQL has a ORDER BY FIELD function which can be used to do this.Using the FIELD( ) function in the ORDER BY clause we can achieve this. It works by specifying the column to sort by and then the values to sort in order. For example:
SELECT * FROM fruit
ORDER BY FIELD(name, 'Banana', 'Apple', 'Pear', 'Orange'), variety;
The resulting data from the example table looks like this:
+----------+--------+---------------------+| fruit_id | name | variety |+----------+--------+---------------------+| 11 | Banana | Burro || 12 | Banana | Cavendish || 10 | Banana | Plantain || 6 | Apple | Cox's Orange Pippin || 7 | Apple | Granny Smith || 1 | Apple | Red Delicious || 8 | Pear | Anjou |
Sort the table record either in ascending order or in descending order according to any field by using ORDER BY Clause. It manages your table records in sorted order of specified column. When You write only 'ORDER BY column_name' , by default it returns records sorted in ascending order. You can also use "asc" for ascending order.For descending order use 'desc' as 'ORDER BY column_name desc'
Example : In this example we are arranging student records in descending order of roll_no .
package jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
class SortingRecords{
public static void main(String[] args){
System.out.println("Sorting rocords of table in JDBC...");
Connection con = null;
Statement statement = null;
ResultSet rs = null;
String url = "jdbc:mysql://localhost:3306/";
String dbName = "students";
String driverName = "com.mysql.jdbc.Driver";
String userName = "root";
String password = "root";
try {
Class.forName(driverName);
// Connecting to the database
con = DriverManager.getConnection(url + dbName,
userName, password);
try {
statement = con.createStatement();
// Using ORDER BY Clause
String sql = "SELECT * FROM student ORDER BY
roll_no desc";
rs = statement.executeQuery(sql);
System.out.println("RollNo\tName\tCourse");
System.out.println("----------------------");
while (rs.next()) {
int roll = rs.getInt("roll_no");
String name = rs.getString("name");
String course = rs.getString("course");
System.out.println(roll + "\t" + name +
"\t" + course);
}
} catch (SQLException e) {
System.out.println(e);
}
con.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Output :
Sorting rocords of table in JDBC...
RollNo Name Course
----------------------
4 Andru MCA
3 Rose MCA
2 Mandy BCA
1 Ron MCA
Mysql Group By
Mysql Group By statement is conjecture term used with the aggregate functions to group the result-set by specified one or more columns.The MySQL GROUP BY clause is used with the SELECT statement to group rows into subgroups by the one or more values of columns or expressions.The MySQL GROUP BY clause is an optional part of the SELECT statement. It must appear after the FROM or WHERE clause. The MySQL GROUP BY clause consists of the GROUP BY keyword followed by a list of comma-separated columns or expressions.The following illustrates the MySQL GROUP BY clause syntax:
SELECT c1,c2,... cn, aggregate_function(expression)FROM tableWHERE where_conditionsGROUP BY c1, c2, ... cn
MySQL GROUP BY Examples
Let’s take a look at the orders table in the sample database. Suppose we want to group values of the order status into subgroups, we can use the following query:
SELECT statusFROM ordersGROUP BY status
We can see that the GROUP BY clause returns unique occurrences of status values. It is similar the SELECT DISTINCT query as follows:
SELECT DISTINCT statusFROM orders
MySQL GROUP BY with aggregate functions
The aggregate functions allow you to perform calculation of a set of records and return a single value. The most common aggregate functions are SUM, AVG, MAX, MIN and COUNT. The aggregate functions are used with MySQL GROUP BY clause to perform calculation on each subgroup and return a single value for each subgroup. Suppose you want to know how many orders in each status, you can use the COUNT function as follows:
SELECT status, count(*)FROM ordersGROUP BY status
MySQL GROUP BY vs. ANSI SQL GROUP BY
MySQL follows ANSI SQL. However, MySQL give you more flexibility when using GROUP BY clause: In ANSI SQL, you must list all columns that you use in the SELECT clause in the
GROUP BY clause. MySQL does not have this restriction. MySQL allows you to have additional columns in the SELECT clause that are not in the GROUP BY clause.
MySQL also allows you to sort the group order in which the results are returned. The default order is ascending.
If you want to see the status and count of orders in the example above in the descending order, you can use the following query:
SELECT status, count(*)FROM ordersGROUP BY status DESC;
DESC in the GROUP BY clause to sort the status in descending order.
MySQL Select Statement
In this lesson you will be learn how to use SELECT statement in MySQL and you can also
learn how to use SELECT statement with WHERE clause. The SELECT statement is used to
retrieve the records from the table. There are some keywords uses in SELECT statement that
are described in the following table
Keywords Description
SELECT SELECT statement is used to retrieve fields from one or more tables.
FROM Tables containing to the fields.
WHERE The WHERE clause is used to describe the criteria to restrict the records retrieved.
GROUP BY The GROUP BY clause is used to determine how the records should be grouped.
HAVING HAVING clause used with GROUP BY to define the criteria for grouped records
ORDER BY The ORDER BY clause is used to described the criteria for ordering the record.
LIMIT The LIMIT clause is used to restrict the limit of number of records retrieved.
The simple SELECT statement is used to retrieve the all records from table. By the following
example you can retrieve the full list of Emp table.
mysql> SELECT * FROM
Emp;
If you want to retrieve only some fields from a table, then you have to provide a comma
separated list of column names. By the following example you select Name, City and Age
fields from the Emp table.
mysql> SELECT Name, City,
Age from EMP;
The WHERE clause is used to limit the number of records. The comparison operators are
used with WHERE clause to limit the number of records. Comparison operator?s list are
given below:
Operator Description
= Equal to
<> or != Not equal to
< Less then
< = Less then or equal to
> Greater then
> = Greater then or equal to
Like Used for comparing string
Between Used for checking value between a range.
IN Used to check values in a list
NOT IN Used to check the value is not in the list.
% Character - If you are working with Strings, then % character can be used as a wildcard.
By the following example you can retrieve the all fields from Emp table where the
Designation field contain the text, 'Manager'.
mysql> SELECT * FROM Emp WHERE
Designation LIKE '%Manager%';
_ character - The underscore character can be used as a placeholder. By the following
example you can selects the all records from the table Emp, where the Name starts with ?R?
followed by four characters. For this we have to use four underscores.
mysql> SELECT * FROM Emp
WHERE Name LIKE 'R____';
BETWEEN Clause - The BETWEEN clause can be used with numbers, dates and text. The
following example is used to retrieve all fields Emp table where the Salary is between 10000
AND 20000.
mysql> SELECT * FROM Emp WHERE Salary
BETWEEN 10000 AND 20000;
OR Clause - The OR clause is used to check the values against the range of values that have
been specified. The following example retrieves the list of all records where the Designation
is either Manager or Assistant in the Emp table.
mysql> SELECT * FROM Emp WHERE
Designation ='Manager' OR 'Assistant';
IN Clause - The IN clause is used to check the values against to many values that have been
specified in IN clause. The following example retrieves the list of all records where the
Designation is either Manager or Assistant in the Emp table.
mysql> SELECT * FROM Emp WHERE
Designation IN ('Manager', 'Assistant');
NOT IN Clause - You can use the NOT modifier with IN clause for checking the values,.
Which are not within the list. The following example retrieves the list of all records where the
Designation is not equal to Manager or Assistant in the Emp table.
mysql> SELECT * FROM Emp WHERE Designation
NOT IN ('Manager', 'Assistant');
The following list shows you a Aggregate Function that available in MySQL.
AVG( );
The AVG( ) function returns the average value in a group of records. Example of the
AVG( ) function:-SELECT AVG(Profit) FROM Income GROUP BY EmpId;
COUNT( );
The COUNT( ) function returns the number of records in a group of records.
Example of the COUNT( ) function:-SELECT COUNT(Profit) FROM Income GROUP BY EmpId;
MAX( );
The MAX( ) function return the maximum value in a group of records. Example of
the MAX( ) function:-SELECT MAX(Profit) FROM Income GROUP BY EmpId;
MIN( );
The MIN( ) function returns minimum value in a group of records. Example of the
MIN( ) function:- SELECT MIN(Profit) FROM Income GROUP BY EmpId;
SUM( );
The SUM( ) function return the sum of the field. Example of the SUM() function :SELECT SUM(Profit) FROM Income GROUP BY EmpId ;
The HAVING Clause
As you know the WHERE clause is used to restrict the records in a query. But if you want to
restrict the records by using the Aggregate function then you have to use the HAVING
clause. The HAVING clause restricts the records after they have been grouped. The
following example shows the list of all Employees who did profit over 10000 on average.
mysql> SELECT AVG(Profit) FROM Income GROUP BY
EmpId HAVING AVG(Profit) > 10000;
The ORDER BY Clause
The ORDER BY clause can be used to set the order of the retrieved records. The following
example shows the list of all employees in the Emp table in alphabetical order. In this clause
we can use the ASC or DESC modifiers to set the order of records in ascending or
descending order. If any modifier is not provided then the records are listed in ascending
order.
mysql> SELECT Name FROM
Emp ORDER BY Name;
The LIMIT Clause
The LIMIT clause can be used to limit the number of records that have been returned by the
SELECT statement. You can specify the start row, and number of records retrieved.
mysql> SELECT * FROM Emp
LIMIT 0,10;
GROUP BY clauseThe MySQL GROUP BY clause is used with the SELECT statement to group rows into subgroups by the one or more values of columns or expressions.The MySQL GROUP BY clause is an optional part of the SELECT statement. It must appear after the FROM or WHERE clause. The MySQL GROUP BY clause consists of the GROUP BY keyword followed by a list of comma-separated columns or expressions.
The following illustrates the MySQL GROUP BY clause syntax:SELECT c1,c2,... cn, aggregate_function(expression)FROM tableWHERE where_conditionsGROUP BY c1, c2, ... cn
Views in MySQL
A view is a specific look on data from one or more tables. It can arrange data in some specific order, highlight or hide some data. A view consists of a stored query accessible as a virtual table composed of the result set of a query. Unlike ordinary tables a view does not form part of the physical schema. It is a dynamic, virtual table computed or collated from data in the database.A view is a pseudo table. It is a stored query which looks like a table. And it can be referenced like a table.Views can restrict users to specific rows or columns and thus enhance security. They can be used to joing columns from multiple tables, so that they look like a single table. They can be used to provide aggregate information.There are several restrictions that apply to views. Here are some of them:
The SELECT statement cannot contain a subquery The SELECT statement cannot refer to system or user variables Any table or view referred to in the definition must exist A temporary VIEW cannot be created A VIEW cannot be associated with a trigger
Creating, modifying and dropping a View CREATE VIEW syntax to create a view.
mysql> SELECT * FROM Cars;+----+------------+--------+| Id | Name | Cost |+----+------------+--------+| 1 | Audi | 52642 || 2 | Mercedes | 57127 || 3 | Skoda | 9000 || 4 | Volvo | 29000 || 5 | Bentley | 350000 || 6 | Citroen | 21000 || 7 | Hummer | 41400 || 8 | Volkswagen | 21600 |+----+------------+--------+
This is our data, upon which we create the view.
mysql> CREATE VIEW CheapCars AS -> SELECT Name FROM Cars WHERE Cost<25000;
We create a view CheapCars. These are cars which cost under 25000.
mysql> SELECT * FROM CheapCars;+------------+| Name |+------------+| Skoda || Citroen || Volkswagen |+------------+
A view is a database object than can be queried. There are three cars which are considered to be cheap.
mysql> ALTER VIEW CheapCars AS SELECT Name FROM Cars -> WHERE Cost<30000;
mysql> SELECT * FROM CheapCars;+------------+| Name |+------------+| Skoda || Volvo || Citroen || Volkswagen |+------------+
We can redefine a view. Say we now consider a car to be cheap, if it costs under 30000. We use the ALTER VIEW statement to modify our view.
What happens to a view if we delete a table, from which the data is selected?
mysql> DROP TABLE Cars;
mysql> SELECT * FROM CheapCars;ERROR 1356 (HY000): View 'mydb.CheapCars' references invalid table(s) or column(s) or function(s) or definer/invoker of view lack rights to use them
Querying the view we receive the above error.
mysql> SOURCE cars.sql
mysql> SELECT * FROM CheapCars;+------------+| Name |+------------+| Skoda || Citroen || Volkswagen |+------------+
When we recreate the table the view works again.
mysql> DROP VIEW CheapCars;
Finally, a view is deleted with the DROP VIEW syntax.
Finding viewsWe will mention several ways how to find views in MySQL database.
mysql> SHOW FULL TABLES;+----------------+------------+| Tables_in_mydb | Table_type |+----------------+------------+| AA | BASE TABLE |...| Chars | BASE TABLE || CheapCars | VIEW || Customers | BASE TABLE || Dates | BASE TABLE || Decimals | BASE TABLE || FavoriteCars | VIEW |...
We can list all tables in a database with a SHOW FULL TABLES statement. In the Table_type column we can see, whether it is a table or a view.
mysql> SELECT TABLE_NAME, TABLE_TYPE FROM information_schema.TABLES;+---------------------------------------+-------------+| TABLE_NAME | TABLE_TYPE |+---------------------------------------+-------------+| CHARACTER_SETS | SYSTEM VIEW || COLLATIONS | SYSTEM VIEW || COLLATION_CHARACTER_SET_APPLICABILITY | SYSTEM VIEW || COLUMNS | SYSTEM VIEW || COLUMN_PRIVILEGES | SYSTEM VIEW || ENGINES | SYSTEM VIEW |...| Chars | BASE TABLE || CheapCars | VIEW || Customers | BASE TABLE || Dates | BASE TABLE || Decimals | BASE TABLE || FavoriteCars | VIEW |...
In the information_schema database there is a TABLES table. The TABLE_NAME and TABLE_TYPE columns give us information about table names and their types.
mysql> SELECT TABLE_NAME FROM information_schema.VIEWS;+--------------+| TABLE_NAME |
+--------------+| CheapCars || FavoriteCars |+--------------+
This is the most straightforward way to find views. We query the VIEWS table of the information_schema database.
Creating a view with a UNIONThe UNION operator is used to combine result-sets of two or more SELECT statements. Each select must have the same number of columns.
mysql> CREATE VIEW FavoriteCars AS -> SELECT * FROM Cars WHERE Id=7 -> UNION SELECT * FROM Cars WHERE Id=4 -> UNION SELECT * FROM Cars WHERE Id=5;
We create a view called FavoriteCars. In this view, we have three rows which are considered to be favourite. There are three SELECT statements combined with a UNION operator.
mysql> SELECT * FROM FavoriteCars;+----+---------+--------+| Id | Name | Cost |+----+---------+--------+| 7 | Hummer | 41400 || 4 | Volvo | 29000 || 5 | Bentley | 350000 |+----+---------+--------+
This is a SELECT from the view.
JOIN in MySQL
An SQL join clause combines records from two or more tables in a database. It creates a set that can be saved as a table or used as it is. A JOIN is a means for combining fields from two tables by using values common to each. ANSI standard SQL specifies four types of JOIN: INNER, OUTER, LEFT, and RIGHT. As a special case, a table (base table, view, or joined table) canJOIN to itself in a self-join.
A programmer writes a JOIN predicate to identify the records for joining. If the evaluated predicate is true, the combined record is then produced in the expected format, a record set or a temporary table.
Consider the following tables:
Employee table
LastName DepartmentID
Rafferty 31
Jones 33
Steinberg 33
Robinson 34
Smith 34
John NULL
Department table
DepartmentID DepartmentName
31 Sales
33 Engineering
34 Clerical
35 Marketing
Note: In the Employee table above, the employee "John" has not been assigned to any department yet. Also, note that no employees are assigned to the "Marketing" department.
Cross join
CROSS JOIN returns the Cartesian product of rows from tables in the join. In other words, it will produce rows which combine each row from the first table with each row from the second table.[1]
Example of an explicit cross join:
SELECT *
FROM employee CROSS JOIN department;
Example of an implicit cross join:
SELECT *FROM employee, department;
Employee.LastName
Employee.DepartmentID
Department.DepartmentName
Department.DepartmentID
Rafferty 31 Sales 31
Jones 33 Sales 31
Steinberg 33 Sales 31
Smith 34 Sales 31
Robinson 34 Sales 31
John NULL Sales 31
Rafferty 31 Engineering 33
Jones 33 Engineering 33
Steinberg 33 Engineering 33
Smith 34 Engineering 33
Robinson 34 Engineering 33
John NULL Engineering 33
Rafferty 31 Clerical 34
Jones 33 Clerical 34
Steinberg 33 Clerical 34
Smith 34 Clerical 34
Robinson 34 Clerical 34
John NULL Clerical 34
Rafferty 31 Marketing 35
Jones 33 Marketing 35
Steinberg 33 Marketing 35
Smith 34 Marketing 35
Robinson 34 Marketing 35
John NULL Marketing 35
The cross join does not apply any predicate to filter records from the joined table. Programmers can further filter the results of a cross join by using a WHERE clause.
Inner join
An inner join is the most common join operation used in applications and can be regarded as the default join-type. Inner join creates a new result table by combining column values of two tables (A and B) based upon the join-predicate. The query compares each row of A with each row of B to find all pairs of rows which satisfy the join-predicate. When the join-predicate is satisfied, column values for each matched pair of rows of A and B are combined into a result
row. The result of the join can be defined as the outcome of first taking the Cartesian product (or Cross join) of all records in the tables (combining every record in table A with every record in table B)—then return all records which satisfy the join predicate. Actual SQL implementations normally use other approaches like a hash join or a sort-merge join where possible, since computing the Cartesian product is very inefficient.
SQL specifies two different syntactical ways to express joins: "explicit join notation" and "implicit join notation".
The "explicit join notation" uses the JOIN keyword to specify the table to join, and the ON keyword to specify the predicates for the join, as in the following example:
SELECT *FROM employee INNER JOIN department ON employee.DepartmentID = department.DepartmentID;
The "implicit join notation" simply lists the tables for joining, in the FROM clause of the SELECT statement, using commas to separate them. Thus it specifies a cross join, and the WHERE clause may apply additional filter-predicates (which function comparably to the join-predicates in the explicit notation).
The following example is equivalent to the previous one, but this time using implicit join notation:
SELECT *FROM employee, departmentWHERE employee.DepartmentID = department.DepartmentID;
The queries given in the examples above will join the Employee and Department tables using the DepartmentID column of both tables. Where the DepartmentID of these tables match (i.e. the join-predicate is satisfied), the query will combine the LastName, DepartmentID and DepartmentName columns from the two tables into a result row. Where the DepartmentID does not match, no result row is generated.
Thus the result of the execution of either of the two queries above will be:
Employee.LastName
Employee.DepartmentID
Department.DepartmentName
Department.DepartmentID
Robinson 34 Clerical 34
Jones 33 Engineering 33
Smith 34 Clerical 34
Steinberg 33 Engineering 33
Rafferty 31 Sales 31
Note: Programmers should take special care when joining tables on columns that can contain NULL values, since NULL will never match any other value (not even NULL itself), unless the join condition explicitly uses the IS NULL or IS NOT NULL predicates.
Notice that the employee "John" and the department "Marketing" do not appear in the query execution results. Neither of these has any matching records in the other respective table: "John" has no associated department, and no employee has the department ID 35 ("Marketing"). Depending on the desired results, this behavior may be a subtle bug, which can be avoided with an outer join.
One can further classify inner joins as equi-joins, as natural joins, or as cross-joins.
Equi-join
An equi-join is a specific type of comparator-based join, that uses only equality comparisons in the join-predicate. Using other comparison operators (such as <) disqualifies a join as an equi-join. The query shown above has already provided an example of an equi-join:
SELECT *FROM employee JOIN department ON employee.DepartmentID = department.DepartmentID;
We can write equi-join as below,
SELECT *FROM employee, departmentWHERE employee.DepartmentID = department.DepartmentID;
If columns in an equi-join have the same name, SQL-92 provides an optional shorthand notation for expressing equi-joins, by way of the USING construct:
SELECT *FROM employee INNER JOIN department USING (DepartmentID);
The USING construct is more than mere syntactic sugar, however, since the result set differs from the result set of the version with the explicit predicate. Specifically, any columns mentioned in the USING list will appear only once, with an unqualified name, rather than once for each table in the join. In the above case, there will be a single DepartmentID column and noemployee.DepartmentID or department.DepartmentID.
The USING clause is not supported by SQL Server and Sybase.
Natural join
A natural join is a type of equi-join where the join predicate arises implicitly by comparing all columns in both tables that have the same column-names in the joined tables. The resulting joined table contains only one column for each pair of equally named columns.
Most experts agree that NATURAL JOINs are dangerous and therefore strongly discourage their use. The danger comes from inadvertently adding a new column, named the same as another column in the other table. An existing natural join might then "naturally" use the new column for comparisons, making comparisons/matches using different criteria (from different
columns) than before. Thus an existing query could produce different results, even though the data in the tables have not been changed, but only augmented.
The above sample query for inner joins can be expressed as a natural join in the following way:
SELECT *FROM employee NATURAL JOIN department;
As with the explicit USING clause, only one DepartmentID column occurs in the joined table, with no qualifier:
DepartmentID
Employee.LastName Department.DepartmentName
34 Smith Clerical
33 Jones Engineering
34 Robinson Clerical
33 Steinberg Engineering
31 Rafferty Sales
PostgreSQL, MySQL and Oracle support natural joins, but not Microsoft T-SQL or IBM DB2. The columns used in the join are implicit so the join code does not show which columns are expected, and a change in column names may change the results. An INNER JOIN performed on 2 tables having the same field name has the same effect.
Outer joins
An outer join does not require each record in the two joined tables to have a matching record. The joined table retains each record—even if no other matching record exists. Outer joins subdivide further into left outer joins, right outer joins, and full outer joins, depending on which table's rows are retained (left, right, or both).
(In this case left and right refer to the two sides of the JOIN keyword.)
No implicit join-notation for outer joins exists in standard SQL.
Left outer join
The result of a left outer join (or simply left join) for table A and B always contains all records of the "left" table (A), even if the join-condition does not find any matching record in the "right" table (B). This means that if the ON clause matches 0 (zero) records in B (for a given record in A), the join will still return a row in the result (for that record)—but with
NULL in each column from B. Aleft outer join returns all the values from an inner join plus all values in the left table that do not match to the right table. From Oracle 9i onwards the LEFT OUTER JOIN statement can be used as well as Oracle's older (+) syntax.
For example, this allows us to find an employee's department, but still shows the employee(s) even when they have not been assigned to a department (contrary to the inner-join example above, where unassigned employees were excluded from the result).
Example of a left outer join, with the additional result row (compared with the inner join) italicized:
SELECT *FROM employee LEFT OUTER JOIN department ON employee.DepartmentID = department.DepartmentID;
Employee.LastName
Employee.DepartmentID
Department.DepartmentName
Department.DepartmentID
Jones 33 Engineering 33
Rafferty 31 Sales 31
Robinson 34 Clerical 34
Smith 34 Clerical 34
John NULL NULL NULL
Steinberg 33 Engineering 33
Oracle supports the alternate syntax:
SELECT *FROM employee, departmentWHERE employee.DepartmentID = department.DepartmentID(+)
Sybase supports the alternate syntax:
SELECT *FROM employee, departmentWHERE employee.DepartmentID *= department.DepartmentID
Right outer join
A right outer join (or right join) closely resembles a left outer join, except with the treatment of the tables reversed. Every row from the "right" table (B) will appear in the joined table at least once. If no matching row from the "left" table (A) exists, NULL will appear in columns from A for those records that have no match in B.
A right outer join returns all the values from the right table and matched values from the left table (NULL in case of no matching join predicate). For example, this allows us to find each employee and his or her department, but still show departments that have no employees.
Below is an example of a right outer join, with the additional result row italicized:
SELECT *FROM employee RIGHT OUTER JOIN department ON employee.DepartmentID = department.DepartmentID;
Employee.LastName
Employee.DepartmentID
Department.DepartmentName
Department.DepartmentID
Smith 34 Clerical 34
Jones 33 Engineering 33
Robinson 34 Clerical 34
Steinberg 33 Engineering 33
Rafferty 31 Sales 31
NULL NULL Marketing 35
Oracle supports the alternate syntax:
SELECT *FROM employee, departmentWHERE employee.DepartmentID(+) = department.DepartmentID
Right and left outer joins are functionally equivalent. Neither provides any functionality that the other does not, so right and left outer joins may replace each other as long as the table order is switched.
Full outer join
Conceptually, a full outer join combines the effect of applying both left and right outer joins. Where records in the FULL OUTER JOINed tables do not match, the result set will have
NULL values for every column of the table that lacks a matching row. For those records that do match, a single row will be produced in the result set (containing fields populated from both tables).
For example, this allows us to see each employee who is in a department and each department that has an employee, but also see each employee who is not part of a department and each department which doesn't have an employee.
Example full outer join:
SELECT *FROM employee FULL OUTER JOIN department ON employee.DepartmentID = department.DepartmentID;
Employee.LastName
Employee.DepartmentID
Department.DepartmentName
Department.DepartmentID
Smith 34 Clerical 34
Jones 33 Engineering 33
Robinson 34 Clerical 34
John NULL NULL NULL
Steinberg 33 Engineering 33
Rafferty 31 Sales 31
NULL NULL Marketing 35
Some database systems do not support the full outer join functionality directly, but they can emulate it through the use of an inner join and UNION ALL selects of the "single table rows" from left and right tables respectively. The same example can appear as follows:
SELECT employee.LastName, employee.DepartmentID, department.DepartmentName, department.DepartmentIDFROM employeeINNER JOIN department ON employee.DepartmentID = department.DepartmentID UNION ALL
SELECT employee.LastName, employee.DepartmentID, CAST(NULL AS VARCHAR(20)), CAST(NULL AS INTEGER)FROM employeeWHERE NOT EXISTS ( SELECT * FROM department WHERE employee.DepartmentID = department.DepartmentID) UNION ALL SELECT CAST(NULL AS VARCHAR(20)), CAST(NULL AS INTEGER), department.DepartmentName, department.DepartmentIDFROM departmentWHERE NOT EXISTS ( SELECT * FROM employee WHERE employee.DepartmentID = department.DepartmentID)Self-join
A self-join is joining a table to itself.
Example
A query to find all pairings of two employees in the same country is desired. If there were two separate tables for employees and a query which requested employees in the first table having the same country as employees in the second table, a normal join operation could be used to find the answer table. However, all the employee information is contained within a single large table.[7]
Consider a modified Employee table such as the following:
Employee Table
EmployeeID
LastName Country DepartmentID
123 Rafferty Australia 31
124 Jones Australia 33
145 Steinberg Australia 33
201 Robinson United States 34
305 Smith Germany 34
306 John Germany NULL
An example solution query could be as follows:
SELECT F.EmployeeID, F.LastName, S.EmployeeID, S.LastName, F.CountryFROM Employee F INNER JOIN Employee S ON F.Country = S.CountryWHERE F.EmployeeID < S.EmployeeIDORDER BY F.EmployeeID, S.EmployeeID;
Which results in the following table being generated.
Employee Table after Self-join by Country
EmployeeIDLastNam
eEmployeeID LastName Country
123 Rafferty 124 Jones Australia
123 Rafferty 145 Steinberg Australia
124 Jones 145 Steinberg Australia
305 Smith 306 John Germany
For this example: F and S are aliases for the first and second copies of the employee table. The condition F.Country = S.Country excludes pairings between employees in different
countries. The example question only wanted pairs of employees in the same country. The condition F.EmployeeID < S.EmployeeID excludes pairings where
the EmployeeID of the first employee is greater than or equal to the EmployeeID of the second employee. In other words, the effect of this condition is to exclude duplicate pairings and self-pairings. Without it, the following less useful table would be generated (the table below displays only the "Germany" portion of the result):
EmployeeIDLastNam
eEmployeeID LastName Country
305 Smith 305 Smith Germany
305 Smith 306 John Germany
306 John 305 Smith Germany
306 John 306 John Germany
Only one of the two middle pairings is needed to satisfy the original question, and the topmost and bottommost are of no interest at all in this example.
ResultSet Object in MYSQL
java.sql Interface ResultSet
A table of data representing a database result set, which is usually generated by executing a statement that queries the database.
A ResultSet object maintains a cursor pointing to its current row of data. Initially the cursor is positioned before the first row. The next method moves the cursor to the next row, and because it returns false when there are no more rows in the ResultSet object, it can be used in a while loop to iterate through the result set.
A default ResultSet object is not updatable and has a cursor that moves forward only. Thus, you can iterate through it only once and only from the first row to the last row. It is possible to produce ResultSet objects that are scrollable and/or updatable. The following code fragment, in which con is a valid Connection object, illustrates how to make a result set that is scrollable and insensitive to updates by others, and that is updatable. See ResultSet fields for other options.
Statement stmt = con.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = stmt.executeQuery("SELECT a, b FROM TABLE2"); // rs will be scrollable, will not show changes made by others, // and will be updatable
The ResultSet interface provides getter methods (getBoolean, getLong, and so on) for retrieving column values from the current row. Values can be retrieved using either the index number of the column or the name of the column. In general, using the column index will be more efficient. Columns are numbered from 1. For maximum portability, result set columns within each row should be read in left-to-right order, and each column should be read only once.
For the getter methods, a JDBC driver attempts to convert the underlying data to the Java type specified in the getter method and returns a suitable Java value. The JDBC specification has a table showing the allowable mappings from SQL types to Java types that can be used by the ResultSet getter methods.
Column names used as input to getter methods are case insensitive. When a getter method is called with a column name and several columns have the same name, the value of the first matching column will be returned. The column name option is designed to be used when column names are used in the SQL query that generated the result set. For columns that are NOT explicitly named in the query, it is best to use column numbers. If column names are used, there is no way for the programmer to guarantee that they actually refer to the intended columns.
A set of updater methods were added to this interface in the JDBC 2.0 API (JavaTM 2 SDK, Standard Edition, version 1.2). The comments regarding parameters to the getter methods also apply to parameters to the updater methods.
The updater methods may be used in two ways:
1. to update a column value in the current row. In a scrollable ResultSet object, the cursor can be moved backwards and forwards, to an absolute position, or to a position relative to the current row. The following code fragment updates the NAME column in the fifth row of the ResultSet object rs and then uses the method updateRow to update the data source table from which rs was derived.
rs.absolute(5); // moves the cursor to the fifth row of rs rs.updateString("NAME", "AINSWORTH"); // updates the // NAME column of row 5 to be AINSWORTH rs.updateRow(); // updates the row in the data source
2. to insert column values into the insert row. An updatable ResultSet object has a special row associated with it that serves as a staging area for building a row to be inserted. The following code fragment moves the cursor to the insert row, builds a three-column row, and inserts it into rs and into the data source table using the method insertRow.
rs.moveToInsertRow(); // moves cursor to the insert row rs.updateString(1, "AINSWORTH"); // updates the // first column of the insert row to be AINSWORTH rs.updateInt(2,35); // updates the second column to be 35 rs.updateBoolean(3, true); // updates the third column to true rs.insertRow(); rs.moveToCurrentRow();
A ResultSet object is automatically closed when the Statement object that generated it is closed, re-executed, or used to retrieve the next result from a sequence of multiple results.
The number, types and properties of a ResultSet object's columns are provided by the ResulSetMetaData object returned by the ResultSet.getMetaData method.
Properties object to connect to database:
Using a database URL and a Properties object:
A third form of the DriverManager.getConnection( ) method requires a database URL and a Properties object:
DriverManager.getConnection(String url, Properties info);
A Properties object holds a set of keyword-value pairs. It's used to pass driver properties to the driver during a call to the getConnection() method.
To make the same connection made by the previous examples, use the following code:
import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;import java.util.Properties; public class DBConnect2 { public static void main(String[] args) { String databaseURL = "jdbc:mysql://localhost:3306/test"; Connection conn = null; try { Properties props = new Properties(); props.put("user", "root"); props.put("password", "root123"); conn = DriverManager.getConnection(databaseURL, props); if (conn != null) { System.out.println("Connected to the database"); } } catch (SQLException ex) { System.out.println("An error occurred. Maybe user/password is invalid"); ex.printStackTrace(); } finally { if (conn != null) { try { conn.close(); } catch (SQLException ex) { ex.printStackTrace(); } } } }}
MYSQL commands:
CREATE TABLE Syntax
CREATE TABLE creates a table with the given name.A) FOR GENERAL TABLE CREATIONCreate Table TableName(fieldname datatype,fieldname1 datatype,…)Example: CREATE TABLE Student (StudentId int(6) not null default 0,Studentvarchar(25) not null default ‘’, PrimaryKey(StudentId));B) FOR CREATING TABLE USING AN EXISTING TABLE(ALONG WITH DATA)Create Table TableName AS Select * from ExistingTableNameExample: CREATE TABLE StudentEmail AS SELECT * FROM PersonEmail;C) FOR CREATING TABLE USING AN EXISTING TABLE(WITHOUT DATA)Create Table TableName like ExistingTableNameExample: CREATE TABLE StudentEmail like PersonEmail;D) FOR CREATING TABLE USING MYSQLDUMPmysqldump –p –u username databasename tablename > tablename.sqlmysql -u –p username databasename < tablename.sqlExample: mysqldump -p -u sans sanskrit Pustak > pustak.sqlExample: mysql -p -u sans sans sanskrit < pustak.sql
2. ALTER TABLE SyntaxALTER TABLE enables you to change the structure of an existing table. For example, you can add ordelete columns, change the type of existing columns, or rename columns or the table itself.A) TO ADD A NEW COLUMNa) To add the column as the first column of the table.Alter Table TableName add NewColumnName datatype FIRSTExample: Alter table Student add School varchar(30) not null default ‘’ FIRSTb) To add the column after a particular column of the table.Alter Table TableName add NewColumnName datatype AFTER ExistingColumnNameExample: Alter table Student Add School varchar(30) not null default ‘’ AFTER StudentB) TO DELETE A COLUMNAlter Table TableName DROP ColumnNameExample: Alter table Student DROP SchoolC) TO RENAME A COLUMNAlter Table TableName CHANGE OldColumnName NewColumnName datatypeExample: Alter table Student change School SchoolName varchar(30) not null default ‘’;D) TO MODIFY A COLUMN DATA-TYPE/SIZEAlter Table TableName modify ColumnName datatypeExample: Alter table Student modify School varchar(50) not null default ‘’;E) TO MAKE A COLUMN UNIQUEa) To make a single column unique.Alter Table TableName add UNIQUE(fieldname)Example: Alter table Student add UNIQUE(School);b) To make multiple columns unique.Alter Table TableName add UNIQUE(fieldname1, fieldname2, fieldname3)Example: Alter table Ashtadhyayee add UNIQUE(Bhav, Paad, Sootra);
3. RENAME TABLE SyntaxThis statement renames one or more tables.Rename OldTableName to NewTableName;Example: Rename Student to StudentDetail
4. DROP TABLE SyntaxThis statement will allow deleting a table from the databaseDROP table TableName;Example: DROP table StudentDetail
5. TO SEE ALL THE TABLES IN THE DATABASESHOW tables;
6. TO SEE DATABASE'S FIELD FORMATS.Desc tablename;
7. INSERT SyntaxINSERT inserts new rows into an existing tableA) To Insert data in all columns of a table.INSERT INTO TableName values ()Example: Insert into StudentDetail values(1,’Ravi’,’WoodBine’),;B) To Insert data in a column(s) of the table.INSERT INTO TableName (ColName1, ColName2,..) values(val1,val2,..)Example: Insert into StudentDetail (StudentId, StudentName) values(2,’Shyaam’),;C) To Insert data into a table from another table.INSERT INTO TableName (ColName1,ColName2) select ColName1,ColName2 From TableName2.Example: Insert into StudentName (StudentName) select Name from NameLog;
8. SELECT SyntaxSELECT is used to retrieve rows selected from one or more tablesD) To Select all data from the tableSELECT * FROM TABLENAME;Example: Select * from StudentDetail;E) To Select data of a particular Column from the tableSELECT ColumnName FROM TABLENAME;Example: Select StudentName from StudentDetail;F) To Select data based on a conditionSELECT * FROM TABLENAME where Condition;Example: Select StudentName from StudentDetail where StudentId=2;G) To Select limited number of Records at a timeSELECT * FROM TABLENAME LIMIT no.of recordsExample: Select StudentName from StudentDetail LIMIT 10
9. UPDATE SyntaxUPDATE statement updates columns of existing rows in TableName with new values. The SET clauseindicates which columns to modify and the values they should be given. The WHERE clause, if given,specifies the conditions that identify which rows to update. With no WHERE clause, all rows are updated. A)To Update data based on a conditionUPDATE TableName SET ColumnName=’value’ where condition;Example: UPDATE StudentDetail SET StudentName=’Rohan’ where StudentId=1;B) To Update all records simultaneously
UPDATE TableName SET ColumnName=’value’ where conditionExample: UPDATE StudentDetail SET School=’Wendy High School’;
10. DELETE SyntaxDELETE statement deletes rows from TableName and returns a count of the number of deleted rows. TheWHERE clause, if given, specifies the conditions that identify which rows to delete. With no WHEREclause, all rows are deleted.C) To Delete data based on a conditionDelete fieldname from TableName where condition;Example: Delete StudentName where StudentId=1;D) To Delete all records simultaneouslyDelete from TableNameExample: Delete * from StudentDetail
Program models:
In the design of Java Web applications, there are two commonly used design models, referred to as Model 1 and Model 2.
Model 1
A simplified diagram of a Model 1 implementation.
In Model 1, a request is made to a JSP or servlet and then that JSP or servlet handles all responsibilities for the request, including processing the request, validating data, handling the business logic, and generating a response. The Model 1 architecture is commonly used in smaller, simple task applications due to its ease of development.
Although conceptually simple, this architecture is not conducive to large-scale application development because, inevitably, a great deal of functionality is duplicated in each JSP. Also, the Model 1 architecture unnecessarily ties together the business logic and presentation logic of the application. Combining business logic with presentation logic makes it hard to introduce a new 'view' or access point in an application. For example, in addition to an HTML interface, you might want to include a Wireless Markup Language (WML) interface for wireless access. In this case, using Model 1 will unnecessarily require the duplication of the business logic with each instance of the presentation code.
Advantages:Easy and quick to develop web application
Disadvantages:Navigation control is decentralized.Time consuming: spend more time to develop custom tags in JSP. So that there is no need to use scirptlet tags.Hard to extend: better for small applications but not for large applications.
Model 2
A simplified diagram of the Model 2 pattern.
Model 2 is a complex design pattern used in the design of Java Web applications which separates the display of content from the logic used to obtain and manipulate the content. Since Model 2 drives a separation between logic and display, it is usually associated with the Model-View-Controller (MVC) paradigm. While the exact form of the MVC "Model" was never specified by the Model 2 design, a number of publications recommend a formalized layer to contain MVC Model code. The Java BluePrints, for example, originally recommended using EJBs to encapsulate the MVC Model.
In a Model 2 application, requests from the client browser are passed to the controller. The controller performs any logic necessary to obtain the correct content for display. It then places the content in the request (commonly in the form of a JavaBean or POJO) and decides which view it will pass the request to. The view then renders the content passed by the controller.
Model 2 is recommended for medium- and large-sized applications.
Advantages:Navigation control is centralizedEasy to maintainEasy to extendEasy to testBetter separation of concerns
Disadvantages:Controller code self is to be written. If the controller code is changed, class has to be recompiled and redeploy the application.
Indexing in MYSQL:
Indexing, is the process of creating Indexes. Indexes are structures which allow SQL (or more generally a DBMS or Search Engine) to locate, in a very efficient fashion, records based on the value of one (or several) of the fields they contain.For example, a database may include at table containing student records, with their Student ID, their Name, Date of Birth, Phone Number ... By creating a index on the Phone Number, we can then search Student based on a phone number. In the absence of an index, the system would have found the same records, but this operation would have been carried by looking every single record and comparing with the desired phone number.
Types of INDEXES:
KEY or INDEX refers to a normal non-unique index. Non-distinct values for the index are allowed, so the index may contain rows with identical values in all columns of the index. These indexes don't enforce any restraints on your data so they are used only for making sure certain queries can run quickly.
UNIQUE refers to an index where all rows of the index must be unique. That is, the same row may not have identical non-NULL values for all columns in this index as another row. As well as being used to speed up queries, UNIQUE indexes can be used to enforce restraints on data, because the database system does not allow this distinct values rule to be broken when inserting or updating data.Your database system may allow a UNIQUE index to be applied to columns which allow NULL values, in which case two rows are allowed to be identical if they both contain a NULL value (the rationale here is that NULL is considered not equal to itself). Depending on your application, however, youmay find this undesirable: if you wish to prevent this, you should disallow NULL values in the relevant columns.
PRIMARY acts exactly like a UNIQUE index, except that it is always named 'PRIMARY', and there may be only one on a table (and there should always be one; though some database systems don't enforce this). A PRIMARY index is intended as a primary means to uniquely identify any row in the table, so unlike UNIQUE it should not be used on any columns which allow NULL values. Your PRIMARY index should be on the smallest number of columns that are sufficient to uniquely identify a row. Often, this is just one column containing a unique auto-incremented number, but if there is anything else that can uniquely identify a row, such as "countrycode" in a list of countries, you can use that instead.Some database systems (such as MySQL's InnoDB) will store a table's records on disk in the order in which they appear in the PRIMARY index.
FULLTEXT indexes are different from all of the above, and their behaviour differs significantly between database systems. FULLTEXT indexes are only useful for full text searches done with the MATCH() / AGAINST() clause, unlike the above three - which are typically implemented internally using b-trees (allowing for selecting, sorting or ranges starting from left most column) or hash tables (allowing for selection starting from left most column).Where the other index types are general-purpose, a FULLTEXT index is specialised, in that it serves a narrow purpose: it's only used for a "full text search" feature.
Similarities All of these indexes may have more than one column in them.
With the exception of FULLTEXT, the column order is significant: for the index to be useful in a query, the query must use columns from the index starting from the left - it can't use just the second, third or fourth part of an index, unless it is also using the previous columns in the index to match static values. (For a FULLTEXT index to be useful to a query, the query must use all columns of the index.)
CREATE INDEX Syntax
Unique indexing:CREATE [UNIQUE|FULLTEXT|SPATIAL] INDEX index_name [index_type] ON tbl_name (index_col_name) [index_type]index_col_name: col_name [(length)] [ASC | DESC]index_type: USING {BTREE | HASH}
Temporary indexing:CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name (create_definition,...) [table_options]
Or:
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name [(create_definition,...)] [table_options] select_statement
Two columns indexing:CREATE INDEX index_name [index_type] ON tbl_name (col_name1,colname2) [index_type]
Multiple columns indexing:CREATE INDEX index_name [index_type] ON tbl_name (col_name1,colname2,colname3) [index_type]
