Validation data with javascript(only numbers,only alphabates,email validation)

Only Numbers:
------------
script language="JavaScript">
function onlyNumbers(evt)
{
var e = event || evt; // for trans-browser compatibility
var charCode = e.which || e.keyCode;

if (charCode > 31 && (charCode < 48 || charCode > 57))
return false;

return true;

}


only charactyers:
----------------


function fn_validateNumeric(thi,dec)
{
if (window.event) keycode = window.event.keyCode;
else if (e) keycode = e.which;
else return true;
if (((keycode>=65) && (keycode<=90))||((keycode>=97) && (keycode<=122)))
{
return true;
}
else
{
return false;
}
}

only Email:
----------
function validateEmail ( f ) {
if ( isEmail ( f.email_address.value ) == false )
{
alert ( "Please enter a valid email address." );
f.email_address.select ( );
return false;
}
return true;
}

function isEmail ( string ) {
if ( string.search(/^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/) != -1 )
return true;
else
return false;
}

Unexpected Error 0x8ffe2740 Occurred

Unexpected Error 0x8ffe2740 Occurred

If you are using IIS 5.1 on XP and are being presented with an "Unexpected Error 0x8ffe2740 Occurred" error message when trying to start your website from the IIS Admin panel, then it is likely that you have a port conflict on your system. That's the easy part, now what do you do to track this conflict down and fix it?

Well, that actually isn't that hard either. By default IIS will try and bind itself to TCP port 80, so the first thing to do is track down which process is binding itself to this port. This could be anything from another webserver (such as Apache), or in my case Skype. To do this, open a command prompt window and type in the following;

netstat -anop TCP|find ":80 "
This will give you some details of what process is using TCP port 80, and unless you have a multihomed system you should only get one result here. The only information that you really need to be concerned about is the number that is display on the far right hand side. This is the PID (Process Identifier) which is a unique number given to a process by the system when it is initiated.

The next step is to match this PID with an actual process that you can identify. There are several ways you can do this, but probably the easiest way is to go back to your command prompt window and type this in (where the number 1234 is the PID number from the previous step);

tasklist /SVC /FI "PID eq 1234"
What this will do is associate the PID number you enter with a process name which will be displayed on the far left, and on the far right will be the name(s) of any related services.This should give you a pretty clear picture of what software is binding itself to TCP port 80, and from there it is a matter of either reconfiguring that software to use a different port number or disabling it while IIS is in use. Of course on the flip side you could always reconfigure IIS to use a different port number as well. Either way, you should now be able to take action so you can start your website from the IIS Admin panel.

Paging With SQL Server Stored Procedures In ASP

Paging With SQL Server Stored Procedures In ASP.NET

Data paging is very useful when you work with large amount of data. Instead of confusing your user with thousands or maybe even millions of records you simply show only first page with 10, 20 or 30 records and enable navigation buttons like Next or Previous if user wants to see other pages. Standard ASP.NET server controls, like GridView have built in paging capabilities in two modes: simple or custom.

Simple paging is easy to implement but it always bind complete records set which is not so scalable solution and can take a lot of network traffic and work very slow if you have large table or your web site is on shared hosting or especially if you have a lot of concurrent visitors. More about how to implement simple or custom paging in GridView and ListView you can read in Data Paging in ASP.NET tutorial.

But, which ever server control you use for data presentation, to get efficient and scalable data paging you need to do all your paging logic on SQL Server's side and SQL Server should return only selected page to ASP.NET web application. With logic like this, you get faster solution, need less memory and avoid too much traffic between SQL Server and web server. On SQL Server side, you can do paging on two main ways:

1. By building a dynamic SQL query

2. By using a stored procedure

Both methods are used widely, to find out how to build dynamic SQL queries for paging check SQL Queries For Paging In ASP.NET. In this tutorial we will see some common solution when paging is done with stored procedure.

Paging stored procedure with three nested queries

You can get selected page by using three nested SQL queries. For example to get third page from Customers table where Country column is 'Spain' with 10 records per page and ordered by CompanyName, sql query will be:

SELECT * FROM
(SELECT TOP 10 * FROM
(SELECT TOP 30 * FROM Customers WHERE Country = 'Spain' AS T1 ORDER BY CompanyName ASC)
AS T2 ORDER BY CompanyName DESC)
T3 ORDER BY CompanyName ASC

I made simple stored procedure based on this idea:

CREATE PROCEDURE getSelectedPage
@TableOrView nvarchar (50),
@SelectedPage int,
@PageSize int,
@Columns nvarchar(500),
@OrderByColumn nvarchar(100),
@OrderByDirection nvarchar(4),
@WhereClause nvarchar(500)
AS
DECLARE @ReturnedRecords int, @SqlQuery nvarchar(1000), @ConOrderByDirection nvarchar(4)
IF Upper(@OrderByDirection) = 'ASC'
BEGIN
SET @ConOrderByDirection = 'DESC'
END
ELSE
BEGIN
SET @ConOrderByDirection = 'ASC'
END

IF @WhereClause <> ''
BEGIN
SET @WhereClause = ' WHERE ' + @WhereClause
END

SET @ReturnedRecords = (@PageSize * @SelectedPage)
SET NOCOUNT ON
SET @SqlQuery = N'SELECT * FROM
(SELECT TOP ' + CAST(@PageSize as varchar(10)) + ' * FROM
(SELECT TOP ' + CAST(@ReturnedRecords as varchar(10)) + ' ' + @Columns +
' FROM ' + @TableOrView + @WhereClause + '
ORDER BY ' + @OrderByColumn + ' ' + @OrderByDirection + ') AS T1
ORDER BY ' + @OrderByColumn + ' ' + @ConOrderByDirection + ') AS T2
ORDER BY ' + @OrderByColumn + ' ' + @OrderByDirection
EXEC(@SqlQuery)
SET NOCOUNT OFF
GO

So, to use it with previous example you need this much simpler line:

EXEC getSelectedPage 'Customers', 3, 10, '*', 'CompanyName', 'ASC', 'Country = ''Spain'' '

This example returns all columns (specified with 4th parameter '*'). In case you need only few columns you need to separate them with comma, for example 'Column1, Column2, Column3'. In this case, you always need to add column name used in ORDER BY clause too.

Three nested queries approach is very simple but it returns last page incorrectly. Number of returned records on last page will be equal to page size.. For example, if page size is 10 and you have total of 73 records, last page should have only 3 records. But, this query will return last 10 records.

To correct this I added additional variable, named TotalRecords and slightly different SQL query if current page is last page. So, this is more complex, but completely accurate paging stored procedure:

CREATE PROCEDURE getSelectedPage
@TableOrView nvarchar (50),
@SelectedPage int,
@PageSize int,
@Columns nvarchar(500),
@OrderByColumn nvarchar(100),
@OrderByDirection nvarchar(4),
@WhereClause nvarchar(500)
AS
SET NOCOUNT ON
DECLARE @ReturnedRecords int, @SqlQuery nvarchar(1000), @ConOrderByDirection nvarchar(4), @TotalPages int, @TotalRecords int

-- Finds total records
SET @SqlQuery = N'SELECT @RecCount = COUNT(*) FROM ' + @TableOrView
EXEC sp_executesql @SqlQuery, N'@RecCount int OUTPUT', @RecCount = @TotalRecords OUTPUT

-- Checks order direction
IF Upper(@OrderByDirection) = 'ASC'
BEGIN
SET @ConOrderByDirection = 'DESC'
END
ELSE
BEGIN
SET @ConOrderByDirection = 'ASC'
END

-- checks if WHERE clause is needed
IF @WhereClause <> ''
BEGIN
SET @WhereClause = ' WHERE ' + @WhereClause
END

-- Finds number of pages
SET @ReturnedRecords = (@PageSize * @SelectedPage)
SET @TotalPages = @TotalRecords / @PageSize
IF @TotalRecords % @PageSize > 0
BEGIN
SET @TotalPages = @TotalPages + 1
END

-- Checks if current page is last page
IF @SelectedPage = @TotalPages
BEGIN
-- Current page is last page
SET @SqlQuery = N'SELECT * FROM
(SELECT TOP ' + CAST((@TotalRecords % @PageSize) as varchar(10)) + ' * FROM
(SELECT TOP ' + CAST(@ReturnedRecords as varchar(10)) + ' ' + @Columns +
' FROM ' + @TableOrView + @WhereClause + '

ORDER BY ' + @OrderByColumn + ' ' + @OrderByDirection + ') AS T1
ORDER BY ' + @OrderByColumn + ' ' + @ConOrderByDirection + ') AS T2
ORDER BY ' + @OrderByColumn + ' ' + @OrderByDirection
END
ELSE
BEGIN
-- Current page is not last page
SET @SqlQuery = N'SELECT * FROM
(SELECT TOP ' + CAST(@PageSize as varchar(10)) + ' * FROM
(SELECT TOP ' + CAST(@ReturnedRecords as varchar(10)) + ' ' + @Columns +
' FROM ' + @TableOrView + @WhereClause + '
ORDER BY ' + @OrderByColumn + ' ' + @OrderByDirection + ') AS T1
ORDER BY ' + @OrderByColumn + ' ' + @ConOrderByDirection + ') AS T2
ORDER BY ' + @OrderByColumn + ' ' + @OrderByDirection
END

-- executes query to get selected page
EXEC(@SqlQuery)
SET NOCOUNT OFF

You can use this procedure on the same way like first example.

Stored procedure for paging by using temporary table

Basically, we create one temporary table with one identity column of type int which will be used as row counter. After that, we extract only wanted rows by filtering rows that belong to selected page.

CREATE PROCEDURE getPageWithTempTable
@TableOrViewName varchar(50),
@Columns varchar(500),
@IdentityColumn varchar(50),
@SortColumn varchar(50),
@SortDirection varchar(4),
@SelectedPage int,
@PageSize int,
@WhereClause varchar(500)
AS

SET NOCOUNT ON

DECLARE @SQLQuery varchar(5000), @StartRecord int, @EndRecord int

-- Create temporary table
CREATE TABLE #TempTable (
RowNumber int IDENTITY (1, 1),
row_id int )

-- Find first record on selected page
SET @StartRecord = (@SelectedPage - 1) * @PageSize + 1

-- Find last record on selected page
SET @EndRecord = @SelectedPage * @PageSize

-- Check if there is WHERE clause
IF @WhereClause <> ''
BEGIN
SET @WhereClause = ' WHERE ' + @WhereClause
END

-- Build INSERT statement used to populate temporary table
SET @SQLQuery = 'INSERT #TempTable (row_id) ' +
' SELECT TOP ' + CAST(@EndRecord AS varchar(20)) + ' ' +
@IdentityColumn + ' FROM ' + @TableOrViewName + ' ' +
@WhereClause + ' ORDER BY ' + @SortColumn + ' ' + @SortDirection

-- Execute statement and populate temp table
EXEC (@SQLQuery)

-- Build SQL query to return only selected page
SET @SQLQuery = N'SELECT RowNumber, ' + @Columns +
' FROM #TempTable tmp JOIN ' + @TableOrViewName +
' ON row_id = ' + @TableOrViewName + '.' + @IdentityColumn +
' WHERE RowNumber >= ' + CAST(@StartRecord AS varchar(20)) +
' AND RowNumber <= ' + CAST(@EndRecord AS varchar(20)) +
' ORDER BY RowNumber '

-- Return selected page
EXEC (@SQLQuery)

-- Delete temporary table
DROP TABLE #TempTable

SET NOCOUNT OFF
GO

So, to return data like in previous example we'll use:

EXEC getPageWithTempTable 'Customers', '*', 'CustomerID', 'CompanyName', 'ASC', 2, 10, 'Country = ''Spain'' '

Stored procedure for paging with ROW_NUMBER() function

SQL Server 2005 introduced new ROW_NUMBER() function that makes paging task easier. To achieve paging like in previous examples, get third page from Customers table where Country column is 'Spain' with 10 records per page and ordered by CompanyName stored procedure will look like this:

CREATE PROCEDURE Paging_Customers
(
@SelectedPage int,
@PageSize int
)
AS
BEGIN
WITH CTE_Customers(PageNumber, ContactTitle, ContactName, CompanyName, Phone, Country)
AS
(
SELECT CEILING((ROW_NUMBER() OVER
(ORDER BY CompanyName ASC
AS PageNumber, ContactTitle, ContactName, CompanyName, Phone, Country
FROM Customers
)

SELECT *
FROM CTE_Customers WHERE PageNumber = @SelectedPage
END

Then, we call this procedure (for third page and ten rows per page) with this simple line:

EXEC Paging_Customers 3, 10

As you can see, this is more hard coded solution but it is more optimized and faster. The reason why we could not use the same logic in previous two stored procedures is that SQL Server doesn't allow using of variables in TOP clause. You can't write something like SELECT TOP @PageSize * FROM TableName because you'll get syntax error. Instead of that, on SQL Server 2000 you need to build SQL query as a string and then execute it by using EXEC keyword. The first two examples with TOP keyword will work on any version of SQL Server, but last solution with ROW_NUMBER() function is usually better solution if you use SQL Server 2005.

Conclusion

It is very important to pay attention to every input from your users because it could be potentially dangerous. It is recommended to use SQL parameters when calling stored procedure to avoid possible SQL injection attacks. Hardest task is usually building of complex WHERE clauses in case that you need to enable not only paging but also database search to your users. Because of that, we developed Search Control as specialized solution to make this task easy. Search Control creates simple or complex WHERE clauses by only changing control's properties, supports different database SQL syntaxes, take care about security issues and more.

Please let me know if you have some other interesting idea for paging with stored procedure. Happy programming!

Differences between sql server 2005 and 2008

Differences b/n SqlServer2000 and SqlServer2005

1. In SQL Server 2000 the Query Analyzer and Enterprise Manager are seperate,whereas in SQL Server 2005 both were combined as Management Studio.

2. In Sql 2005,the new datatype XML is used,whereas in Sql 2000 there is no such datatype

3. In Sql server2000 we can create 65,535 databases,whereas in Sql server2005 2(pow(20))-1 databases can be created.

Differences b/n SqlServer2005 and SqlServer2008

DIFFERENCE	SQLSERVER2005	SQLSERVER2008
1. upgrading		upgrading should be much easier from 2005 to 2008 than it was from 2000 to 2005.
2.

SQL Server 2008 introduces four new date and time data types, which include:

* DATE: As you can imagine, the DATE data type only stores a date in the format of YYYY-MM-DD. It has a range of 0001-01-01 through 9999-12-32, which should be adequate for most business and scientific applications. The accuracy is 1 day, and it only takes 3 bytes to store the date.
* TIME: TIME is stored in the format: hh:mm:ss.nnnnnnn, with a range of 00:00:00.0000000 through 23:59:59:9999999 and is accurate to 100 nanoseconds. Storage depends on the precision and scale selected, and runs from 3 to 5 bytes.
* DATETIME2: DATETIME2 is very similar to the older DATETIME data type, but has a greater range and precision. The format is YYYY-MM-DD hh:mm:ss:nnnnnnnm with a range of 0001-01-01 00:00:00.0000000 through 9999-12-31 23:59:59.9999999, and an accuracy of 100 nanoseconds. Storage depends on the precision and scale selected, and runs from 6 to 8 bytes.
* DATETIMEOFFSET: DATETIMEOFFSET is similar to DATETIME2, but includes additional information to track the time zone. The format is YYYY-MM-DD hh:mm:ss[.nnnnnnn] [+|-]hh:mm with a range of 0001-01-01 00:00:00.0000000 through 0001-01-01 00:00:00.0000000 through 9999-12-31 23:59:59.9999999 (in UTC), and an accuracy of 100 nanoseconds. Storage depends on the precision and scale selected, and runs from 8 to 10 bytes.

SQLSERVER2008 has following feautures:-

• Transparent Data Encryption. The ability to encrypt an entire database.
• Backup Encryption. Executed at backup time to prevent tampering.
• External Key Management. Storing Keys separate from the data.
• Auditing. Monitoring of data access.
• Data Compression. Fact Table size reduction and improved performance.
• Resource Governor. Restrict users or groups from consuming high levels or resources.
• Hot Plug CPU. Add CPUs on the fly.
• Performance Studio. Collection of performance monitoring tools.
• Installation improvements. Disk images and service pack uninstall options.
• Dynamic Development. New ADO and Visual Studio options as well as Dot Net 3.
• Entity Data Services. Line Of Business (LOB) framework and Entity Query Language (eSQL)
• LINQ. Development query language for access multiple types of data such as SQL and XML.
• Data Synchronizing. Development of frequently disconnected applications.
• Large UDT. No size restriction on UDT.
• Dates and Times. New data types: Date, Time, Date Time Offset.
• File Stream. New data type VarBinary(Max) FileStream for managing binary data.
• Table Value Parameters. The ability to pass an entire table to a stored procedure.
• Spatial Data. Data type for storing Latitude, Longitude, and GPS entries.
• Full Text Search. Native Indexes, thesaurus as metadata, and backup ability.
• SQL Server Integration Service. Improved multiprocessor support and faster lookups.
• MERGE. TSQL command combining Insert, Update, and Delete.
• SQL Server Analysis Server. Stack improvements, faster block computations.
• SQL Server Reporting Server. Improved memory management and better rendering.
• Microsoft Office 2007. Use OFFICE as an SSRS template. SSRS to WORD.
• SQL 200 Support Ends. Mainstream Support for SQL 2000 is coming to an end.

50 New Features of SQL Server 2008

· Transparent Data Encryption

Enable encryption of an entire database, data files, or log files, without the need for application changes. Benefits of this include: Search encrypted data using both range and fuzzy searches, search secure data from unauthorized users, and data encryption without any required changes in existing applications.

· Extensible Key Management

SQL Server 2005 provides a comprehensive solution for encryption and key management. SQL Server 2008 delivers an excellent solution to this growing need by supporting third-party key management and HSM products.

· Auditing

Create and manage auditing via DDL, while simplifying compliance by providing more comprehensive data auditing. This enables organizations to answer common questions, such as, "What data was retrieved?"

· Enhanced Database Mirroring

SQL Server 2008 builds on SQL Server 2005 by providing a more reliable platform that has enhanced database mirroring, including automatic page repair, improved performance, and enhanced supportability.

· Automatic Recovery of Data Pages

SQL Server 2008 enables the principal and mirror machines to transparently recover from 823/824 types of data page errors by requesting a fresh copy of the suspect page from the mirroring partner transparently to end users and applications.

· Log Stream Compression

Database mirroring requires data transmissions between the participants of the mirroring implementations. With SQL Server 2008, compression of the outgoing log stream between the participants delivers optimal performance and minimizes the network bandwidth used by database mirroring.

· Resource Governor

Provide a consistent and predictable response to end users with the introduction of Resource Governor, allowing organizations to define resource limits and priorities for different workloads, which enable concurrent workloads to provide consistent performance to their end users.

· Predictable Query Performance

Enable greater query performance stability and predictability by providing functionality to lock down query plans, enabling organizations to promote stable query plans across hardware server replacements, server upgrades, and production deployments.

· Data Compression

Enable data to be stored more effectively, and reduce the storage requirements for your data. Data compression also provides significant performance improvements for large I/O bound workloads, like data warehousing.

· Hot Add CPU

Dynamically scale a database on demand by allowing CPU resources to be added to SQL Server 2008 on supported hardware platforms without forcing any downtime on applications. Note that SQL Server already supports the ability to add memory resources online.

· Policy-Based Management

Policy-Based Management is a policy-based system for managing one or more instances of SQL Server 2008. Use this with SQL Server Management Studio to create policies that manage entities on the server, such as the instance of SQL Server, databases, and other SQL Server objects.

· Streamlined Installation

SQL Server 2008 introduces significant improvements to the service life cycle for SQL Server through the re-engineering of the installation, setup, and configuration architecture. These improvements separate the installation of the physical bits on the hardware from the configuration of the SQL Server software, enabling organizations and software partners to provide recommended installation configurations.

· Performance Data Collection

Performance tuning and troubleshooting are time-consuming tasks for the administrator. To provide actionable performance insights to administrators, SQL Server 2008 includes more extensive performance data collection, a new centralized data repository for storing performance data, and new tools for reporting and monitoring.

· Language Integrated Query (LINQ)

Enable developers to issue queries against data, using a managed programming language, such as C# or VB.NET, instead of SQL statements. Enable seamless, strongly typed, set-oriented queries written in .NET languages to run against ADO.NET (LINQ to SQL), ADO.NET DataSets (LINQ to DataSets), the ADO.NET Entity Framework (LINQ to Entities), and to the Entity Data Service Mapping provider. Use the new LINQ to SQL provider that enables developers to use LINQ directly on SQL Server 2008 tables and columns.

· ADO.NET Data Services

The Object Services layer of ADO.NET enables the materialization, change tracking, and persistence of data as CLR objects. Developers using the ADO.NET framework can program against a database, using CLR objects that are managed by ADO.NET. SQL Server 2008 introduces more efficient, optimized support that improves performance and simplifies development.

· DATE/TIME

SQL Server 2008 introduces new date and time data types:

o DATE—A date-only type

o TIME—A time-only type

o DATETIMEOFFSET—A time-zone-aware datetime type

o DATETIME2—A datetime type with larger fractional seconds and year range than the existing DATETIME type

The new data types enable applications to have separate data and time types while providing large data ranges or user defined precision for time values.

· HIERARCHY ID

Enable database applications to model tree structures in a more efficient way than currently possible. New system type HierarchyId can store values that represent nodes in a hierarchy tree. This new type will be implemented as a CLR UDT, and will expose several efficient and useful built-in methods for creating and operating on hierarchy nodes with a flexible programming model.

· FILESTREAM Data

Allow large binary data to be stored directly in an NTFS file system, while preserving an integral part of the database and maintaining transactional consistency. Enable the scale-out of large binary data traditionally managed by the database to be stored outside the database on more cost-effective storage without compromise.

· Integrated Full Text Search

Integrated Full Text Search makes the transition between Text Search and relational data seamless, while enabling users to use the Text Indexes to perform high-speed text searches on large text columns.

· Sparse Columns

NULL data consumes no physical space, providing a highly efficient way of managing empty data in a database. For example, Sparse Columns allows object models that typically have numerous null values to be stored in a SQL Server 2005 database without experiencing large space costs.

· Large User-Defined Types

SQL Server 2008 eliminates the 8-KB limit for User-Defined Types (UDTs), allowing users to dramatically expand the size of their UDTs.

· Spatial Data Types

Build spatial capabilities into your applications by using the support for spatial data.

o Implement Round Earth solutions with the geography data type. Use latitude and longitude coordinates to define areas on the Earth's surface.

o Implement Flat Earth solutions with the geometry data type. Store polygons, points, and lines that are associated with projected planar surfaces and naturally planar data, such as interior spaces.

· Backup Compression

Keeping disk-based backups online is expensive and time-consuming. With SQL Server 2008 backup compression, less storage is required to keep backups online, and backups run significantly faster since less disk I/O is required.

· Partitioned Table Parallelism

Partitions enable organizations to manage large growing tables more effectively by transparently breaking them into manageable blocks of data. SQL Server 2008 builds on the advances of partitioning in SQL Server 2005 by improving the performance on large partitioned tables.

· Star Join Query Optimizations

SQL Server 2008 provides improved query performance for common data warehouse scenarios. Star Join Query optimizations reduce query response time by recognizing data warehouse join patterns.

· Grouping Sets

Grouping Sets is an extension to the GROUP BY clause that lets users define multiple groupings in the same query. Grouping Sets produces a single result set that is equivalent to a UNION ALL of differently grouped rows, making aggregation querying and reporting easier and faster.

· Change Data Capture

With Change Data Capture, changes are captured and placed in change tables. It captures complete content of changes, maintains cross-table consistency, and even works across schema changes. This enables organizations to integrate the latest information into the data warehouse.

· MERGE SQL Statement

With the introduction of the MERGE SQL Statement, developers can more effectively handle common data warehousing scenarios, like checking whether a row exists, and then executing an insert or update.

· SQL Server Integration Services (SSIS) Pipeline Improvements

Data Integration packages can now scale more effectively, making use of available resources and managing the largest enterprise-scale workloads. The new design improves the scalability of runtime into multiple processors.

· SQL Server Integration Services (SSIS) Persistent Lookups

The need to perform lookups is one of the most common ETL operations. This is especially prevalent in data warehousing, where fact records need to use lookups to transform business keys to their corresponding surrogates. SSIS increases the performance of lookups to support the largest tables.

· Analysis Scale and Performance

SQL Server 2008 drives broader analysis with enhanced analytical capabilities and with more complex computations and aggregations. New cube design tools help users streamline the development of the analysis infrastructure enabling them to build solutions for optimized performance.

· Block Computations

Block Computations provides a significant improvement in processing performance enabling users to increase the depth of their hierarchies and complexity of the computations.

· Writeback

New MOLAP enabled writeback capabilities in SQL Server 2008 Analysis Services removes the need to query ROLAP partitions. This provides users with enhanced writeback scenarios from within analytical applications without sacrificing the traditional OLAP performance.

· Enterprise Reporting Engine

Reports can easily be delivered throughout the organization, both internally and externally, with simplified deployment and configuration. This enables users to easily create and share reports of any size and complexity.

· Internet Report Deployment

Customers and suppliers can effortlessly be reached by deploying reports over the Internet.

· Manage Reporting Infrastructure

Increase supportability and the ability to control server behaviour with memory management, infrastructure consolidation, and easier configuration through a centralized store and API for all configuration settings.

· Report Builder Enhancements

Easily build ad-hoc and author reports with any structure through Report Designer.

· Forms Authentication Support

Support for Forms authentication enables users to choose between Windows and Forms authentication.

· Report Server Application Embedding

Report Server application embedding enables the URLs in reports and subscriptions to point back to front-end applications.

· Microsoft Office Integration

SQL Server 2008 provides new Word rendering that enables users to consume reports directly from within Microsoft Office Word. In addition, the existing Excel renderer has been greatly enhanced to accommodate the support of features, like nested data regions, sub-reports, as well as merged cell improvements. This lets users maintain layout fidelity and improves the overall consumption of reports from Microsoft Office applications.

· Predictive Analysis

SQL Server Analysis Services continues to deliver advanced data mining technologies. Better Time Series support extends forecasting capabilities. Enhanced Mining Structures deliver more flexibility to perform focused analysis through filtering as well as to deliver complete information in reports beyond the scope of the mining model. New cross-validation enables confirmation of both accuracy and stability for results that you can trust. Furthermore, the new features delivered with SQL Server 2008 Data Mining Add-ins for Office 2007 empower every user in the organization with even more actionable insight at the desktop.