https://msdn.microsoft.com/en-us/library/hh231691(SQL.110).aspx

enjoy

These warning can be retreive after you have deployed your cube on the Analysis Services Server.

here is a sample script to retreive these warning :

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.AnalysisServices")
$serverAS = New-Object Microsoft.AnalysisServices.Server
$serverAS.connect("ServerName")
$db = $serverAS.databases["DatabaseName"]

$val = new-object Microsoft.AnalysisServices.ValidationResultCollection

foreach ($dim in $db.dimensions)
{
 write-host "Validation dimension : ", $dim.name
 $dim.validate($val, 4)
}

foreach ($cube in $db.cubes)
 {
  write-host "validation cube : ", $cube.name
 $cube.validate($val, 4)
 foreach ($mg in $cube.measuregroups)
  {
   write-host "validation measuregroup : ", $mg.name
   $mg.validate($val, 4)
   foreach ($partition in $mg.partitions)
    {
     write-host "validation partition : ", $partition.name
     $partition.validate($val, 4)
    }
  }
 }

$val | select source, sourcePath, sourceTYpe, description

 Enjoy !

this script is very simple, you just have to connect to you database and call the updatestatistics() method for all your tables :

[System.Reflection.Assembly]::LoadWithPartialName('Microsoft.SqlServer.SMO') | out-null

 $s = new-object ('Microsoft.sqlserver.Management.smo.server') myServer\myInstance

 $db = $s.databases["myDB"]

 foreach ($t in $db.tables)
 {
       write-host "Update stat"  $t.name
       $t.updatestatistics("all", "fullscan")
 }

the first parameter is a statistics Target, possible value are described here : https://msdn.microsoft.com/fr-fr/library/microsoft.sqlserver.management.smo.statisticstarget.aspx

the second parameter is a Statistics scan type, possible value are describe here : https://msdn.microsoft.com/fr-fr/library/microsoft.sqlserver.management.smo.statisticsscantype.aspx

If you want to update your statistics with giving a sample and not a full scan, the script become :

[System.Reflection.Assembly]::LoadWithPartialName('Microsoft.SqlServer.SMO') | out-null

$s = new-object ('Microsoft.sqlserver.Management.smo.server') myServer\myInstance

$db = $s.databases["myDB"]

$sample = 50

foreach ($t in $db.tables)
{
    write-host "Update stat" $t.name
    $t.updatestatistics("all", "percent", $sample)
}

Enjoy...

The goal of this post is to rebuild fragmented index with power shell.

To achieve that we need to use the invoke-sqlcmd cmdlet.

try to use this command, if it doesn't work, be sure to have all the system module loaded, if not, run the importSystemModules cmdlet.

the query that we are going to use to know if indexes are fragmented or not is :

Select   i.name as index_name, 
         object_name(s.object_id) as table_name,
         s.avg_fragmentation_in_percent, 
         s.page_count
from     sys.dm_db_index_physical_stats(db_id(), null, null, null, null) s,
         sys.indexes i
where    i.object_id = s.object_id
and      i.index_id = s.index_id
and      i.name is not null

to run this query from powershell, just put the query in a variable ($indexList) and use the invoke-sqlcmd cmdlet like :

 invoke-sqlcmd -ServerInstance "myServer\myInstance" -database "myDB" -query $indexlist

you can put the result of this query in a powershell variable :

$listObject = invoke-sqlcmd -ServerInstance "opieri02\R2" -database "AdventureworksDW2008R2" -query $indexlist

after you just have to test if an index is fragmented or not (here, we consider an index as fragmented if it have more than 1000 pages and if the fragmentation is more than 10%)

to achieve this test we are going to use smo object.

1) load the smo assemby :
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo")

2) connect to your instance :
$server = New-Object('Microsoft.SqlServer.Management.Smo.Server') myServer\myInstance

3) for each index that you have retreive, instanciate an smo index :
$index = $Server.databases["myDB"].Tables[$i.table_name].Indexes[$i.index_name]

 The complete script is :

$indexlist = "
Select i.name as index_name, object_name(s.object_id) as table_name,
s.avg_fragmentation_in_percent, s.page_count from sys.dm_db_index_physical_stats(db_id(), null, null, null, null) s,
sys.indexes i
where i.object_id = s.object_id and i.index_id = s.index_id and i.name is not null"

$listObject = invoke-sqlcmd -ServerInstance "myServer\myInstance" -database "myDB" -query $indexlist

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo")

$server = New-Object('Microsoft.SqlServer.Management.Smo.Server') myServer\myInstance

foreach ($i in $listObject)
{
 $index = $Server.databases["myDB"].Tables[$i.table_name].Indexes[$i.index_name]
 if ($i.avg_fragmentation_in_percent -gt 10 -and $i.page_count -gt 1000)
  {
             Write-Host -BackgroundColor Red "Table : " $i.table_name " Index :" $i.index_name " is Fragmented = > Rebuild"
             $index.Rebuild()
  }
 else
  {
  Write-Host "Table : " $i.table_name " Index :" $i.index_name " is not Fragmented"
  }

}

Enjoy !!!

1)  Perfom a full backup for a specified database :

[System.Reflection.Assembly]::LoadWithPartialName('Microsoft.SqlServer.SMO') | out-null
$s = New-Object ('Microsoft.SqlServer.Management.Smo.Server') "myServer\myInstance"

#Create a Backup object instance with the Microsoft.SqlServer.Management.Smo.Backup namespace
$dbBackup = new-object ("Microsoft.SqlServer.Management.Smo.Backup")

#Set the Database property to myDB
$dbBackup.Database = "myDB"

#Add the backup file to the Devices collection and specify File as the backup type
$dbBackup.Devices.AddDevice("C:\backups\myDB_FULL.bak", "File")

#Specify the Action property to generate a FULL backup
$dbBackup.Action="Database"

#Call the SqlBackup method to generate the backup
$dbBackup.SqlBackup($s)

2) Perfom a full backup for all databases :

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.SMO") | out-null
$s = new-object ("Microsoft.SqlServer.Management.Smo.Server") "myServer\myInstance"

$bkdir = "D:\backups"
$dbs = $s.Databases
foreach ($db in $dbs)
{
if($db.Name -ne "tempdb") #We don't want to backup the tempdb database
{
$dbname = $db.Name
$dt = get-date -format yyyyMMddHHmm
$dbBackup = new-object ("Microsoft.SqlServer.Management.Smo.Backup")
$dbBackup.Action = "Database"
$dbBackup.Database = $dbname
$dbBackup.Devices.AddDevice($bkdir + "\" + $dbname + "_db_" + $dt + ".bak", "File")
$dbBackup.SqlBackup($s)
}
}

3) Perform a transaction log backup for all databases :

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.SMO") | out-null
$s = new-object ("Microsoft.SqlServer.Management.Smo.Server") "myServer\myInstance"

$bkdir = "D:\backups"
$dbs = $s.Databases
foreach ($db in $dbs)
{

if($db.RecoveryModel -ne 3) #Don't do Log backups for DBs with RecoveryModel=3 or SIMPLE
{
$dbname = $db.Name
$dt = get-date -format yyyyMMddHHmm
$dbBackup = new-object ("Microsoft.SqlServer.Management.Smo.Backup")
$dbBackup.Action = "Log"
$dbBackup.Database = $dbname
$dbBackup.Devices.AddDevice($bkdir + "\" + $dbname + "_log_" + $dt + ".trn", "File")
$dbBackup.SqlBackup($s)
}

}

4) monitoring backup

the following script give info about the last databases backup

[System.Reflection.Assembly]::LoadWithPartialName('Microsoft.SqlServer.SMO') | out-null
$s = New-Object ('Microsoft.SqlServer.Management.Smo.Server') "MyServer\MyInstance"

$dbs=$s.Databases

$dbs | SELECT Name,LastBackupDate, LastLogBackupDate | Format-Table -autosize

1) is the SQL Service running ?

Get-WmiObject win32_service | Where-Object {$_.name -match "^*SQL*"} | select SystemName, Name, StartName, State

2) how the process run ?

get-wmiobject win32_process | where {$_.name -like "*sql*"} | select name, workingsetsize, threadcount

3) Is there info about SQL Server in the event log ?

get-eventlog -logname application -newest 1000 | where-object {($_.source -eq "MSSQL`$R2") -and ($_.EntryType -eq "Error")}

Now, if we want info about SQL Server, we have to connect to SQL server, to do that, we must first load the SMO assembly

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo")

and make a connection to a specific SQL Server instance :

$server = New-Object('Microsoft.SqlServer.Management.Smo.Server') myserver\myinstance

 4) SQL Server instance information :

$server | select Edition, Version, ProductLevel, Collation, PhysicalMemory, Processors
$server.Configuration.get_AweEnabled()

5) Processes Info (sp_who):

$server.EnumProcesses() | where-object {$_.IsSystem -eq $false} | select Spid, Login, Host, Status, Command, database, Cpu, memusage, BlockingSpid | Format-Table

6) databases information :

$server.Databases | select name, collation, size

To go in a specific database :

$db = $server.databases["DatabaseName"]

and to show all the info about this database :

$db

7) Tables information :

foreach ($t in $db.Tables)
{
write-host $t.name, $t.RowCount, $t.DataSpaceUsed, $IndexSpaceUsed
}

8) Tables with clustered index :

foreach ($t in $db.Tables)
{
 if ($t.HasClusteredIndex -eq $false)
  {
  write-host $t.name
 }
}

9) script an object

you can generate the object's SQL Script (in this example, a table, but it work for all SQL Server object, stored proc etc...)

$db.Tables["tableName"].script()

10) Detach/attach a database :

#Detach :

$server.DetachDatabase("Mydatabase", $false)

#Attach
$sc = new-object System.Collections.Specialized.StringCollection
$sc.Add("C:\Program Files\Microsoft SQL Server\MSSQL10_50.MSSQLSERVER\MSSQL\DATA\Mydatabase.mdf")
$server.AttachDatabase("myDataBase", $sc)

to achieve that, you first need to load the AMO assembly in Powershell :

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.AnalysisServices")

And then create a server object :

$serverAS = New-Object Microsoft.AnalysisServices.Server

And connect to your Analysis Services server :

$serverAS.connect("OPIERI02\R2")

 Now, you can easily query your Analysis Services to know how it is configured :

$serverAS.serverproperties | select Name, Value

Or to know the list of databases that are stored on this Analysis Services Instance :

$serverAS.databases | select Name, EstimatedSize, StorageMode, LastProcessed

If, for a database, you want to have some information about the cube :

$db = $server.databases["MyDB"]

$db.cubes | select name, storagemode, lastprocessed

if, for the same database, you want info about dimensions

$db.dimensions | select name, isparentchild, lastprocessed, storagemode

 If you want to see information about measure group in your database, you have to browse the cube collection as follow :

foreach ($c in $db.cubes) {
        write-host $c.Name
        foreach ($mg in $c.measuregroups) {
                 write-host $mg.name, $mg.estimatedsize, $mg.lastprocessed
        }
}

You want to know if proactive cache is enable for partition ?

$cube = $db.cubes[“myCube”]
$mg = $cube.MeasureGroups[“myMG”]
Foreach ($p in $mg.partitions) { Write-host $p.Name, $p.estimatedSize, $p.proactivecaching.enabled}

To process all the cube for a database :

Foreach ($c in $db.cubes)  {$c.process("ProcessFull")}

and to process all dimensions :

Foreach ($d in $db.dimensions) {$d.process("ProcessFull")}

And you can also backup an analysis services  database with powershell:

$db.backup("myBackup.abf")

Enjoy !

• View of internals informations.
• DMV are basically SQL Views on some pretty important internal memory structures.
• DMV informations include metrics about :
  • indexes
  • query execution
  • operating system
  • Transaction
  • Databases
  • and much more

What are DMF : (Dynamic Management Function)

As an example sys.dm_exec_query_stats records details of the SQL being processed via variable called sql_handle.

If this sql_handle is passed as a parameter to the DMF sys.dm_exec_sql_text, the DMF will return the actual SQL Text  associated with this sql_handle.

Find a cache plan :

Select   st.Text as [SQL],
         cp.cacheobjtype, 
         cp, objtype,
         COASLESCE (Cast(pa.value, INT)), 'Resource' as [DatabaseName],
         cp.usecounts as [Plan Usage],
         qp.query_plan
From     sys.dm_exec_cached_plan cp
CROSS APPLY sys.dm_exec_sql_text (cp.plan_handle) st
CROSS APPLY sys.dm_exec_query_plan (cp.plan_handle) qp
OUTER APPLY sys.dm_exec_plan_attributes (cp.plan_handle) pa
Where   pa.attribute = 'dbid'

Most Expensive Query :

Select     Cast(Total_elapsed_time / 1000000.0 as decimal(28,2)) as [Total Duration (s)],
                 Cast(Total_Worker_Time * 100.0 / Total_Elapsed_Time as decimal(28, 2)) as [% CPU],
                 Cast ((total_elapsed_time - total_worker_time) * 100.0 / total_elapsed_time  as decimal(28,2)) as [%  Waiting],
                 execution_count,
                 Cast (Total_elapsed_time / 1000000.0 / execution_count as decimal(28,2)) as [average duration (s)],
                 Substring (qt.text, (qs.statement_start_offset / 2) + 1, ((
                                     Case When qs.statement_end_offset = -1
                                                Then len(convert(Nvarchar(Max), qt.text)) * 2
                                                Else qs.statement_end_offset
                                    End - qs.statement_start_offset) / 2 ) + 1) as [Individual Query]
From        sys.dm_exec_query_stats qs
CROSS APPLY  sys.dm_exec_sql_text (qs.sql_handle) as qt
CROSS APPLY sys.dm_exec_query_plan(qs.plan_handle) qp
INNER JOIN sys.dm_exec_cached_plans as cp
                        ON qs.plan_handle = cp.plan_handle
Where     Total_elapsed_Time <> 0
and           Execution_count <> 0
Order By  total_elapsed_time DESC

 Missing Index :

 Select    Round (avg_total_user_cost * avg_user_impact * (user_seeks + user_scans), 0) as [Total Cost],
                statement as [Table Name],
                equality_columns
From      sys.dm_db_missing_index_groups g
INNER JOIN sys.dm_db_missing_index_group_stats s on s.group_handle = g.index_group_handle
INNER JOIN sys.dm_db_missing_index_details d on d.index_handle = g.index_handle

Why are you waiting ?

Select  Wait_type, wait_time_ms, signal_wait_time_ms, wait_time_ms -signal_wait_time_ms as RealWait,
             convert(Decimal(12, 2), (wait_time_ms - signal_wait_time_ms) * 100.0 / sum(wait_time_ms) over()) as [% RealWait]
From   sys.dm_os_wait_stats
Where Wait_type like '%SLEEP%'
And      wait_type != 'WAITFOR'
Order by wait_time_ms DESC

What is blocked ?

Select      Blocking.Session_id as BlockingSessionId,
            Sess.login_name as BlockingUser,
            BlockingSQL.Text as BlockingSQL,
            Waits.wait_type as WhyBlocked,
            Blocked.Session_id as BlockedSessionId,
            USER_NAME(Blocked.user_id) as BlockedUser,
            BlockedSQL.text as BlockedSQL,
            DB_NAME(Blocked.database_id) as DatabaseName
From       Sys.dm_exec_connections as Blocking
INNER JOIN sys.dm_exec_requests as Blocked
              ON Blocking.session_id = blocked.blocking_sessionid
INNER JOIN sys.dm_os_waiting_task as waits
              ON Blocked.session_id = Waits.session_id
RIGHT OUTER JOIN sys.dm_exec_sessions Sess
              ON Blocking.session_id = sess.session_id
CROSS APPLY sys.dm_exec_sql_text (Blocking.most_recent_sql_handle) as Blocking SQL
CROSS APPLY sys.dm_exec_sql_text (Blocked.sql_handle) as BlockedSQL

What Fill the log ?

 Select db.name as [Database Name],
        db.recovery_model_desc as [Recovery Model],
        db.log_reuse_wait_desc as [Log reuse Wait Description],
        ls.cntr_value as [Log Size (KB)],
        lu.cntr_value as [log Used (KB)],
        CAST ( CAST(lu.cntr_value as float) / CAST(ls.cntr_value as float) as DECIMAL (18,2)) * 100 as [Log Used %],
        db.Compatibility_level as [DB Compatibility Level],
        db.page_verify_option_desc as [Page Verify_Option]
From    sys.databases as db
INNER JOIN sys.dm_os_performance_counters as lu on db.name = lu.instance_name
INNER JOIN sys.dm_os_performance_counters as ls on db.name = ls.instance_name
Where lu.counter_name like 'Log File(s) Used Size (KB)%'
And ls.counter_name like 'Log File(s) Size (KB)%'

System Information :

Select  cpu_count as [Logical CPU Count],
        hyperthread_ratio as [ Hyperthread Ratio],
        cpu_count /hyperthread_ratio as [Physical CPU Count],
        physical_memory_in_bytes / 1048576 as [Physical Memory (MB)]
From    sys.dm_os_sys_info

Monitor Scheduler info :

SELECT  AVG(current_tasks_count) AS [Avg Task Count] ,
        AVG(runnable_tasks_count) AS [Avg Runnable Task Count]
FROM    sys.dm_os_schedulers
WHERE   scheduler_id < 255
        AND [status] = 'VISIBLE ONLINE'

Monitor Memory :

SELECT  total_physical_memory_kb ,
        available_physical_memory_kb ,
        total_page_file_kb ,
        available_page_file_kb ,
        system_memory_state_desc
FROM    sys.dm_os_sys_memory

SELECT  physical_memory_in_use_kb ,
        locked_page_allocations_kb ,
        page_fault_count ,
        memory_utilization_percentage ,
        available_commit_limit_kb ,
        process_physical_memory_low ,
        process_virtual_memory_low
FROM    sys.dm_os_process_memory

SELECT  OBJECT_NAME(p.[object_id]) AS [ObjectName] ,
        p.index_id ,
        COUNT(*) / 128 AS [Buffer size(MB)] ,
        COUNT(*) AS [Buffer_count]
FROM    sys.allocation_units AS a
        INNER JOIN sys.dm_os_buffer_descriptors
                 AS b ON a.allocation_unit_id = b.allocation_unit_id
        INNER JOIN sys.partitions AS p ON a.container_id = p.hobt_id
WHERE   b.database_id = DB_ID()
        AND p.[object_id] > 100
GROUP BY p.[object_id] ,
        p.index_id
ORDER BY buffer_count DESC

This sample show how to replace target and source connection string and give a value to a package variable.

It show too how to register package event.

using Runtime = Microsoft.SqlServer.Dts.Runtime;

Let do it !

1) Use the useful namespace

using Microsoft.AnalysisServices.AdomdClient;

using System.Data;

using System.IO;

using System.Xml;

2) Start by connecting to Analysis Services 2005 using Adomd.

strConnectionString = "Data Source=" + ServerID + ";";

objConnection = new AdomdConnection();