Saturday 23 November 2013

What is the difference between the having clause and the group by?



The difference is that WHERE operates on individual rows, while HAVING operates on groups.

You can have WHERE without HAVING, you can have HAVING without WHERE, you can have both WHERE and HAVING, and you can have neither WHERE nor HAVING. But you can't have HAVING without grouping, even if the group consists of the entire result set.

In SQL, the having clause and the group by statement work together when using aggregate functions like SUM, AVG, MAX, etc. This is best illustrated by an example. Suppose we have a table called emp_bonus as shown below. Note that the table hasmultiple entries for employees A and B.
emp_bonus
Employee
Bonus
Emp1
1000
Emp2
2000
Emp1
500
Emp3
700
Emp2
1250

If we want to calculate the total bonus that each employee received, then we would write a SQL statement like this:


select employee, sum(bonus) from emp_bonus group by employee;
The Group By Clause

In the SQL statement above, you can see that we use the "group by" clause with the employee column. The group by clause does allows us to find the sum of the bonuses for each employee. Using the ‘group by’ in combination with the ‘sum(bonus)’ statement will give us the sum of all the bonuses for employees A, B, and C.


Running the SQL above would return this:

Employee
Sum(Bonus)
Emp1
1500
Emp2
3250
Emp3
700

Now, suppose we wanted to find the employees who received more than $1,000 in bonuses for the year of 2007. This is when we need to use the HAVING clause, and this is what the SQL look like:

GOOD SQL:
select employee, sum(bonus) from emp_bonus
group by employee having sum(bonus) > 1000;

And the result of running the SQL above would be this:

Employee
Sum(Bonus)
Emp1
1500
Emp2
3250

Difference between having clause and group by statement

So, from the example, we can see that the group by clause is used to group column(s) so that aggregates (like SUM, MAX, etc) can be used to find the necessary information. The having clause is used with the group by clause when comparisons need to be made with those aggregate functions (like “> 1,000″). So, the having clause and group by statements are not really alternatives to each other – but they are used alongside one another!


Wednesday 20 November 2013

Microsoft SQL Server Online Training

                          Microsoft SQL Server Online Training 

1. SQL Server and Toolset
  • ·         SQL Server Platform
  • ·         Working with SQL Server Tools
  • ·         Configuring SQL Server Services

2. Working Data Types
  • ·         Using Data Types
  • ·         Converting Data Types
  • ·         Specialized Data Types

3. Designing and Implementing Tables
  • ·         Designing Tables
  • ·         Working with Schemas
  • ·         Creating and Altering Tables

4. Ensuring Data Integrity through Constraints
  • ·         Enforcing Data Integrity
  • ·         Implementing Domain Integrity
  • ·         Implementing Entity and Referential Integrity

5. Planning for SQL Server Indexing
  • ·         Core Indexing Concepts
  • ·         Data Types and Indexes
  • ·         Single Column and Composite Indexes

6. Implementing Table Structures in SQL Server 2012
  • ·         SQL Server Table Structures
  • ·         Working with Clustered Indexes
  • ·         Designing Effective Clustered Indexes

7. Reading SQL Server Execution Plans
  • ·         Execution Plan Core Concepts
  • ·         Common Execution Plan Elements
  • ·         Working with Execution Plans

8. Improving Performance through Non-Clustered Indexes
  • ·         Designing Effective Non-Clustered Indexes
  • ·         Implementing Non-Clustered Indexes
  • ·         Using the Database Engine Tuning Advisor

9. Designing and Implementing Views
  • ·         Views
  • ·         Creating and Managing Views
  • ·         Performance Considerations for Views

10. Designing and Implementing Stored Procedures
  • ·         Stored Procedures
  • ·         Working with Stored Procedures
  • ·         Implementing Parameterized Stored Procedures
  • ·         Controlling Execution Context

11. Merging Data and Passing Tables
  • ·         Using the MERGE Statement
  • ·         Implementing Table Types
  • ·         Using TABLE Types as Parameters

12. Designing and Implementing User-Defined Functions
  • ·         Functions
  • ·         Designing and Implementing Scalar Functions
  • ·         Designing and Implementing Table-Valued Functions
  • ·         Implementation Considerations for Functions
  • ·         Alternatives to Functions

13. Creating Highly Concurrent SQL Server Applications
  • ·         Transactions
  • ·         Locks
  • ·         Management of Locking
  • ·         Transaction Isolation Levels

14. Handling Errors in T-SQL Code
  • ·         T-SQL Error Handling
  • ·         Implementing T-SQL Error Handling
  • ·         Implementing Structured Exception Handling

15. Responding to Data Manipulation via Triggers
  • ·         Designing DML Triggers
  • ·         Implementing DML Triggers
  • ·         Advanced Trigger Concepts

16. Implementing Managed Code in SQL Server 2012
  • ·         SQL CLR Integration
  • ·         Importing and Configuring Assemblies
  • ·         Implementing SQL CLR Integration

17. Storing XML Data in SQL Server 
  • ·         XML and XML Schemas
  • ·         Storing XML Data and Schemas in SQL Server
  • ·         Implementing the XML Data Type

18. Querying XML Data in SQL Server
  • ·         Using the T-SQL for XML Statement
  • ·         Starting with XQuery
  • ·         Shredding XML

19. Working with SQL Server Spatial Data
  • ·         Spatial Data
  • ·         Working with SQL Server Spatial Data Types
  • ·         Using Spatial Data in Applications

20. Working with Full-Text Indexes and Queries
  • ·         Implementing a Full-Text Index
  • ·         Implementing a Stoplist
  • ·         Creating a Stored Procedure to Implement a Full-Text Search

Thanks,
Raja K

+91 9247360004