- SQL Server Reference Guide
- Introduction
- SQL Server Reference Guide Overview
- Table of Contents
- Microsoft SQL Server Defined
- SQL Server Editions
- SQL Server Access
- Informit Articles and Sample Chapters
- Online Resources
- Microsoft SQL Server Features
- SQL Server Books Online
- Clustering Services
- Data Transformation Services (DTS) Overview
- Replication Services
- Database Mirroring
- Natural Language Processing (NLP)
- Analysis Services
- Microsot SQL Server Reporting Services
- XML Overview
- Notification Services for the DBA
- Full-Text Search
- SQL Server 2005 - Service Broker
- Using SQL Server as a Web Service
- SQL Server Encryption Options Overview
- SQL Server 2008 Overview
- SQL Server 2008 R2 Overview
- SQL Azure
- The Utility Control Point and Data Application Component, Part 1
- The Utility Control Point and Data Application Component, Part 2
- Microsoft SQL Server Administration
- The DBA Survival Guide: The 10 Minute SQL Server Overview
- Preparing (or Tuning) a Windows System for SQL Server, Part 1
- Preparing (or Tuning) a Windows System for SQL Server, Part 2
- Installing SQL Server
- Upgrading SQL Server
- SQL Server 2000 Management Tools
- SQL Server 2005 Management Tools
- SQL Server 2008 Management Tools
- SQL Azure Tools
- Automating Tasks with SQL Server Agent
- Run Operating System Commands in SQL Agent using PowerShell
- Automating Tasks Without SQL Server Agent
- Storage – SQL Server I/O
- Service Packs, Hotfixes and Cumulative Upgrades
- Tracking SQL Server Information with Error and Event Logs
- Change Management
- SQL Server Metadata, Part One
- SQL Server Meta-Data, Part Two
- Monitoring - SQL Server 2005 Dynamic Views and Functions
- Monitoring - Performance Monitor
- Unattended Performance Monitoring for SQL Server
- Monitoring - User-Defined Performance Counters
- Monitoring: SQL Server Activity Monitor
- SQL Server Instances
- DBCC Commands
- SQL Server and Mail
- Database Maintenance Checklist
- The Maintenance Wizard: SQL Server 2000 and Earlier
- The Maintenance Wizard: SQL Server 2005 (SP2) and Later
- The Web Assistant Wizard
- Creating Web Pages from SQL Server
- SQL Server Security
- Securing the SQL Server Platform, Part 1
- Securing the SQL Server Platform, Part 2
- SQL Server Security: Users and other Principals
- SQL Server Security – Roles
- SQL Server Security: Objects (Securables)
- Security: Using the Command Line
- SQL Server Security - Encrypting Connections
- SQL Server Security: Encrypting Data
- SQL Server Security Audit
- High Availability - SQL Server Clustering
- SQL Server Configuration, Part 1
- SQL Server Configuration, Part 2
- Database Configuration Options
- 32- vs 64-bit Computing for SQL Server
- SQL Server and Memory
- Performance Tuning: Introduction to Indexes
- Statistical Indexes
- Backup and Recovery
- Backup and Recovery Examples, Part One
- Backup and Recovery Examples, Part Two: Transferring Databases to Another System (Even Without Backups)
- SQL Profiler - Reverse Engineering An Application
- SQL Trace
- SQL Server Alerts
- Files and Filegroups
- Partitioning
- Full-Text Indexes
- Read-Only Data
- SQL Server Locks
- Monitoring Locking and Deadlocking
- Controlling Locks in SQL Server
- SQL Server Policy-Based Management, Part One
- SQL Server Policy-Based Management, Part Two
- SQL Server Policy-Based Management, Part Three
- Microsoft SQL Server Programming
- An Outline for Development
- Database
- Database Services
- Database Objects: Databases
- Database Objects: Tables
- Database Objects: Table Relationships
- Database Objects: Keys
- Database Objects: Constraints
- Database Objects: Data Types
- Database Objects: Views
- Database Objects: Stored Procedures
- Database Objects: Indexes
- Database Objects: User Defined Functions
- Database Objects: Triggers
- Database Design: Requirements, Entities, and Attributes
- Business Process Model Notation (BPMN) and the Data Professional
- Business Questions for Database Design, Part One
- Business Questions for Database Design, Part Two
- Database Design: Finalizing Requirements and Defining Relationships
- Database Design: Creating an Entity Relationship Diagram
- Database Design: The Logical ERD
- Database Design: Adjusting The Model
- Database Design: Normalizing the Model
- Creating The Physical Model
- Database Design: Changing Attributes to Columns
- Database Design: Creating The Physical Database
- Database Design Example: Curriculum Vitae
- NULLs
- The SQL Server Sample Databases
- The SQL Server Sample Databases: pubs
- The SQL Server Sample Databases: NorthWind
- The SQL Server Sample Databases: AdventureWorks
- The SQL Server Sample Databases: Adventureworks Derivatives
- UniversalDB: The Demo and Testing Database, Part 1
- UniversalDB: The Demo and Testing Database, Part 2
- UniversalDB: The Demo and Testing Database, Part 3
- UniversalDB: The Demo and Testing Database, Part 4
- Getting Started with Transact-SQL
- Transact-SQL: Data Definition Language (DDL) Basics
- Transact-SQL: Limiting Results
- Transact-SQL: More Operators
- Transact-SQL: Ordering and Aggregating Data
- Transact-SQL: Subqueries
- Transact-SQL: Joins
- Transact-SQL: Complex Joins - Building a View with Multiple JOINs
- Transact-SQL: Inserts, Updates, and Deletes
- An Introduction to the CLR in SQL Server 2005
- Design Elements Part 1: Programming Flow Overview, Code Format and Commenting your Code
- Design Elements Part 2: Controlling SQL's Scope
- Design Elements Part 3: Error Handling
- Design Elements Part 4: Variables
- Design Elements Part 5: Where Does The Code Live?
- Design Elements Part 6: Math Operators and Functions
- Design Elements Part 7: Statistical Functions
- Design Elements Part 8: Summarization Statistical Algorithms
- Design Elements Part 9:Representing Data with Statistical Algorithms
- Design Elements Part 10: Interpreting the Data—Regression
- Design Elements Part 11: String Manipulation
- Design Elements Part 12: Loops
- Design Elements Part 13: Recursion
- Design Elements Part 14: Arrays
- Design Elements Part 15: Event-Driven Programming Vs. Scheduled Processes
- Design Elements Part 16: Event-Driven Programming
- Design Elements Part 17: Program Flow
- Forming Queries Part 1: Design
- Forming Queries Part 2: Query Basics
- Forming Queries Part 3: Query Optimization
- Forming Queries Part 4: SET Options
- Forming Queries Part 5: Table Optimization Hints
- Using SQL Server Templates
- Transact-SQL Unit Testing
- Index Tuning Wizard
- Unicode and SQL Server
- SQL Server Development Tools
- The SQL Server Transact-SQL Debugger
- The Transact-SQL Debugger, Part 2
- Basic Troubleshooting for Transact-SQL Code
- An Introduction to Spatial Data in SQL Server 2008
- Performance Tuning
- Performance Tuning SQL Server: Tools and Processes
- Performance Tuning SQL Server: Tools Overview
- Creating a Performance Tuning Audit - Defining Components
- Creating a Performance Tuning Audit - Evaluation Part One
- Creating a Performance Tuning Audit - Evaluation Part Two
- Creating a Performance Tuning Audit - Interpretation
- Creating a Performance Tuning Audit - Developing an Action Plan
- Understanding SQL Server Query Plans
- Performance Tuning: Implementing Indexes
- Performance Monitoring Tools: Windows 2008 (and Higher) Server Utilities, Part 1
- Performance Monitoring Tools: Windows 2008 (and Higher) Server Utilities, Part 2
- Performance Monitoring Tools: Windows System Monitor
- Performance Monitoring Tools: Logging with System Monitor
- Performance Monitoring Tools: User Defined Counters
- General Transact-SQL (T-SQL) Performance Tuning, Part 1
- General Transact-SQL (T-SQL) Performance Tuning, Part 2
- General Transact-SQL (T-SQL) Performance Tuning, Part 3
- Performance Monitoring Tools: An Introduction to SQL Profiler
- Performance Tuning: Introduction to Indexes
- Performance Monitoring Tools: SQL Server 2000 Index Tuning Wizard
- Performance Monitoring Tools: SQL Server 2005 Database Tuning Advisor
- Performance Monitoring Tools: SQL Server Management Studio Reports
- Performance Monitoring Tools: SQL Server 2008 Activity Monitor
- The SQL Server 2008 Management Data Warehouse and Data Collector
- Performance Monitoring Tools: Evaluating Wait States with PowerShell and Excel
- Practical Applications
- Choosing the Back End
- The DBA's Toolbox, Part 1
- The DBA's Toolbox, Part 2
- Scripting Solutions for SQL Server
- Building a SQL Server Lab
- Using Graphics Files with SQL Server
- Enterprise Resource Planning
- Customer Relationship Management (CRM)
- Building a Reporting Data Server
- Building a Database Documenter, Part 1
- Building a Database Documenter, Part 2
- Data Management Objects
- Data Management Objects: The Server Object
- Data Management Objects: Server Object Methods
- Data Management Objects: Collections and the Database Object
- Data Management Objects: Database Information
- Data Management Objects: Database Control
- Data Management Objects: Database Maintenance
- Data Management Objects: Logging the Process
- Data Management Objects: Running SQL Statements
- Data Management Objects: Multiple Row Returns
- Data Management Objects: Other Database Objects
- Data Management Objects: Security
- Data Management Objects: Scripting
- Powershell and SQL Server - Overview
- PowerShell and SQL Server - Objects and Providers
- Powershell and SQL Server - A Script Framework
- Powershell and SQL Server - Logging the Process
- Powershell and SQL Server - Reading a Control File
- Powershell and SQL Server - SQL Server Access
- Powershell and SQL Server - Web Pages from a SQL Query
- Powershell and SQL Server - Scrubbing the Event Logs
- SQL Server 2008 PowerShell Provider
- SQL Server I/O: Importing and Exporting Data
- SQL Server I/O: XML in Database Terms
- SQL Server I/O: Creating XML Output
- SQL Server I/O: Reading XML Documents
- SQL Server I/O: Using XML Control Mechanisms
- SQL Server I/O: Creating Hierarchies
- SQL Server I/O: Using HTTP with SQL Server XML
- SQL Server I/O: Using HTTP with SQL Server XML Templates
- SQL Server I/O: Remote Queries
- SQL Server I/O: Working with Text Files
- Using Microsoft SQL Server on Handheld Devices
- Front-Ends 101: Microsoft Access
- Comparing Two SQL Server Databases
- English Query - Part 1
- English Query - Part 2
- English Query - Part 3
- English Query - Part 4
- English Query - Part 5
- RSS Feeds from SQL Server
- Using SQL Server Agent to Monitor Backups
- Reporting Services - Creating a Maintenance Report
- SQL Server Chargeback Strategies, Part 1
- SQL Server Chargeback Strategies, Part 2
- SQL Server Replication Example
- Creating a Master Agent and Alert Server
- The SQL Server Central Management System: Definition
- The SQL Server Central Management System: Base Tables
- The SQL Server Central Management System: Execution of Server Information (Part 1)
- The SQL Server Central Management System: Execution of Server Information (Part 2)
- The SQL Server Central Management System: Collecting Performance Metrics
- The SQL Server Central Management System: Centralizing Agent Jobs, Events and Scripts
- The SQL Server Central Management System: Reporting the Data and Project Summary
- Time Tracking for SQL Server Operations
- Migrating Departmental Data Stores to SQL Server
- Migrating Departmental Data Stores to SQL Server: Model the System
- Migrating Departmental Data Stores to SQL Server: Model the System, Continued
- Migrating Departmental Data Stores to SQL Server: Decide on the Destination
- Migrating Departmental Data Stores to SQL Server: Design the ETL
- Migrating Departmental Data Stores to SQL Server: Design the ETL, Continued
- Migrating Departmental Data Stores to SQL Server: Attach the Front End, Test, and Monitor
- Tracking SQL Server Timed Events, Part 1
- Tracking SQL Server Timed Events, Part 2
- Patterns and Practices for the Data Professional
- Managing Vendor Databases
- Consolidation Options
- Connecting to a SQL Azure Database from Microsoft Access
- SharePoint 2007 and SQL Server, Part One
- SharePoint 2007 and SQL Server, Part Two
- SharePoint 2007 and SQL Server, Part Three
- Querying Multiple Data Sources from a Single Location (Distributed Queries)
- Importing and Exporting Data for SQL Azure
- Working on Distributed Teams
- Professional Development
- Becoming a DBA
- Certification
- DBA Levels
- Becoming a Data Professional
- SQL Server Professional Development Plan, Part 1
- SQL Server Professional Development Plan, Part 2
- SQL Server Professional Development Plan, Part 3
- Evaluating Technical Options
- System Sizing
- Creating a Disaster Recovery Plan
- Anatomy of a Disaster (Response Plan)
- Database Troubleshooting
- Conducting an Effective Code Review
- Developing an Exit Strategy
- Data Retention Strategy
- Keeping Your DBA/Developer Job in Troubled Times
- The SQL Server Runbook
- Creating and Maintaining a SQL Server Configuration History, Part 1
- Creating and Maintaining a SQL Server Configuration History, Part 2
- Creating an Application Profile, Part 1
- Creating an Application Profile, Part 2
- How to Attend a Technical Conference
- Tips for Maximizing Your IT Budget This Year
- The Importance of Blue-Sky Planning
- Application Architecture Assessments
- Transact-SQL Code Reviews, Part One
- Transact-SQL Code Reviews, Part Two
- Cloud Computing (Distributed Computing) Paradigms
- NoSQL for the SQL Server Professional, Part One
- NoSQL for the SQL Server Professional, Part Two
- Object-Role Modeling (ORM) for the Database Professional
- Business Intelligence
- BI Explained
- Developing a Data Dictionary
- BI Security
- Gathering BI Requirements
- Source System Extracts and Transforms
- ETL Mechanisms
- Business Intelligence Landscapes
- Business Intelligence Layouts and the Build or Buy Decision
- A Single Version of the Truth
- The Operational Data Store (ODS)
- Data Marts – Combining and Transforming Data
- Designing Data Elements
- The Enterprise Data Warehouse — Aggregations and the Star Schema
- On-Line Analytical Processing (OLAP)
- Data Mining
- Key Performance Indicators
- BI Presentation - Client Tools
- BI Presentation - Portals
- Implementing ETL - Introduction to SQL Server 2005 Integration Services
- Building a Business Intelligence Solution, Part 1
- Building a Business Intelligence Solution, Part 2
- Building a Business Intelligence Solution, Part 3
- Tips and Troubleshooting
- SQL Server and Microsoft Excel Integration
- Tips for the SQL Server Tools: SQL Server 2000
- Tips for the SQL Server Tools – SQL Server 2005
- Transaction Log Troubles
- SQL Server Connection Problems
- Orphaned Database Users
- Additional Resources
- Tools and Downloads
- Utilities (Free)
- Tool Review (Free): DBDesignerFork
- Aqua Data Studio
- Microsoft SQL Server Best Practices Analyzer
- Utilities (Cost)
- Quest Software's TOAD for SQL Server
- Quest Software's Spotlight on SQL Server
- SQL Server on Microsoft's Virtual PC
- Red Gate SQL Bundle
- Microsoft's Visio for Database Folks
- Quest Capacity Manager
- SQL Server Help
- Visual Studio Team Edition for Database Professionals
- Microsoft Assessment and Planning Solution Accelerator
- Aggregating Server Data from the MAPS Tool
Most DBAs are looking for a way to locate the installations of SQL Server in their organization. They need to find and document all of these servers, including the versions, the editions, the amount of CPU’s on the system, the amount of RAM and so on.
In the past, I’ve used three methods to do this:
- Build my own
- Use Microsoft’s MOM (Now System Center Operations Manager, or SCOM)
- Use a third-party product like Spotlight on SQL Server from Quest
All of these work, and in fact I’ve switched in and out between them. And sometimes I’ve even used a couple of them in tandem, because one solution might not have all of the information I need.
Each of these solutions offers advantages and disadvantages. Building my own system provided the most flexibility, and not counting my development time, the least cost. But it also is very proprietary, and unless I spent time documenting it well was not continued beyond my tenure as the company DBA.
Using SCOM (what Microsoft Operations Manager became) is a great solution, especially when you can “stack” the database in with other components such as network equipment and Windows Servers to see an entire line of business application. But it is not as comprehensive in its monitoring and control of the SQL Server system, especially when you factor in the new features in SQL Server 2008 like Policy Based Management and the Management Data Warehouse. I have no doubt that the System Center product will eventually “know” about these features, but as of this writing, it does not. And of course there is a cost to buy the product, and the time spent learning and implementing it, in addition to the hardware needed to run it.
I have used (and written about) other products that monitor SQL Server, such as Spotlight on SQL Server, from Quest. These are also great solutions, but they also do not know about the new features in SQL Server 2008, they have a relatively high cost, and they require hardware to run and time to learn.
So which route do I take now? Well, there are considerations, of course. Perhaps my firm already has System Center for other purposes, or perhaps the DBA team is already familiar with another third party product. In those cases, the decision is pretty simple — go with what you have, or go with what you know, and supplement with the tools and features in the product.
But if you’re like me, you might not have any budget right now, and only an anemic machine in the corner to run your system. And... I have a few more requirements than just performance data. I want a system that does it all, from one location.
So what I’m going to do is use the data I collected in that MAPS tool evaluation I wrote about some time ago. You can read that entire article here, but the upshot is that the Microsoft Assessment and Planning Solution Accelerator (MAPS) is a free tool from Microsoft that will run across a series of IP addresses, lists of servers, or even an Active Directory OU to find systems that have SQL Server installed — from version 2000 and higher. It then creates these awesome reports that show all that data, from the version and edition installed all the way down to the CPU and memory installed on the Instance.
So I thought I would try and leverage that data. I’ll run the MAPS tool on my network, and find the Instances of SQL Server I have installed. I would like to store all that data in a single location, so I decided to do some research to find out where all that data comes from, and where it ends up.
The Investigation
Before I begin, it’s important to note that I’m going after data that was generated by a specific version of a tool that is not a Microsoft SQL Server product. The point is that if I develop a procedure or process based on that tool, it might break someday if that tool ever changes. And of course it will change.
So the most important thing to know about the process I’m describing is the version of the MAPS tool. The version I used to inventory my SQL Server systems is: 3.2.2315.0. That’s important because of some decisions I’ll make along the way.
The main decision I have is where to get my data from. In the article I wrote on this tool earlier, you’ll see that the tool produces two reports when it is run for a SQL Server inventory, one in Microsoft Word and the other in Microsoft Excel.
The first approach I thought about what extracting the data from the Excel spreadsheet. I considered the Word document; but it only shows things like the number of versions and some other high-level data. Great for reporting what we have installed to the boss, but not as useful for the kind of detailed data I am after.
As I reviewed the Excel spreadsheet the tool makes, I found that it contains a lot of useful information, including:
- SQL Server Component Name
- Number of instances
- Computer Name
- SQL Server Instance Name
- SQL Server Product Name
- SQL Server Version Number
- SQL Server Service Pack
- SQL Server Edition
- Clustered?
- Language
- Machine Type
- SQL Server Sub-Directory
- SQL Service State
- SQL Service Start Mode
- Current Operating System
- Operating System Service Pack Level
- Operating System Architecture Type
- Number of Processors
- Number of Cores
- Number of Logical Processors CPU
- System Memory (MB)
- Logical Disk Drive Name
- Logical Disk Size (GB)
- Logical Disk Free Space (GB)
That’s quite a lot of information about a system, and I have a lot of choices about how to get the data. I can store the Excel files after each evaluation on my “Central Management Server” and then run a query from SQL Server to attach directly to the spreadsheet, I can import the data from the spreadsheet using SQL Server Integration Services, or I can export the data to a flat-text file in Excel and then import the data with BCP. I can even use PowerShell to open the spreadsheet, open SQL Server, and transfer the data that way.
But I began to wonder about the fact that the MAPS tool installs SQL Server Express edition when it runs. Perhaps that’s where the data is stored for all those spreadsheets and Word documents.
And in fact it is. I opened the SQL Server Configuration Management tool on my MAPS system, and there was the name of the Instance — MAPS. So I connected to that database using SQL Server Management Studio (SSMS) and began to explore. I found the name of the database I installed when I set up the MAPS product, and began to explore the relationships in the tables there.
I normally always start with the views on a system when I want to look at the data it contains. I don’t normally use the stored procedures, since they are code and technically belong to the vendor, and many times they not only return data, but insert, delete or update data as well. I want to ensure that I’m in a “read only” mode.
The views I found in this database didn’t help me all that much. In fact, many of them returned no data at all. That makes sense, since the MAPS tool has the ability to evaluate everything from Microsoft Office to Vista and even Virtualization.
So that left me with the tables. What I did to evaluate them was to use the Database Diagram feature in SQL Server 2008 to pull in all of the tables into a diagram, and that showed me the links that the Primary and Foreign keys had. I then did a SELECT from each table with a TOP 10 limit to see which ones had data.
Armed with that knowledge, I began to pull out the data that I wanted to see.
The Tables
What I found in my discoveries was that there was one main table that seems to store all of the data the other primary tables link to. I also found that some of the columns contained pointers to other data using a numeric system, so I excluded that data for the time being. For instance, in the table that shows the installed software on the machine, there’s a column called install_state, which is numeric. I don’t know what those mean, so I did not include them.
But what I was left with was a rich selection of data — very useful for my monitoring solution, so that I can find out things like service pack numbers, CPU counts and so on. I can even find information about drive space, although it isn’t always easy to find out the unit the space is stored in.
The way I documented this information was in a grid, showing the table name, the information I found that it stored, and how it was linked to other tables. Here is that grid, and then in the section that follows I’ll show you a few of the queries I used to get the information I wanted as an example. I won’t show all columns, since some of them were empty, and others had those numeric or code references. If you’re interested in doing the same thing, you can install the MAPS tool and then perform an inventory on your own systems. Then you can explore more of these columns.
Table Name |
Columns |
Data it Shows |
Related Table(s) |
Key |
Devices |
device_number ad_dns_host_name ad_domain_name ad_fully_qualified_domain_name bios_manufacturer bios_name bios_release_date bios_serial_number bios_version boot_device boot_rom_supported build_number computer_system_name csd_version current_language dns_host_name free_physical_memory free_virtual_memory last_bootup_time local_datetime model number_of_processors number_of_users operating_system operating_system_service_pack organization os_architecture os_caption os_install_date os_manufacturer roles service_pack_major_version service_pack_minor_version smbios_asset_tag system_device system_directory system_drive total_physical_memory workgroup |
This is the main table, and it shows multiple items such as the |
sql_assessments physical_memory processors disk_drives logical disks disk_partitions services services_details |
device_number |
sql_assessments |
device_number clustered create_datetime dns_host_name instanceid iswow64 language servicename skuname splevel sqlservicetype version |
Shows SQL Server specific information |
devices |
device_number |
physical_memory |
device_number capacity create_datetime data_width device_locator speed tag total_width |
Memory Chips installed in the system |
devices |
device_number |
processors |
device_number address_width create_datetime current_clock_speed data_width description device_id l2_cache_size l2_cache_speed l3_cache_size l3_cache_speed manufacturer max_clock_speed name number_of_cores number_of_logical_processors processor_id revision version |
Processor hardware information |
devices |
device_number |
disk_drives |
device_number bytes_per_sector capability_descriptions caption compression_method create_datetime default_block_size description device_id interface_type manufacturer media_loaded media_type model name partitions pnp_device_id scsi_bus scsi_logical_unit scsi_port scsi_target_id sectors_per_track signature size total_cylinders total_heads total_sectors total_tracks tracks_per_cylinder |
Physical disk drive information |
devices |
device_number |
logical disks |
device_number caption compressed create_datetime description device_id file_system free_space name quotas_disabled quotas_incomplete quotas_rebuilding size supports_disk_quotas supports_file_based_compression volume_name volume_serial_number |
Logical Disk Drives information |
devices |
device_number |
services |
device_number caption create_datetime description desktop_interact display_name name path_name start_mode start_name started state |
The Windows Services that are installed and their states. |
devices |
device_number |
products |
device_number caption create_datetime description install_date install_location name vendor version |
Major software packages installed on this system. |
devices |
device_number |
Sample Queries
Right now I’m leaving the data in the MAPS tables, and just using these queries when I need them. In the future, I’ll pull the data out and store it in my own tables, and then refresh the data in my “Central Management Server” from time to time for the data space, drive space and so on. In fact, I’ll probably just use the Management Data Warehouse feature for that data.
But in any case, these queries are examples of what I can get out of this database — very handy! There is much more here, of course, but this will demonstrate a little of what you can find out.
/* SQL Server Instance Information */ SELECT DISTINCT device_number , [clustered] , create_datetime , dns_host_name , instanceid , iswow64 , [language] , servicename , skuname , splevel , CASE sqlservicetype WHEN 1 THEN 'Engine' WHEN 2 THEN 'Agent' WHEN 3 THEN 'FTS' WHEN 4 THEN 'SSIS' WHEN 5 THEN 'SSAS' WHEN 6 THEN 'SSRS' WHEN 7 THEN 'SQLBrowser' END , version FROM sql_assessments ORDER BY dns_host_name /* Show SQL Servers by 64 or 32 bit, by OS installed 32 or 64 bit */ SELECT DISTINCT a.instanceid , skuname , b.os_architecture FROM sql_assessments a INNER JOIN devices b ON a.device_number = b.device_number ORDER BY instanceid /* Show other software installed on a SQL Server */ SELECT DISTINCT b.dns_host_name ,a.name ,a.vendor ,a.version FROM products a INNER JOIN sql_assessments b ON a.device_number = b.device_number ORDER BY a.name
InformIT Articles and Sample Chapters
Rich Schiesser has a great tutorial on inventorying your hardware in the (now defunct) InformIT IT Management Reference Guide. You can find the full installment still online with this direct link, however.
Books and eBooks
Rich Schieser also wrote IT Systems Management: Designing, Implementing, and Managing World-Class Infrastructures, from which you can find an excerpt on software inventories in the aforementioned InformIT IT Management Reference Guide.
Online Resources
The MAPS software is a free download from here: http://technet.microsoft.com/en-us/library/bb977556.aspx.