Friday, November 25, 2016

No se puede borrar base de datos en Single User Mode


En algunas ocasiones una base de datos se pasa a Single User Mode y después no podemos borrarla. Para hacer esto necesitamos primero borrar las conexiones hacia la base de datos y después podemos borrarla usando el siguiente script

SELECT request_session_id FROM sys.dm_tran_locks
WHERE resource_database_id = DB_ID('nombre_bd')

kill 76

USE Master
ALTER DATABASE nombre_bd SET MULTI_USER

drop database nombre_bd

Sunday, November 20, 2016

Introduccion herramientas R con SQL Server


En este video vemos las herramientas con soporte de R de Microsoft y vemos su integración con SQL Server 2016 R Services.

Revision instalacion y monitoreo de R Services

En este video vemos cómo revisar que la instalación de R Services en SQL Server 2016 ha sido correcta, además vemos scripts para monitoreo del desempeño.

Sunday, November 13, 2016

Video sobre Instalacion y monitoreo de R Services

SQL Server 2016 R Services Monitoring with DMVs


SQL Server 2016 includes features for running advanced analytics scripts within the database these scripts are based on the R language.In this blog post we will see some DMV that we can use to be able to monitor the performance of our server.

These administrative views give us information about the amount of scripts that are running at this time as well as the duration of each of them, in this way we can determine what is the impact of running scripts of R within our SQL Server.

The following are the most common administrative views for monitoring the performance of R Scripts.

- DMV sys. dm_os_performance_counters

- Total   Executions:   Indicates the number of processes initiated locally or remotely- Parallel   Executions: Number of times a script includes a parallel execution- Streaming   Executions: Number of times the function was used 
- SQL CC Executions: This column indicates the amount of R scripts that were initiated remotely and are utiliz or to SQL Server as a context of execution
- Total   execution   Time   (Ms): This column indicates the time of the execution
- Execution   Errors: Number of errors that occurred during the execution of the script.

SELECT *   from sys. dm_os_performance_countersWHERE object_name LIKE '% Scripts%'



- DMV sys. dm_external_script_requestsThis administrative view returns one row for each process account being used to execute an external script. It must be emphasized that the account with which it executes the process is not the same credentials of the person who is sending the script for its execution.

This means that if a person sends several jobs to be executed inside the server all these jobs are going to be executed under the same process using a single work account that was assigned to all the scripts sent by the user. The output of this administrative view returns the following information:

Unique identifier what is used to identify the script that is runningLanguage in which the script is written, in our case it would be the R languageAn indicator that specifies whether parallel operations are runningThe name of the working account that is being used for execution, this account is used by the LaunchPad service

SELECT external_script_request_id   ,   [Language]   , degree_of_parallelism   , external_user_nameFROM sys. dm_external_script_requests;

The result of the execution is seen in the following figure, we can notice that at the moment only one script is running and that the programming language is R.


Get information about the scripts that are runningThe following query returns information about all R language operations that are currently running. It returns valuable information, such as session ID, information about locks, database being used where the script is running, also information about timeout, time taken to execute Information about number of readings and writes that the query is performing.

select r. session_id, r. blocking_session_id, r. status      , Db_name (s. Database_id)   as database_name, s. login_name      , R. wait_time, r. wait_type, r. last_wait_type      , R. total_elapsed_time, r. reads, r. logical_reads, r. writes      , Er. language as script_type, er. degree_of_parallelism, er. external_user_name   from sys. dm_exec_requests as rsys join. dm_external_script_requests as eron r. external_script_request_id = er. external_script_request_idsys join. dm_exec_sessions as son s. session_id = r. session_id

- DMV sys. dm_external_script_execution_statsThis administrative view allows us to know what the advanced analytic functions have been used in the execution of Script that include R language. The result of this query is a list of the different advanced analysis libraries and the number of times they have been executed during the entire period that the sql server instance has been running. In the following image the result of the execution is shown and we can see that the forest algorithm has been executed at least 132 times.

SELECT counter_name, counter_valueFROM sys. dm_external_script_execution_statsWHERE language =   'R';



Regards,

Ing. Eduardo Castro, PhDMicrosoft Data Platform MVP


Video Resource Governor con SQL Server 2016 R Services

Using Resource Governor with SQL Server 2016 R Services


SQL Server 2016 includes new advanced analitcs features like R script execution, these features are very useful, however, because those features may use a lot of memory and a lot and a lot of processor it could be the case that all the resources are used by the R Scripts execution.

To control the amount of resources that are allocated to the execution of R scripts you can use the feature known as resource governor. The following T-SQL gets the current configuration of the sql server for the execution and control of resources and resources.

- Check the amount of resources that are assigned by default 
SELECT   *   DESDE   sys. resource_governor_resource_pools   WHERE name =  Default   

The following statute verifies what resources are allocated to the pool external resources. Remember that the R scripts are executed as external scripts so we must use a dedicated pool for that execution

SELECT   *   DESDE   sys. resource_governor_external_resource_pools   
WHERE name =   Default   

The following T-SQL modifies the allocation of resources so that the maximum utilization is 70% of the total memory that the server has. In this way if we want to limit the amount of memory that is assigned we can do it the T-SQL shown below.

ALTER RESOURCE POOL "default" WITH (max_memory_percent =   70); 

If you want to limit the amount of memory that is used by the external scripting then we must modify it by using External Resource Pool. The following command modifies the allocation of resources so that the amount of memory assigned to the external scrtips does not exceed 50%.

ALTER RESOURCE POOL EXTERNAL "default" WITH (max_memory_percent =   50); 

Once we have made those changes, we must execute the following command for these changes to take effect.

ALTER RESOURCE GOVERNOR reconfigure; 

We also have the option to create a special configuration for the assignment of external scripting resources. For example the following command set a maximum of memory use of 30% for external scripts. We also have the option to create a group where we establish the use of resources that we establish by creating a workload group. 

CREATE EXTERNAL RESOURCE POOL WITH pool_scripts_externos (max_memory_percent =   30); 

CREATE WORKLOAD GROUP WITH grupo_scripts_externos (Importance = medium) 
USING "default" EXTERNAL "pool_scripts_externos"; 


ALTER RESOURCE GOVERNOR WITH (classifier_function = NULL);    
ALTER RESOURCE GOVERNOR reconfigure;    

Next we are going to create a classification function, that function will be used to identify the programs that execute R code in this way we can filter those requests that come from the applications such like R Studio we assign the corresponding resources.


USE master 
GO 
CREATE   FUNCTION   aplicaciones_R_Externas () 
RETURNS sysname 
WITH schemabinding 
ACE    
BEGIN    
IF program_name () in ( 'RStudio') RETURN 'grupo_scripts_externos'; 
RETURN 'default'    
END; 
GO

Once the function has been created we have to reconfigure the resource group and assign the classification function that will be used to identify the calls that are being made to the SQL Server instance and will be assigned the groups of Resources corresponding to external applications running R languages. The command to apply the changes is shown below: 

ALTER RESOURCE GOVERNOR WITH (classifier_function =   dbo.aplicaciones_R_Externas); 
ALTER RESOURCE GOVERNOR reconfigure; 
go 

If we want to verify that the changes have been applied correctly we have to execute the following commands: 


SELECT   *   DESDE   sys. resource_governor_workload_groups; 

SELECT   *   DESDE   sys. resource_governor_external_resource_pools; 


In summary in this article we show you how we can control the amount of resources that is allocated to the execution of external scripts and we can control the amount of memory also the amount of semen that will use this type of execution of external scripts.

Uso de Resource Governor con SQL Server 2016 R Services

SQL Server 2016 incluye nuevas características de análisis avanzado,  dichas características son muy útiles,  sin embargo, debido a que esas características utilizan mucha memoria y mucho  y mucho procesador se podría podría dar el caso que se consumen todos los recursos de una instancia de sql server.

Para controlar la cantidad de recursos que se asignan a la ejecución de scripts de R  se puede utilizar la característica del controlador de recursos conocida como resource governor.  El siguiente estatuto SQL obtiene la configuración actual que tiene el sql server para la ejecución y control de recursos y de los recursos.

-- Se verifica la cantidad de recursos que están asignados por default
SELECT * FROM sys.resource_governor_resource_pools WHERE name = 'default'

El siguiente estatuto verifica Cuáles son los recursos asignados para el pool recursos externos.  recordemos que los estatutos de R  son ejecutados como scripts externos asi que debemos utilizar un pool dedicado para esa ejecución

SELECT * FROM sys.resource_governor_external_resource_pools
WHERE name = 'default'
El siguiente estatuto modifica la asignación de recursos para que el máximo de utilización sea de un 70% de la memoria Total que tenga el servidor.  De esta forma si deseamos limitar la cantidad de memoria que está asignada lo podemos hacer con el estatuto que se muestra a continuación.

ALTER RESOURCE POOL "default" WITH (max_memory_percent = 70);  
Si lo que se desea es limitar la cantidad de memoria que es utilizada por los estatutos de scripts externos de R  entonces debemos modificarlo mediante el uso de Pool de recursos externos. El  el siguiente comando modifica la asignación de recursos para que la cantidad de memoria asignada a los estatutos externos no exceda un 50%.


ALTER EXTERNAL RESOURCE POOL "default" WITH (max_memory_percent = 50);


Una vez que hemos hecho esos cambios  debemos ejecutar el siguiente Comando para que dichos cambios sean efectivos.

ALTER RESOURCE GOVERNOR reconfigure;
También tenemos la opción de crear una configuración especial para la asignación de recursos de estatuto de scripts externos. Por Ejemplo el siguiente Comando Establece que para los escritos externos se establezca un máximo de uso de memoria de un 30%.  También se crea un grupo en donde le establecemos la importancia que va a tener con respecto al uso de los recursos eso lo establecemos mediante la creación de un workload group.


CREATE EXTERNAL RESOURCE POOL pool_scripts_externos WITH (max_memory_percent = 30);

CREATE WORKLOAD GROUP grupo_scripts_externos WITH (importance = medium)
USING "default", EXTERNAL "pool_scripts_externos";  

Para continuar con la configuración debemos crear una función de clasificación en los comandos siguientes vamos a crear dicha función de clasificación,  pero primero debemos aplicar los cambios que hemos creado anteriormente lo cual se realiza con los siguientes comandos.


ALTER RESOURCE GOVERNOR WITH (classifier_function = NULL);  
ALTER RESOURCE GOVERNOR reconfigure;  

A continuación vamos a crear una función de clasificación,  esa función nos va a servir para poder identificar los programas que Ejecutan código R  Y de esa forma le vamos a asignar un grupo de recursos,  de esta forma podemos filtrar aquellas solicitudes que vienen de las aplicaciones tales como R Studio  le asignamos los recursos correspondientes.



USE master  
GO  
CREATE FUNCTION aplicaciones_R_Externas()  
RETURNS sysname  
WITH schemabinding  
AS  
BEGIN  
   IF program_name() in ('Microsoft R Host', 'RStudio') RETURN 'grupo_scripts_externos';  
   RETURN 'default'  
   END;  
GO  

Una vez que la función ha sido creada tenemos que volver a configurar el grupo de recursos y le asignamos la función de clasificación que será utilizada para identificar las llamadas que se están haciendo a la instancia de sql server y se le van a asignar los grupos de recursos correspondientes a las aplicaciones externas que ejecuten lenguajes R. El  comando para poder aplicar los cambios se muestra a continuación:
ALTER RESOURCE GOVERNOR WITH  (classifier_function = dbo.aplicaciones_R_Externas);  
ALTER RESOURCE GOVERNOR reconfigure;  
go  
Si deseamos verificar que los cambios han sido aplicados de forma correcta tenemos que ejecutar los siguientes comandos:


SELECT * FROM sys.resource_governor_workload_groups;  

SELECT * FROM sys.resource_governor_external_resource_pools;  


En resumen en este artículo hemos mostrado la forma en que podemos controlar la cantidad de recursos que se asigna a la ejecución de scripts externos y podemos controlar la cantidad de memoria también la cantidad de semen que van a utilizar este tipo de ejecución de scripts externos.  de esta forma podemos controlar el uso de los recursos de nuestro servidor SQL Server

SQL Server 2016 Stretch Databases

El SQL Server Stretch Database permite que los datos históricos o de bitácoras puedan ser movidos hacia Azure, específicamente permite mover...