In SQL Server, the PRINT statement prints up to 4000 characters. So what will you do if the content of the dynamic queries you write is longer than 4000 characters?

In SQL Server, in some cases, you may want to PRINT statements with more than 4000 characters.

You can easily do this using the procedure below.

CREATE PROCEDURE LONGPRINT
    @String NVARCHAR(MAX)
AS
BEGIN
    BEGIN TRY

    DECLARE @CurrentEnd BIGINT;
    DECLARE @Offset TINYINT; 
    SET @String = replace(replace(@String, CHAR(13) + CHAR(10), CHAR(10)), CHAR(13), CHAR(10))

    WHILE LEN(@String) > 1
    BEGIN
        IF CHARINDEX(CHAR(10), @String) BETWEEN 1 AND 4000
        BEGIN
            SET @CurrentEnd =  CHARINDEX(CHAR(10), @String) -1
            SET @Offset = 2
        END
        ELSE
        BEGIN
            SET @CurrentEnd = 4000
            SET @Offset = 1
        END   
        PRINT SUBSTRING(@String, 1, @CurrentEnd) 
        SET @String = SUBSTRING(@String, @CurrentEnd + @Offset, LEN(@String))   
    END 
    END TRY
    BEGIN CATCH
        DECLARE @ErrorMessage VARCHAR(4000)
        SELECT @ErrorMessage = ERROR_MESSAGE()    
        RAISERROR(@ErrorMessage,16,1)
    END CATCH
END

--Use of the Procedure

DECLARE @Degisken VARCHAR(MAX)
SET @Degisken = REPLICATE('x', 6000)
EXEC LONGPRINT @Degisken

When you create the above procedure and run the code, you will see a result similar to the one below.

As you can see, we have printed 6000 characters with the LONGPRINT procedure.

Good luck to everyone in business and life.

The post Customized PRINT Procedure in SQL Server first appeared on MSSQL Query.

Most people tend to prefix “sp_” to the name of the Stored Procedure when creating a Stored Procedure in SQL Server.

There are several reasons why this is considered bad practice.

Microsoft says you shouldn’t do this.

You can read Microsoft’s statement below.

Avoid using the sp_ prefix when naming Stored Procedures. This prefix is used by Microsoft SQL Server to identify system procedures. Using the prefix can break the application code if there is a system procedure with the same name.

This means that if you accidentally name your Stored Procedure with the same name as one of SQL Server’s Stored Procedure, your Stored Procedure will not be called. Instead, the SQL Server System Stored Procedure is called.

For example, if you have created a Stored Procedure named “sp_configure” in your database, it will never be executed when you call it because there is a system Stored Procedure named “sp_configure” in the master database and will be called instead.

Second, when SQL Server sees the prefix “sp_” at the beginning of a Stored Procedure, it first tries to find that procedure in the master database. As stated in the Microsoft documentation above, ” This prefix is used by SQL Server to denote system procedures “, so when SQL Server sees the phrase “sp_” prefix, it starts searching for system procedures. But after searching all the procedures in the master database and determining that your procedure is not there, it will return to your database to try to find the stored procedure.

As noted in the above post, procedures named with the “sp_” prefix will run slower. Of course, this may not always be noticed.

There are times when the above situation is an exception.

Use DatabaseOrnek 
EXEC dbo.sp_configure

ile

Use DatabaseOrnek 
EXEC DatabaseOrnek.dbo.sp_configure

The second example will call your procedure correctly.

But for this to work, you have to call it like (databasename.semaname.procedure) every time.

Unless you are intentionally creating a Stored Procedure in the SQL Server system database, there is no valid reason to name the Stored Procedure with the “sp_” prefix. It is not very convenient to send SQL Server to wrong database to find Stored Procedure. It’s confusing, inefficient, and can cause performance issues. So why take the risk? To help maintain peak performance of your databases, avoid using the “sp_” prefix in your Stored Procedure names.

Good luck to everyone in business and life.

The post Why You Shouldn’t Prefix “sp_” Before Your Stored Procedures in SQL Server? first appeared on MSSQL Query.

In this article, I will share information about the procedure for outputting tables in HTML format in SQL Server

In SQL Server, in some cases you may want to output the tables in HTML format.

You can easily do this by using the following procedure.

CREATE PROCEDURE [dbo].[SqlTableToHtml] (@TABLENAME NVARCHAR(500),
@OUTPUT NVARCHAR(MAX) OUTPUT,
@TBL_STYLE NVARCHAR(1024) = '',
@TD_STYLE NVARCHAR(1024) = '',
@HDR_STYLE NVARCHAR(1024) = '')
AS

	DECLARE @exec_str NVARCHAR(MAX)
	DECLARE @ParmDefinition NVARCHAR(500)

	SET @exec_str = N'
DECLARE @exec_str  NVARCHAR(MAX)
DECLARE @ParmDefinition NVARCHAR(500)

select CustColHTML_ID=0,* INTO #CustomTable2HTML FROM ' + @TABLENAME + ' 

DECLARE @COUNTER INT
SET @COUNTER=0
UPDATE #CustomTable2HTML SET @COUNTER = CustColHTML_ID=@COUNTER+1 

DECLARE @HTMLROWS NVARCHAR(MAX) DECLARE @FIELDS NVARCHAR(MAX) 
SET @HTMLROWS='''' DECLARE @ROW NVARCHAR(MAX) 

SET @FIELDS=''<tr>''
SELECT @FIELDS=COALESCE(@FIELDS, '' '','''')+''<th ' + @HDR_STYLE + '>'' + name + ''</th>''
FROM tempdb.sys.Columns
WHERE object_id=object_id(''tempdb..#CustomTable2HTML'')
AND name not like ''CustColHTML_ID''
SET @FIELDS=@FIELDS + ''</tr>''

DECLARE @ColumnName  NVARCHAR(500)
DECLARE @maxrows INT
DECLARE @rownum INT

--Find row count of our temporary table
SELECT @maxrows=count(*) FROM  #CustomTable2HTML

DECLARE col CURSOR FOR
SELECT name FROM tempdb.sys.Columns
WHERE object_id=object_id(''tempdb..#CustomTable2HTML'')
AND name not like ''CustColHTML_ID''
ORDER BY column_id ASC

SET @rowNum=0
SET @ParmDefinition=N''@ROWOUT NVARCHAR(MAX) OUTPUT,@rowNum_IN INT''

While @rowNum < @maxrows
BEGIN
  SET @HTMLROWS=@HTMLROWS + ''<tr>''

  SET @rowNum=@rowNum +1
  OPEN col
  FETCH NEXT FROM col INTO @ColumnName
  WHILE @@FETCH_STATUS=0
    BEGIN
      SET @exec_str=''SELECT @ROWOUT=(select COALESCE(['' + @ColumnName + ''], '''''''') AS ['' + @ColumnName + ''] from #CustomTable2HTML where CustColHTML_ID=@rowNum_IN)''

	  EXEC	sp_executesql 
			@exec_str,
			@ParmDefinition,
			@ROWOUT=@ROW OUTPUT,
            @rowNum_IN=@rownum

      SET @HTMLROWS =@HTMLROWS +  ''<td ' + @TD_STYLE + '>'' + @ROW + ''</td>''
      FETCH NEXT FROM col INTO @ColumnName
    END
  CLOSE col
  SET @HTMLROWS=@HTMLROWS + ''</tr>''
END

SET @OUTPUT=''''
IF @maxrows>0
SET @OUTPUT= ''<table ' + @TBL_STYLE + '>'' + @FIELDS + @HTMLROWS + ''</table>''

DEALLOCATE col
'

	DECLARE @ParamDefinition NVARCHAR(MAX)
	SET @ParamDefinition = N'@OUTPUT NVARCHAR(MAX) OUTPUT'
	EXEC sp_executesql @exec_str
					  ,@ParamDefinition
					  ,@OUTPUT = @OUTPUT OUTPUT

	RETURN 1


--Use of the Procedure


DECLARE @html NVARCHAR(MAX)
EXEC SqlTableToHtml 'Products'
					,@html OUTPUT
					,''
					,'style="border-top:1px #CCCCCC solid;padding:7px"'
					,'style="padding:7px"'
SELECT
	@html

Create and run the above procedure and you will see a result similar to the one below.

I got the result by trying the above procedure on the Products table on the Northwind database. You can also try it on your own tables.

As you can see, we have printed the table in HTML format.

Good luck to everyone in their working life and life.

The post Procedure to Output Tables in HTML Format in SQL Server first appeared on MSSQL Query.

In this article, I will give you information about when to use the sp_refreshview procedure in SQL Server.

The sp_refreshview procedure in SQL Server is used to update the metadata of a view in the database. This can be necessary in certain situations, such as when a view is not returning the expected results, or when changes have been made to the underlying tables or columns that are referenced by the view.

Here are some situations when you might want to use sp_refreshview:

1. After altering a table or view referenced by the view: If you make changes to a table or view that is used in the definition of a view, you will need to refresh the view’s metadata using sp_refreshview so that it reflects the changes.
2. After restoring a database: If you restore a database that contains views, you should refresh the metadata of those views using sp_refreshview so that they reflect the current state of the database.
3. When troubleshooting view performance issues: If you are experiencing performance issues with a view, you can use sp_refreshview to update its metadata and ensure that it is using the most up-to-date statistics.

In general, sp_refreshview is not needed on a regular basis, but it can be useful in certain situations to ensure that your views are up-to-date and functioning as expected.

Good luck to everyone in business and life.

The post When to Use the sp_refreshview Procedure in SQL Server first appeared on MSSQL Query.

In this article, I will try to give information about learning the physical size of a table in SQL Server.

In SQL Server, in some cases you may want to know the physical size of a table.

We use the sp_spaceused procedure for this operation.

We run our procedure by saying exec.

EXEC sp_spaceused;

After that, parts such as name information, rows information, and data information of the Products table come.

Good luck to everyone in business and life.

The post Finding the Physical Size of a Table in SQL Server first appeared on MSSQL Query.

In this article, I will try to give information about the advantages of using Procedures in SQL Server.

Procedures are pre-written code blocks that can be stored and executed in a SQL Server database. Here are some advantages of using procedures in SQL Server:

1. Reusability: Procedures can be reused multiple times, making it an efficient way to execute repetitive tasks. Once a procedure is written, it can be called whenever needed.
2. Modularity: Procedures allow you to break down complex logic into smaller, manageable pieces, which makes code maintenance and debugging easier.
3. Improved Performance: By using procedures, you can reduce the amount of data that needs to be sent over the network. This can lead to improved performance and reduced network traffic.
4. Security: Procedures provide a level of security by allowing you to control access to sensitive data. By granting users permission to execute a procedure rather than directly accessing the data, you can restrict access to the data.
5. Consistency: Procedures ensure that database operations are performed consistently. This is particularly important when working with transactions where multiple operations need to be executed together.
6. Encapsulation: Procedures can be used to encapsulate business logic, which means that the implementation details are hidden from the user. This makes it easier to modify the implementation without affecting the user interface.

Overall, the use of procedures in SQL Server can lead to improved performance, enhanced security, and easier maintenance and development of the database.

Good luck to everyone in business and life.

The post What are the Advantages of Using Procedures in SQL Server? first appeared on MSSQL Query.

In this article, I will try to give information about System Procedures, which are widely used in SQL Server.

There are many system procedures available in SQL Server, but some of the commonly used ones are:

1. sp_help: This system procedure provides information about a database object, such as a table, view, or stored procedure. It can be used to retrieve information about columns, constraints, indexes, and other object properties.
2. sp_who: This system procedure displays information about current users and processes connected to the SQL Server instance. It provides details such as the login name, hostname, program name, and status of each process.
3. sp_configure: This system procedure is used to view or modify system-level configuration settings in SQL Server. It allows you to change settings such as the maximum amount of memory allocated to SQL Server, network protocols used, and many other options.
4. sp_spaceused: This system procedure displays the amount of space used by a table or database in SQL Server. It provides details such as the total size of the table, the amount of space used by indexes, and the amount of space available.
5. sp_executesql: This system procedure is used to execute a dynamic SQL statement that is constructed at runtime. It is often used when the exact SQL statement is not known until runtime, such as when building dynamic reports or queries.
6. sp_rename: This system procedure is used to rename a database object, such as a table, column, or stored procedure. It can be used to change the name of an object without having to drop and recreate it.
7. sp_helpindex: This system procedure provides information about the indexes on a table. It displays the name, type, and columns included in each index, as well as the index size and fragmentation.

These are just a few examples of the many system procedures available in SQL Server that can be used for various purposes.

Good luck to everyone in business and life.

The post What Are Commonly Used System Procedures in SQL Server? first appeared on MSSQL Query.

In this article, I will talk about the difference between stored procedures and functions in SQL Server.

Stored procedures are sql statements that are stored by the database and do not need to be recompiled after the first compilation.

Functions are sql codes that can return any type of value.

The differences between them are below.

1. Functions always return a value (Number, string expression, table, etc.) Stored procedures may or may not return a value.
2. Functions have only input parameters, but stored procedures have both input and output parameters.
3. Functions can be run by stored procedures, but stored procedures cannot be run inside functions.
4. Functions can only be used with a Select statement. CRUD operations are not performed with functions. You can do all CRUD (Create/Read/Update/Delete) operations with stored procedures.
5. You cannot use the try-catch construct in functions, but you can use it with stored procedures.
6. Functions do not support transaction structures, but stored procedures do.
7. Functions do not support the PRINT statement. PRINT statement can be used in stored procedures.
8. The result set returned by the function can be used in JOIN operations. Not used with stored procedures.
9. You can use TABLE variable inside the function. Functions The use of TEMPORARY TABLE is not allowed. TABLE variable and TEMPORARY TABLE can be used in stored procedure.

Good luck to everyone in business and life.

The post Differences Between Stored Procedures and Functions in SQL Server first appeared on MSSQL Query.

In this article, I will try to give information about displaying Stored Procedure parameters in SQL Server in detail.

In SQL Server, in some cases, you may want to view the Stored Procedure parameters in detail.

You can easily do this using the code below.

SELECT 'Parameter_name' = name,
       'Type' = TYPE_NAME(user_type_id),
       'Length' = max_length,
       'Prec' = CASE
                    WHEN TYPE_NAME(system_type_id) = 'uniqueidentifier' THEN
                        precision
                    ELSE
                        OdbcPrec(system_type_id, max_length, precision)
                END,
       'Scale' = OdbcScale(system_type_id, scale),
       'Param_order' = parameter_id,
       'Collation' = CONVERT(   sysname,
                                CASE
                                    WHEN system_type_id IN ( 35, 99, 167, 175, 231, 239 ) THEN
                                        SERVERPROPERTY('collation')
                                END
                            )
FROM sys.parameters
WHERE OBJECT_ID = OBJECT_ID('dbo.CustOrderHist'); --Enter the procedure name here.

When you run the above code, you will see a result similar to the one below.

As you can see, we have displayed the Stored Procedure parameters in detail.

Good luck to everyone in business and life.

The post Viewing Stored Procedure Parameters in Detail in SQL Server first appeared on MSSQL Query.

In this article, I will try to give information about seeing Procedure Execution Statistics in SQL Server.

In SQL Server you may want to see Procedure Execution Statistics in some cases.

One advantage of Stored Procedures is that performance can be tracked. There may be many Stored Procedures in our database or SQL Server. You may want to see information such as how long they work, their working time, how much resources they use. This information shows us the information from the last run time of SQL Server to the time of writing the query. This information is kept in Memory and Cache. This information is lost when a restart is performed on SQL Server, but it is easy and useful to log the working information of historical Stored Procedures.

You can easily do this using the code below.

SELECT database_id,
       object_id,
       OBJECT_NAME(object_id, database_id) AS 'Prosedür Adı',
       cached_time,
       last_execution_time,
       total_elapsed_time,
       (total_elapsed_time / execution_count) AS 'AVG Elapsed Time',
       last_elapsed_time,
       execution_count
FROM sys.dm_exec_procedure_stats
WHERE database_id = DB_ID('AdventureWorks');

When you run the above code, you will see a result similar to the one below.

As you can see, we have seen the Procedure Execution Statistics.

Stored Procedure name, last run time, time elapsed when the procedure was run, how many times the procedure ran, etc. We were able to access information such as and show it in tabular form.

Good luck to everyone in business and life.

The post Seeing Procedure Execution Statistics in SQL Server first appeared on MSSQL Query.

In this article, I will provide information about the procedure that brings the previous week’s list of failed logins in SQL Server.

It is also very important for security to track failed login attempts to SQL Server.

With the help of the procedure below, you can also track failed logins.

CREATE PROC sp_PreviousWeekFailedLoginList 
AS
BEGIN
    SET NOCOUNT ON;

    DECLARE @ErrorLogCount INT;
    DECLARE @LastLogDate DATETIME;

    DECLARE @ErrorLogInfo TABLE
    (
        LogDate DATETIME,
        ProcessInfo NVARCHAR(50),
        [Text] NVARCHAR(MAX)
    );

    DECLARE @EnumErrorLogs TABLE
    (
        [Archive#] INT,
        [Date] DATETIME,
        LogFileSizeMB INT
    );

    INSERT INTO @EnumErrorLogs
    EXEC sp_enumerrorlogs;

    SELECT @ErrorLogCount = MIN([Archive#]),
           @LastLogDate = MAX([Date])
    FROM @EnumErrorLogs;

    WHILE @ErrorLogCount IS NOT NULL
    BEGIN

        INSERT INTO @ErrorLogInfo
        EXEC sp_readerrorlog @ErrorLogCount;

        SELECT @ErrorLogCount = MIN([Archive#]),
               @LastLogDate = MAX([Date])
        FROM @EnumErrorLogs
        WHERE [Archive#] > @ErrorLogCount
              AND @LastLogDate > GETDATE() - 1;

    END;

    SELECT COUNT(Text) AS NumberOfAttempts,
           Text AS Details,
           MIN(LogDate) AS MinLogDate,
           MAX(LogDate) AS MaxLogDate
    FROM @ErrorLogInfo
    WHERE ProcessInfo = 'Logon'
          AND Text LIKE '%fail%'
          AND LogDate > GETDATE() - 1
    GROUP BY Text
    ORDER BY NumberOfAttempts DESC;

    SET NOCOUNT OFF;
END;


--Use of Procedure

EXEC sp_PreviousWeekFailedLoginList ;

Good luck to everyone in business and life.

The post Procedure to Return Previous Week’s Failed Login List in SQL Server first appeared on MSSQL Query.

In this article, I will give information about data compression procedure for all tables in SQL Server.

There are two types of data compression.

Row Level Data Compression: A compression method that converts fixed-length data types to variable-length data types and frees up free space. It also saves additional space by ignoring zero and null values. In contrast, it can fit more rows in a single data sheet.

Page-Level Data Compression: A compression method that starts with row-level data compression and then adds a prefix and a dictionary compression for data pages.

The following procedure expects either ROW or PAGE parameter. Which compression type you want to use, you can run that parameter by writing it to the procedure.

CREATE PROCEDURE DataCompressionProcedureforAllTables 
(@compression_method CHAR(4))
AS
SET NOCOUNT ON;
BEGIN
    DECLARE @schema_name sysname,
            @table_name sysname;
    CREATE TABLE #compress_report_tb
    (
        ObjName sysname,
        schemaName sysname,
        indx_ID INT,
        partit_number INT,
        size_with_current_compression_setting BIGINT,
        size_with_requested_compression_setting BIGINT,
        sample_size_with_current_compression_setting BIGINT,
        sample_size_with_requested_compression_setting BIGINT
    );
    DECLARE c_sch_tb_crs CURSOR FOR
    SELECT TABLE_SCHEMA,
           TABLE_NAME
    FROM INFORMATION_SCHEMA.TABLES
    WHERE TABLE_TYPE LIKE 'BASE%'
          AND TABLE_CATALOG = UPPER(DB_NAME());
    OPEN c_sch_tb_crs;
    FETCH NEXT FROM c_sch_tb_crs
    INTO @schema_name,
         @table_name;
    WHILE @@Fetch_Status = 0
    BEGIN
        INSERT INTO #compress_report_tb
        EXEC sp_estimate_data_compression_savings @schema_name = @schema_name,
                                                  @object_name = @table_name,
                                                  @index_id = NULL,
                                                  @partition_number = NULL,
                                                  @data_compression = @compression_method;
        FETCH NEXT FROM c_sch_tb_crs
        INTO @schema_name,
             @table_name;
    END;
    CLOSE c_sch_tb_crs;
    DEALLOCATE c_sch_tb_crs;
    SELECT schemaName AS [schema_name],
           ObjName AS [table_name],
           AVG(size_with_current_compression_setting) AS avg_size_with_current_compression_setting,
           AVG(size_with_requested_compression_setting) AS avg_size_with_requested_compression_setting,
           AVG(size_with_current_compression_setting - size_with_requested_compression_setting) AS avg_size_saving
    FROM #compress_report_tb
    GROUP BY schemaName,
             ObjName
    ORDER BY schemaName ASC,
             avg_size_saving DESC;
    DROP TABLE #compress_report_tb;
END;
SET NOCOUNT OFF;


--Usage 
--Run after selecting the relevant database. Otherwise, the responsibility belongs to you.

EXEC DataCompressionProcedureforAllTables @compression_method= 'PAGE';
GO

Good luck to everyone in business and life.

The post Data Compression Procedure for All Tables in SQL Server first appeared on MSSQL Query.

In this article, I will provide information on how to remove all procedures in SQL Server.

In SQL Server we may want to remove all procedures in some cases.

You can easily do this using the code below.

DECLARE @procName VARCHAR(500);
DECLARE cur CURSOR FOR SELECT [name] FROM sys.objects WHERE type = 'p';
OPEN cur;
FETCH NEXT FROM cur
INTO @procName;
WHILE @@fetch_status = 0
BEGIN
    EXEC ('drop procedure [' + @procName + ']');
    FETCH NEXT FROM cur
    INTO @procName;
END;
CLOSE cur;
DEALLOCATE cur;

When you run the above code, all procedures in the relevant database will be removed.

Good luck to everyone in business and life.

The post Removing All Procedures in SQL Server first appeared on MSSQL Query.

In this article, I will give information about what are the Differences Between Function and Procedure in SQL Server.

This question especially comes to mind of curious friends who are just learning SQL Server. This question may come up in job interviews. It is useful to know briefly, because in the programming world, it is more important to do something efficiently and with less resources than to do it.

1. The function must always return a value. (Number, text, table etc.) but Stored Procedure is optional, it may not have a return value.
2. You cannot use a try-catch construct in a function. You can use it in Stored Procedure.
3. Function can only be used with Select, it doesn’t update or delete, Stored Procedure can do all CRUD(CREATE/READ/UPDATE/DELETE) operations.
4. Function has only input parameters, but Stored Procedures can use both input and output parameters.
5. Function can be called by Stored Procedure but Stored Procedure cannot be called by Function.
6. Functions do not support Transaction constructs, but Stored Procedures do.
7. Only variable table values can be used in functions, Temporary tables cannot be used. You can use both in procedures.
8. Functions can be used anywhere in the WHERE/HAVING/SELECT section, while Stored Procedures cannot.
9. Functions can be called and used using Select and Stored Procedures using Exec or Execute.
10. We cannot use indexes in functions, they can be used in Stored Procedures.
11. Trigger is not used in Functions, it can be used in Stored Procedure.
12. While functions are not compiled once, Stored Procedures are compiled once and work efficiently.
13. It can be used in functions with Join structure, not in Stored Procedures.

I hope it was useful.

Good luck to everyone in business and life.

The post What are the Differences Between Function and Procedure in SQL Server? first appeared on MSSQL Query.

In this article, I will try to give information about finding the last used Stored Procedure in SQL Server.

In SQL Server in some cases you may want to find the last used Stored Procedure.

You can easily do this using the script below.

SELECT DB_NAME(qt.[dbid]) AS [DatabaseName],
       OBJECT_NAME(qt.[objectid], qt.[dbid]) AS [SP Name],
       qs.execution_count AS [Execution Count],
       qs.max_logical_reads,
       qs.max_logical_writes,
       qs.creation_time,
       DATEDIFF(MINUTE, qs.creation_time, GETDATE()) AS [Age in Cache]
FROM sys.dm_exec_query_stats AS qs
    CROSS APPLY sys.dm_exec_sql_text(qs.[sql_handle]) AS qt
WHERE LEN(OBJECT_NAME(qt.[objectid], qt.[dbid])) > 0
ORDER BY DB_NAME(qt.[dbid]) DESC,
         OBJECT_NAME(qt.[objectid], qt.[dbid]) DESC;

When you run the above code, you will see a result similar to the one below.

As you can see, we have found the Stored Procedure we used last time.

Good luck to everyone in business and life.

The post Finding Last Used Stored Procedure in SQL Server first appeared on MSSQL Query.

In this article, I will talk about how to list disk spaces in SQL Server.

In SQL Server, in some cases, it may be desired to display disk spaces with a query.

In such cases, we can list the disk spaces using the following query.

EXEC master..xp_fixeddrives;

When we run the relevant query, we will get a result as follows.

As you can see, the disk spaces are listed.

Good luck to everyone in business and life.

The post Listing Disk Spaces in SQL Server first appeared on MSSQL Query.

In this article, I will talk about how to dynamically generate code for removing all procedures in SQL Server.

In SQL Server, in some cases, instead of removing the procedures by manually writing the code, we can remove the relevant procedures by dynamically generating code.

You can see the relevant code below.

SELECT 'DROP PROC ' + '[' + ROUTINE_SCHEMA + ']' + '.' + '[' + ROUTINE_NAME + ']'
FROM INFORMATION_SCHEMA.ROUTINES
WHERE ROUTINE_TYPE = 'PROCEDURE';

When we run the relevant code on the Northwind database, you will see the following result.

As you can see, the following codes were generated.

DROP PROC [dbo].[Ten Most Expensive Products];
DROP PROC [dbo].[Employee Sales by Country];
DROP PROC [dbo].[Sales by Year];
DROP PROC [dbo].[CustOrdersDetail];
DROP PROC [dbo].[CustOrdersOrders];
DROP PROC [dbo].[CustOrderHist];
DROP PROC [dbo].[SalesByCategory];
DROP PROC [dbo].[sp_upgraddiagrams];
DROP PROC [dbo].[sp_helpdiagrams];
DROP PROC [dbo].[sp_helpdiagramdefinition];
DROP PROC [dbo].[sp_creatediagram];
DROP PROC [dbo].[sp_renamediagram];
DROP PROC [dbo].[sp_alterdiagram];
DROP PROC [dbo].[sp_dropdiagram];
DROP PROC [dbo].[ScriptCreateTableKeys];
DROP PROC [dbo].[ScriptCreateTableKeys2];

You can run whatever you want according to your needs, or you can run them all together and remove all procedures.

Good luck to everyone in business and life.

The post Generating the Code to Remove All Procedures in SQL Server first appeared on MSSQL Query.

Even though I don’t use it much, in SQL Server, in some cases, we may only need to create a script for the key fields. In addition, I think that this process, which we will do on a table basis, will save us from code confusion. It can also be useful if something like a backup of table-based key fields is to be made.

First of all, you should create the following procedure in your related database. I created the following procedure in Adventureworks database as an example.

CREATE PROC [dbo].[TabloKeylerininScriptiniAl] @table_name sysname
AS
BEGIN

    SET NOCOUNT ON;


    DECLARE @crlf CHAR(2);

    SET @crlf = CHAR(13) + CHAR(10);

    DECLARE @version CHAR(4);

    SET @version = SUBSTRING(@@VERSION, LEN('Microsoft SQL Server') + 2, 4);

    DECLARE @object_id INT;

    SET @object_id = OBJECT_ID(@table_name);

    DECLARE @sql NVARCHAR(MAX);



    /*    IF @version NOT IN ( '2005', '2008' )
    BEGIN

        RAISERROR('This script only supports SQL Server 2005 and 2008', 16, 1);

        RETURN;

    END;*/



    SET @sql
        = N'' + N'SELECT ' + N'CASE ' + N'WHEN 1 IN (i.is_primary_key, i.is_unique_constraint) THEN '
          + N'''ALTER TABLE '' + ' + N'QUOTENAME(OBJECT_SCHEMA_NAME(i.object_id)) + ''.'' + '
          + N'QUOTENAME(OBJECT_NAME(i.object_id)) + @crlf + ' + N'''ADD '' + ' + N'CASE k.is_system_named '
          + N'WHEN 0 THEN ''CONSTRAINT '' + QUOTENAME(k.name) + @crlf ' + N'ELSE '''' ' + N'END + ' + N'CASE k.type '
          + N'WHEN ''UQ'' THEN ''UNIQUE'' ' + N'ELSE ''PRIMARY KEY'' ' + N'END + '' '' + ' + N'i.type_desc  + @crlf + '
          + N'kc.key_columns + @crlf ' + N'ELSE ' + N'''CREATE UNIQUE '' + i.type_desc + '' INDEX '' + '
          + N'QUOTENAME(i.name) + @crlf + ' + N'''ON '' + ' + N'QUOTENAME(OBJECT_SCHEMA_NAME(i.object_id)) + ''.'' + '
          + N'QUOTENAME(OBJECT_NAME(i.object_id)) + @crlf + ' + N'kc.key_columns + @crlf + ' + N'COALESCE ' + N'( '
          + N'''INCLUDE '' + @crlf + ' + N'''( '' + @crlf + ' + N'STUFF ' + N'( ' + N'( ' + N'SELECT ' + N'( '
          + N'SELECT ' + N''','' + @crlf + '' '' + QUOTENAME(c.name) AS [text()] ' + N'FROM sys.index_columns AS ic '
          + N'JOIN sys.columns AS c ON ' + N'c.object_id = ic.object_id ' + N'AND c.column_id = ic.column_id '
          + N'WHERE ' + N'ic.object_id = i.object_id ' + N'AND ic.index_id = i.index_id '
          + N'AND ic.is_included_column = 1 ' + N'ORDER BY ' + N'ic.key_ordinal ' + N'FOR XML PATH(''''), TYPE '
          + N').value(''.'', ''VARCHAR(MAX)'') ' + N'), ' + N'1, ' + N'3, ' + N''''' ' + N') + @crlf + '
          + N''')'' + @crlf, ' + N''''' ' + N') ' + N'END + ' + N'''WITH '' + @crlf + ' + N'''('' + @crlf + '
          + N''' PAD_INDEX = '' + ' + N'CASE CONVERT(VARCHAR, i.is_padded) ' + N'WHEN 1 THEN ''ON'' '
          + N'ELSE ''OFF'' ' + N'END + '','' + @crlf + ' + N'CASE i.fill_factor ' + N'WHEN 0 THEN '''' ' + N'ELSE '
          + N''' FILLFACTOR = '' + ' + N'CONVERT(VARCHAR, i.fill_factor) + '','' + @crlf ' + N'END + '
          + N''' IGNORE_DUP_KEY = '' + ' + N'CASE CONVERT(VARCHAR, i.ignore_dup_key) ' + N'WHEN 1 THEN ''ON'' '
          + N'ELSE ''OFF'' ' + N'END + '','' + @crlf + ' + N''' ALLOW_ROW_LOCKS = '' + '
          + N'CASE CONVERT(VARCHAR, i.allow_row_locks) ' + N'WHEN 1 THEN ''ON'' ' + N'ELSE ''OFF'' '
          + N'END + '','' + @crlf + ' + N''' ALLOW_PAGE_LOCKS = '' + ' + N'CASE CONVERT(VARCHAR, i.allow_page_locks) '
          + N'WHEN 1 THEN ''ON'' ' + N'ELSE ''OFF'' ' + N'END + '
          + CASE @version
                WHEN '2005' THEN
                    ''
                ELSE
                    ''','' + @crlf + ' + ''' DATA_COMPRESSION = '' + ' + '( ' + 'SELECT ' + 'CASE '
                    + 'WHEN MIN(p.data_compression_desc) =

                                          MAX(p.data_compression_desc)

                                          THEN MAX(p.data_compression_desc) '
                    + 'ELSE ''[PARTITIONS USE

                                          MULTIPLE COMPRESSION TYPES]'' '
                    + 'END ' + 'FROM sys.partitions AS p ' + 'WHERE ' + 'p.object_id = i.object_id '
                    + 'AND p.index_id = i.index_id ' + ') '
            END + N'+ @crlf + ' + N''') '' + @crlf + ' + N'''ON '' + ds.data_space + '';'' + '
          + N'@crlf + @crlf COLLATE database_default AS [-- Create Candidate Keys] ' + N'FROM sys.indexes AS i '
          + N'LEFT OUTER JOIN sys.key_constraints AS k ON ' + N'k.parent_object_id = i.object_id '
          + N'AND k.unique_index_id = i.index_id ' + N'CROSS APPLY ' + N'( ' + N'SELECT ' + N'''( '' + @crlf + '
          + N'STUFF ' + N'( ' + N'( ' + N'SELECT ' + N'( ' + N'SELECT '
          + N''','' + @crlf + '' '' + QUOTENAME(c.name) AS [text()] ' + N'FROM sys.index_columns AS ic '
          + N'JOIN sys.columns AS c ON ' + N'c.object_id = ic.object_id ' + N'AND c.column_id = ic.column_id '
          + N'WHERE ' + N'ic.object_id = i.object_id ' + N'AND ic.index_id = i.index_id ' + N'AND ic.key_ordinal > 0 '
          + N'ORDER BY ' + N'ic.key_ordinal ' + N'FOR XML PATH(''''), TYPE ' + N').value(''.'', ''VARCHAR(MAX)'') '
          + N'), ' + N'1, ' + N'3, ' + N''''' ' + N') + @crlf + ' + N''')'' ' + N') AS kc (key_columns) '
          + N'CROSS APPLY ' + N'( ' + N'SELECT ' + N'QUOTENAME(d.name) + ' + N'CASE d.type ' + N'WHEN ''PS'' THEN '
          + N'+ ' + N'''('' + ' + N'( ' + N'SELECT ' + N'QUOTENAME(c.name) ' + N'FROM sys.index_columns AS ic '
          + N'JOIN sys.columns AS c ON ' + N'c.object_id = ic.object_id ' + N'AND c.column_id = ic.column_id '
          + N'WHERE ' + N'ic.object_id = i.object_id ' + N'AND ic.index_id = i.index_id '
          + N'AND ic.partition_ordinal = 1 ' + N') + ' + N''')'' ' + N'ELSE '''' ' + N'END '
          + N'FROM sys.data_spaces AS d ' + N'WHERE ' + N'd.data_space_id = i.data_space_id '
          + N') AS ds (data_space) ' + N'WHERE ' + N'i.object_id = @object_id ' + N'AND i.is_unique = 1 ' +

    --filtered and hypothetical indexes cannot be candidate keys

    CASE @version
        WHEN '2008' THEN
            'AND i.has_filter = 0 '
        ELSE
            ''
    END        + N'AND i.is_hypothetical = 0 ' + N'AND i.is_disabled = 0 ' + N'ORDER BY ' + N'i.index_id ';



    EXEC sp_executesql @sql,
                       N'@object_id INT, @crlf CHAR(2)',
                       @object_id,
                       @crlf;



    SELECT 'ALTER TABLE ' + QUOTENAME(OBJECT_SCHEMA_NAME(fk.parent_object_id)) + '.'
           + QUOTENAME(OBJECT_NAME(fk.parent_object_id)) + @crlf + CASE fk.is_not_trusted
                                                                       WHEN 0 THEN
                                                                           'WITH CHECK '
                                                                       ELSE
                                                                           'WITH NOCHECK '
                                                                   END + 'ADD '
           + CASE fk.is_system_named
                 WHEN 0 THEN
                     'CONSTRAINT ' + QUOTENAME(name) + @crlf
                 ELSE
                     ''
             END + 'FOREIGN KEY ' + @crlf + '( ' + @crlf
           + STUFF(
             (
                 SELECT
                     (
                         SELECT ',' + @crlf + ' ' + QUOTENAME(c.name) AS [text()]
                         FROM sys.foreign_key_columns AS fc
                             JOIN sys.columns AS c
                                 ON c.object_id = fc.parent_object_id
                                    AND c.column_id = fc.parent_column_id
                         WHERE fc.constraint_object_id = fk.object_id
                         ORDER BY fc.constraint_column_id
                         FOR XML PATH(''), TYPE
                     ).value('.', 'VARCHAR(MAX)')
             ),
             1,
             3,
             ''
                  ) + @crlf + ') ' + 'REFERENCES ' + QUOTENAME(OBJECT_SCHEMA_NAME(fk.referenced_object_id)) + '.'
           + QUOTENAME(OBJECT_NAME(fk.referenced_object_id)) + @crlf + '( ' + @crlf
           + STUFF(
             (
                 SELECT
                     (
                         SELECT ',' + @crlf + ' ' + QUOTENAME(c.name) AS [text()]
                         FROM sys.foreign_key_columns AS fc
                             JOIN sys.columns AS c
                                 ON c.object_id = fc.referenced_object_id
                                    AND c.column_id = fc.referenced_column_id
                         WHERE fc.constraint_object_id = fk.object_id
                         ORDER BY fc.constraint_column_id
                         FOR XML PATH(''), TYPE
                     ).value('.', 'VARCHAR(MAX)')
             ),
             1,
             3,
             ''
                  ) + @crlf + ');' + @crlf + @crlf COLLATE DATABASE_DEFAULT AS [-- Create Referencing FKs]
    FROM sys.foreign_keys AS fk
    WHERE referenced_object_id = @object_id
          AND is_disabled = 0
    ORDER BY key_index_id;



END;


--Kullanımı

EXEC [dbo].[TabloKeylerininScriptiniAl] @table_name = 'Production.Product';

After creating the procedure, let’s run it.

As you can see, the script of the Primary Key, Foreign Key and Index Key fields has been created.

Good luck to everyone in business and life.

The post Scripting Table Key Fields in SQL Server first appeared on MSSQL Query.

In this article, I will try to share information about searching words in all tables in SQL Server.

In SQL Server, in some cases, we may want to find a word we want in all tables.

You can easily do this using the procedure below.

Note: It may cause performance problems in tables with a large number of records or tables. You can use it in Small and Medium databases.

CREATE   PROC SearchingforWordsinAllTables
(@WordToSearch NVARCHAR(100))
AS
BEGIN

    CREATE TABLE #Sonuc
    (
        ColumnName NVARCHAR(370),
        ColumnValue NVARCHAR(3630)
    );

    SET NOCOUNT ON;

    DECLARE @TableName NVARCHAR(256),
            @ColumnName NVARCHAR(128),
            @Word NVARCHAR(110);

    SET @TableName = N'';
    SET @Word = QUOTENAME('%' + @WordToSearch + '%', '''');

    WHILE @TableName IS NOT NULL
    BEGIN
        SET @ColumnName = N'';
        SET @TableName =
        (
            SELECT MIN(QUOTENAME(TABLE_SCHEMA) + '.' + QUOTENAME(TABLE_NAME))
            FROM INFORMATION_SCHEMA.TABLES
            WHERE TABLE_TYPE = 'BASE TABLE'
                  AND QUOTENAME(TABLE_SCHEMA) + '.' + QUOTENAME(TABLE_NAME) > @TableName
                  AND OBJECTPROPERTY(OBJECT_ID(QUOTENAME(TABLE_SCHEMA) + '.' + QUOTENAME(TABLE_NAME)), 'IsMSShipped') = 0
        );

        WHILE (@TableName IS NOT NULL) AND (@ColumnName IS NOT NULL)
        BEGIN
            SET @ColumnName =
            (
                SELECT MIN(QUOTENAME(COLUMN_NAME))
                FROM INFORMATION_SCHEMA.COLUMNS
                WHERE TABLE_SCHEMA = PARSENAME(@TableName, 2)
                      AND TABLE_NAME = PARSENAME(@TableName, 1)
                      AND DATA_TYPE IN ( 'char', 'varchar', 'nchar', 'nvarchar','ntext' )
                      AND QUOTENAME(COLUMN_NAME) > @ColumnName
            );
            IF @ColumnName IS NOT NULL
            BEGIN
                INSERT INTO #Sonuc
                EXEC ('SELECT ''' + @TableName + '.' + @ColumnName + ''', LEFT(CAST(' + @ColumnName + 'as varchar(max)), 3630) FROM ' + @TableName + ' (NOLOCK) ' + ' WHERE ' + @ColumnName + ' LIKE ' + @Word);
            END;
        END;
    END;

    SELECT ColumnName,
           ColumnValue
    FROM #Sonuc;

END;

--Use of Procedure

EXEC SearchingforWordsinAllTables  'Dried fruit and bean curd';

Let’s create the procedure and test it.

When you run the procedure, you will see a result like the one above.

The procedure searches ‘CHAR’, ‘VARCHAR’, ‘NCHAR’, ‘NVARCHAR’, ‘NTEXT’ fields.

Good luck to everyone in business and life.

The post Searching for Words in All Tables in SQL Server first appeared on MSSQL Query.

In this article, I will give information about the prime number checking procedure in SQL Server.

You can constantly improve yourself by making such examples in SQL Server.

You can easily do this with the help of the code below.

CREATE PROC IsNumberPrime @Number INT
AS
DECLARE @Counter INT;
SET @Counter = 2;
BEGIN
    WHILE (@Counter) < @Number
    BEGIN
        IF (@Number % @Counter = 0)
        BEGIN
            SELECT 'Not Prime';
            RETURN;
        END;
        SET @Counter = @Counter + 1;
    END;
    SELECT 'Prime';
    RETURN;
END;

--Kullanımı 

EXEC dbo.IsNumberPrime @Number = 20;
EXEC dbo.IsNumberPrime @Number = 23;

When you create the procedure and run the code, you will get a result like the one below.

As you can see, the prime number checking procedure has been created.

Good luck to everyone in business and life.

The post Prime Number Checking Procedure in SQL Server first appeared on MSSQL Query.