List of DMV in SQL Server 2005

1. sys.dm_broker_activated_tasks
2. sys.dm_broker_connections
3. sys.dm_broker_forwarded_messages
4. sys.dm_broker_queue_monitors
5. sys.dm_clr_appdomains
6. sys.dm_clr_loaded_assemblies
7. sys.dm_clr_properties
8. sys.dm_clr_tasks
9. sys.dm_db_file_space_usage
10. sys.dm_db_index_usage_stats
11. sys.dm_db_mirroring_connections
12. sys.dm_db_missing_index_details
13. sys.dm_db_missing_index_group_stats
14. sys.dm_db_missing_index_groups
15. sys.dm_db_partition_stats
16. sys.dm_db_session_space_usage
17. sys.dm_db_task_space_usage
18. sys.dm_exec_background_job_queue
19. sys.dm_exec_background_job_queue_stats
20. sys.dm_exec_cached_plans
21. sys.dm_exec_connections
22. sys.dm_exec_query_memory_grants
23. sys.dm_exec_query_optimizer_info
24. sys.dm_exec_query_resource_semaphores
25. sys.dm_exec_query_stats
26. sys.dm_exec_query_transformation_stats
27. sys.dm_exec_requests
28. sys.dm_exec_sessions
29. sys.dm_fts_active_catalogs
30. sys.dm_fts_index_population
31. sys.dm_fts_memory_buffers
32. sys.dm_fts_memory_pools
33. sys.dm_fts_population_ranges
34. sys.dm_io_backup_tapes
35. sys.dm_io_cluster_shared_drives
36. sys.dm_io_pending_io_requests
37. sys.dm_os_buffer_descriptors
38. sys.dm_os_child_instances
39. sys.dm_os_cluster_nodes
40. sys.dm_os_hosts
41. sys.dm_os_latch_stats
42. sys.dm_os_loaded_modules
43. sys.dm_os_memory_allocations
44. sys.dm_os_memory_cache_clock_hands
45. sys.dm_os_memory_cache_counters
46. sys.dm_os_memory_cache_entries
47. sys.dm_os_memory_cache_hash_tables
48. sys.dm_os_memory_clerks
49. sys.dm_os_memory_objects
50. sys.dm_os_memory_pools
51. sys.dm_os_performance_counters
52. sys.dm_os_ring_buffers
53. sys.dm_os_schedulers
54. sys.dm_os_stacks
55. sys.dm_os_sublatches
56. sys.dm_os_sys_info
57. sys.dm_os_tasks
58. sys.dm_os_threads
59. sys.dm_os_virtual_address_dump
60. sys.dm_os_wait_stats
61. sys.dm_os_waiting_tasks
62. sys.dm_os_worker_local_storage
63. sys.dm_os_workers
64. sys.dm_qn_subscriptions
65. sys.dm_repl_articles
66. sys.dm_repl_schemas
67. sys.dm_repl_tranhash
68. sys.dm_repl_traninfo
69. sys.dm_tran_active_snapshot_database_transactions
70. sys.dm_tran_active_transactions
71. sys.dm_tran_current_snapshot
72. sys.dm_tran_current_transaction
73. sys.dm_tran_database_transactions
74. sys.dm_tran_tran_locks
75. sys.dm_tran_session_transactions
76. sys.dm_tran_top_version_generators
77. sys.dm_tran_transactions_snapshot
78. sys.dm_tran_version_store

New DMV in SQL Server 2008
1. sys.dm_audit_actions
2. sys.dm_audit_class_type_map
3. sys.dm_cdc_errors
4. sys.dm_cdc_log_scan_sessions
5. sys.dm_cryptographic_provider_properties
6. sys.dm_database_encryption_keys
7. sys.dm_db_mirroring_auto_page_repair
8. sys.dm_db_mirroring_past_actions
9. sys.dm_db_persisted_sku_features
10. sys.dm_db_script_level
11. sys.dm_exec_procedure_stats
12. sys.dm_exec_trigger_stats
13. sys.dm_filestream_file_io_handles
14. sys.dm_filestream_file_io_requests
15. sys.dm_fts_fdhosts
16. sys.dm_fts_outstanding_batches
17. sys.dm_os_dispatcher_pools
18. sys.dm_os_dispatchers
19. sys.dm_os_memory_brokers
20. sys.dm_os_memory_node_access_stats
21. sys.dm_os_memory_nodes
22. sys.dm_os_nodes
23. sys.dm_os_process_memory
24. sys.dm_os_spinlock_stacks
25. sys.dm_os_sys_memory
26. sys.dm_resource_governor_configuration
27. sys.dm_resource_governor_resource_pools
28. sys.dm_resource_governor_workload_groups
29. sys.dm_server_audit_status
30. sys.dm_tran_commit_table
31. sys.dm_xe_map_values
32. sys.dm_xe_object_columns
33. sys.dm_xe_objects
34. sys.dm_xe_packages
35. sys.dm_xe_session_event_actions
36. sys.dm_xe_session_events
37. sys.dm_xe_session_object_columns
38. sys.dm_xe_session_targets
39. sys.dm_xe_sessions

I have my DTS package on my File System, so I am choosing Structured Storage File. If you have your DTS Package on the Database then you can choose the Source as SQL Server.

Then You have to choose the destination. In my case again I am using DTSX file as my destination.

Then you can choose the package and edit the destination package name.

Then you can specify the log file.

Then the Package Migration is completed.

1. Google’s advertizing model will start facing problems:
Google will have some problems with their advertizing model in the year 2009 and advertisers would be less interested in Google’s ads. Google’s ad should not be context based but rather be user based. Google should read the mind of the user and display the ad, exactly what he is looking for. There should be more localization in the Google’s ads. Now a day people are not so much interested in the Google’s ads, so either Google has to change its advertizing model or it will start facing problems.

2. Microsoft will inch ahead due to Google’s loss of reputation:
Year 2009 will be really bad for the Google. Google is acting as a spy and tracking all the data from cookies. Everybody will think twice before using Google. So the charm of Google is reducing day by day and it will slowly fall behind in the race against Microsoft.

3. Standards will evolve in the Clouds:
Till now everybody has defined cloud according to their way. But in the year 2009, some standards will evolve in the clouds and there will be SLAs .

4. Amazon will appear as the next big thing after Microsoft and Google:
Amazon has now everything and it will evolve as the next big thing after Microsoft and Google. Amazon’s Cloud will be the major success in the year 2009.

5. Virtual Societies will evolve on top of the social networking
Social networking sites will be a downward spiral. Virtual Societies will evolve on the top of the social networking on the year 2009. People will start making virtual societies around them with the same kind of interest and website promoting these virtual societies will become the major highlight for the year 2009.

6. Research will happen on Image Search and Video Search:
Till now we are having Image Search and Video Search only based on the text search associated with the Image and Video. But there would be research on Image Search and Video Search. Till now if the title of any videos is different then we could never get to the videos but if we have Video Search option available then this would be the milestone for stopping piracy on videos. So in the year 2009, big media companies will be sponsoring Universities to research on “Search based on Image and Video”.

7. Yahoo as a Company might be divided into several pieces.
Yahoo as a Company might be divided into several pieces and Google will buy some part of it and Microsoft will buy some part of it. Microsoft will likely buy the search part of the yahoo. Google will buy the messenger of yahoo and combine with their gtalk.

8. Google will buy Mozilla:
Due to and despite the modest success of the Chrome, Google will buy Mozilla to compete against the Internet Explorer.

9. Google App Engine will support Ruby
Till now Google App Engine only supports Python but in the year 2009, it will also support Ruby.

10. Java will evolve through dynamic languages but the SUN will be in crisis
Since Java is moving more towards the open source, Java will evolve through other dynamic languages but SUN will be in crisis.

• Enterprise Reporting Engine

There are two major infrastructure changes for Reporting Services. Reporting Services enhances the processing engine and rendering extensions to enable new functionality, such as Tablix support, and scalability as well as remove the dependency on IIS. Additionally, new report designer and configuration tool are provided that improve usability and workflow for RS customers.

• Analysis Services Time Series

This improvement adds a new time series forecasting algorithm (ARIMA: Auto Regressive Integrated Moving Average) to the data mining algorithm suite that provides more stable long term predictions.

In Data warehouses, spaces used to be always wasted due to the NULL values. Columns having lots of NULL value is actually allocating lots of space without storing any values. This problem has been taken care in SQL Server 2008 by the introduction of a sparse columns. This columns allows NULL values to be stored without taking any physical space on the disk.

T-SQL Improvements

Object Dependencies: The object dependencies improvement provides reliable discovery of dependencies between objects through newly introduced catalog view and dynamic management functions. Dependency information is always up-to-date for both schema-bound and non-schema-bound objects. Dependencies are tracked for stored procedures, tables, views, functions, triggers, user-defined types, XML schema-collections, and more.

Performance Data Collection
Collect data from various sources in SQL Server and OS to help with performance troubleshooting and server maintenance. With this improvement, organizations improve their analysis of common performance issues:

•  Define what data is collected and organize the collection into collection sets
•  Start/stop/manipulate collection sets programmatically (T-SQL and .NET API)
•  Define where data is stored (relational database)
•  View data through reports in SQL Server Management Studio.
•  Provide platform to plug in more data collectors in the future.

Extended Events

SQL Server Extended Events is a general event-handling system for server systems. The Extended Events infrastructure supports the correlation of data from SQL Server, and under certain conditions, the correlation of data from the operating system and database applications. In the latter case, Extended Events output must be directed to Event Tracing for Windows (ETW) in order to correlate the event data with operating system or application event data.

Database Mirroring Enhancements
SQL Server 2008 builds upon the momentum of SQL Server 2005 by providing a more reliable platform with enhanced database mirroring:

Automatic bad page repair – allows the principal and mirror machines to transparently recover from 823/824 types of data page errors by requesting a fresh copy of the corrupted page from the mirroring partner.

Log stream compression – compression of the outgoing log stream in order to minimize the network bandwidth used by database mirroring.

Miscellaneous performance enhancements:
using asynchronous log write requests on the mirror in order to shorten the log write time and thus speed-up the commit acknowledgement.

better utilization of the mirroring log send buffers in order to pack multiple smaller log blocks into a single network send.

Supportability and diagnosability improvements:
additional performance counters to allow for more granular accounting of the time spent across the different stages of the DBM log processing.

new DMVs and extensions of existing views in order to expose additional information about the mirroring sessions.

ORDPATH Improvement
ORDPATH improvement provides an important new functionality to our customers who use hierarchical data. It provides a superior way of modeling hierarchies in SQL Server by introducing the HierarchyID system data type and corresponding built-in methods which are designed to make it easier to store, query and operate hierarchical data. HierarchyID is also optimized for representing trees, the most common type of hierarchical data.

Large User-Defined Types Improvement
Large user-defined types allows users to expand the size of defined data types by eliminating the 8‑KB limit.

DATE/TIME Data Types
SQL Server 2008 introduces new date and time data types. The new data types enable applications to have separate date and time types, larger year ranges for date value, larger fractional seconds precision for time value, time-zone offset aware datetime type that containing date, time and time zone offset portion, user defined option on fractional seconds precision of time related types and datetime2 and datetimeoffset provide standards conformant semantics. Along with the T-SQL support on the new types, both native (ODBC, OLEDB) and managed (SqlClient) providers also provide the full support through the client driver APIs.

Improved XML Support
To leverages the new date and time types, SQL Server’s XML Schema collection now provides full support for the xs:date, xs:time and xs:dateTime data types. Support for union types is also enhanced by returning correct results for “instance of” queries when union types are involved, and adding support for lists of unions and unions of lists constructs in XML Schemas.

SSMS Improvement
SQL Server Management Studio(SSMS) has been improved a lot in SQL Server 2008. Most important improvement in SSMS 2008 are:

• Activity Monitor
• Object Explorer Details
• Object Search
• Multi-server Queries
• Intellisense added to the query Editor
• T-SQL Debugger Added to the Query Editor

Backup Database test
to disk='C:\test\test1.bak'
with compression

Plan Freezing

Data Compression

Hot-Add CPUs and Hot-Add Memory

So let’s discuss what is the cause behind this. SQL Server logins are stored in the master database and they are mapped against individual databases. The Login informations on SQL Server 2005 are visible through sys.server_principals system catalog view and the sys.logins view. The mapping information of the database user is stored in the sysusers system table. This table includes the name of the database user and the SID of the corresponding SQL Server Login. The SID is the security identifier and SID tracks the logins throughout the entire systems.

So when we move or copy our database from one server to another or from one instance to another then the windows login will have the same SID but the SQL logins may have the different SIDs. So when the SID of the new server instance and the older instance doesn’t matches we have a Orphaned User.

So if you are copying or moving a database from one server to another, then you should follow these steps:

1. Backup the source database.
2. Create the logins on the destination server.
3. Restore the database on the destination server.
4. Synchronize logins if not completed in step 2.

So for Synchronizing the logins, first you need to check all the users that are present.
Select 'user', * from sys.sysusers

Then check whether those users have logins or not by
Select 'Login', * from sys.server_principals

If there is orphaned user for user ‘dave’ then you should create the login with the same SID as its SID in the source server. This can be done by

Create login dave with Password = 'password', SID=0x8103F8ADEEADFA44BC4FE23836BCCE93


Another way of synchronizing the login can be done by system stored procedure.

Exec sp_change_users_login Report

This code will list out all the orphaned users and their corresponding SID.

Then after this you can do

Exec sp_change_users_login AUTO_FIX, 'lisa', 'password'

So the Auto_Fix will create a new login with the new SID and then match those with the User’s SID.

After this also you have more orphaned user then you can do

Exec sp_change_users_login 'update one', 'john', 'password'

But there is one major problem with using the stored procedure sp_change_users_login, when you restore the database again then the sp_change_users_login will be gone. So you would have to again do the whole process again. So sp_change_users_login is fine if you are moving database only once. If it is a repeatable transfer of a database from server to server then this sp_change_users_login is not useful.

Login Synchronization can be done through SSIS as well. SSIS also uses random SIDs at the destination and sp_change_users_login type to work to remap the users accounts to the newly generated SIDs.

Another way of Synchronization can be done through sp_help_revlogin. So we need to first download sp_help_revlogin from the Microsoft’s kb246133, then execute sp_help_revlogin on the source and copy the result. Then run the copied result in the destination server. So this will solve the orphaned users problem.

Solution:

So First I need to have the data flow task for this.

Then in the data flow the package would be like this:

Let us first add the flat file connection Manager, Excel Connection Manager, and Oledb Connection Manager.

In the flat file Source add the Flat file connection Manager.

In the Excel Source add the Excel Source connection Manager.

Since the data in Excel is in Unicode format so it should be converted into string format using Data Conversion Transformation.

Before the data is merged, it should be sorted. So lets sort the Flat file Source and converted data of Excel by First Name and Last Name.

Then after Sorting the data, it should be merged.

Then after merging the data, the first name column should be changed to uppercase. So the Character Map Transformation should be used.

After changing the data into uppercase, we have to add a new Salary column which could show the raise in the salary. So the derived column transformation has to be used which will calulate the 20% increase in salary.

Then finally the OLEDB destination is added where all the data is dumped. In this OLEDB Destination the OLEDB Connection manager is added and the desired table is selected and mapped.

This is the common thing you hear while you are working as a DBA. The reason for this is not always evident. Perhaps the number of transactions issued has increased or maybe the volume of the data has increased. But sometimes this might not be the cause of the problem. The problem might be due to disorganization of the database. Database disorganization occurs when a database’s logical and physical storage allocation contains many scattered areas of storage that are too small, not physically contiguous, or too disorganized to be used.

Database disorganization or fragmentation can occur when modifying data with INSERT, UPDATE, or DELETE statements, which over time cause gaps in each page. If a query search is based on a table scan or partial table scan, then it will create overhead for the SQL Server process with additional page reads, leading to high CPU activity and unresponsiveness.

To minimize fragmentation, database objects must be restructured on a regular basis.

Some of the steps that you need to perform for database reorganization is

• Take the object level backups using BCP, Import/Export Wizard. If the database has constraints disable them.
• Truncate the table.
• Import the data back to the table.
• Enable the constraints if you had disabled them.

Database reorganization is an offline process. So you should be aware of the downtime and do this only in off-peak hours. If the database is mission critical and no downtime is accepted then the split mirror backups can be used by completely using different set of disk. Then the database reorganization can be done on the database and replace the disk back again.

In the inbound location, I have to create a directory which would be like “DealerSales and Current Date” and then download files from the remote location to that directory. Then I have to move the files from there to the working directory. Then I have to unzip the zip files and load the text files to the database and delete the text files from the working directory and move the zip from the working directory to the Archive folder. The directory’s date format should be in MMDDYYYY format.

Solution:

There could be a different approach to make the SSIS Package. One of the easier way to make the Package for this type of scenario could be like this:

1. Let’s first have the File System Task which will create a directory like “DealerSales12052008″ inside download directory, if it doesn’t exist.
2. Then let’s have the FTP Task which will download files from remote location to that folder.
3. Then let’s have the File System Task which will create a directory like “DealerSales12052008″ inside the working directory, if it doesn’t exist.
4. Then let’s have the For Each Loop Container and File System task which will move files from download directory to the working directory.
5. Then let’s have the For Each Loop Container and Execute Process Task which will unzip the Zip files.
6. Then let’s have the For Each Loop Container and Data Flow Task which will load all the text files into the SQL Server database.
7. Then let’s have the File System Task which will create a directory like “DealerSales12052008″ inside the Archive Directory.
8. Then let’s have the For Each Loop Container and File System Task which will move the zip files to the Archive Directory.
9. Then let’s have the For Each Loop Container and File System Task which will delete the text files from the working directory.
10. Then let’s have a File System tasks which will clean up our download directory and working directory.

So now let’s begin by making the skeleton of the package by dragging the task and which would look like this:

First of all lets make download, Archive, Workdir Directories inside the C:\SSIS folder. In the download directory we will download the files from remote location. Workdir is our working directory where we will copy the files from download directory. When the datas are inserted into the tables, then we will move the zip files to the Archive directory.

Now let’s feed our tasks. Let’s start by creating variables first.

Let’s create a Package level Variable called dname01 with String datatype and Value as C:\SSIS\download.

Let’s create another Package level Variable called dname02 with string datatype. Let’s make its EvaluateAsExpression True and on Expression let’s write as:

Now let’s create another Package level Variable dname03 of String Datatype. Let’s make its EvaluateAsExpression True with Expression as

Now let’s configure the File System task as:

Now we have created the directory called “DealerSales12052008″ inside the download directory. Now we are downloading the files inside this directory from the remote location using FTP task. In our Remote Location we have Some ZIP files starting with the name of DealerSales. So we can configure our FTP task as:

Now the zip files are already downloaded on the download directory. So now we have to move those files into working directory. So first of all we have to create a directory DealerSales12052008 inside the working directory. So lets create a package level variable dname04 with string datatype and expression as:

Then let’s configure the file system task as:

Now we have created the directory inside the working directory. So let’s move the files from download directory to the working directory by configuring the For Each Loop Container and File System task inside it.

Now let’s create a Package level variable fname01 of String datatype and Value any string like “dummy”.

Let’s configure For Each Loop Container as:

Now let’s configure the File System task as:

Now the files are inside the working directory so now we have to unzip all the files inside the directory. So now let’s create a Container level variable name01 of String datatype.

Now let’s configure the For each loop Container as:

Now let’s configure the Execute Process task as:

Now we have unzipped the files. So now we have to load those text files into the SQL server Database.

So let’s create a package level variable bname01 of string datatype with expression as:

Now let’s configure the For Each Loop Container for loading data into SQL Server as:

Now let’s configure the data Flow task as

Now the data is loaded from text file to the SQL Server. So now let’s create a folder in the Archive directory. For that we have to create a package level Variable dname05 of string datatype with expression as

Now we have to configure the File System Task for creating the folder inside Archive directory as:

Now we have to move those zip files into Archive directory. So lets create a Container level variable aname01 of string datatype with some string value like “dummy”.

Then we have to configure the for each loop container for moving zip files to Archive directory as

And we have to configure the file system task inside the Archive For Each Loop Container as

Now we have to delete the text files that have been extracted and loaded into SQL Server.

For that we have to create a Container Level variable tname01 of string datatype and some string value as “dummy”. Then we have to configure the for each loop container for deleting the text file as

Similarly we have to configure the file system task inside the Delete Text file for each loop container as:

So finally we have to configure our File System task to delete the contents from the download directory and the working directory as:

The relational database is the dominent database till now. When Object Oriented Database came into market. Everybody at that time expected that Object Oriented Database was the evolutionary step in the database and it would replace all the relational databases. But it never happened. The main thing we should note is that although Object Oriented Programming language is so popular, the Object Oriented Database failed. If we look closely for the failure of OODBMS’s against traditional RDBMS then its due to the lack of interoperability with a great number of features and tools that we use with SQL like reporting tools, OLAP tools, backups and recovery standards. Moreover OODBMS had weakness on query support due to the lacking of formal mathematical foundation.

Now the google’s Bigtable and Apache Hadoop seems promising threat to relational database. Although big giants like Google and Yahoo had successfully implemented these distributed databases, it has lots of flaws.

Major Flaw of these distributed database is it does not support transactional systems and they are vendor dependent and not Portable. If your data is in Google’s BigTable, you can’t pull it out. No big enterprise company wants to have their data elsewhere but they want everything on their own hardware.

The relational database has its own beauty. Multiple applications work on the common database and uses tools like Reporting Services, OLAP, Integration Services. It would be quite difficult to replace the relational database.

The performance and high availability provided by BigTable and Hadoop had given very good opportunities for the Developers to choose between Relational Databases and Distributed Databases. It is on the grave of future that whether distributed databases will become more mature and popular or it will fail against traditional relational databases.