Indian Currency To Words In Sql Server

CREATE FUNCTION [dbo].[GetNumberToWords] (@intNumberValue INTEGER)
RETURNS VARCHAR(2000)
AS
BEGIN
    DECLARE @strNumberString VARCHAR(9)
    DECLARE @strReturn VARCHAR(2000)
    DECLARE @intUnits SMALLINT

    -- Alter table of number groups
    DECLARE @tblNumberGroups TABLE
    (
        Units SMALLINT,
        Hundreds SMALLINT,
        Tens SMALLINT
    )

    -- Handle errors and 'quick wins'
    IF @intNumberValue IS NULL
        RETURN NULL
    IF ISNUMERIC(@intNumberValue) = 0
        RETURN NULL
    IF @intNumberValue = 0
        RETURN 'ZERO'

    IF @intNumberValue < 0
    BEGIN
        SET @strReturn = 'MINUS '
        SET @intNumberValue = ABS(@intNumberValue)
    END

    SET @intUnits = 0

    -- Populate table of number groups
    WHILE (@intNumberValue % 1000) > 0 OR (@intNumberValue / 1000) > 0
    BEGIN
        INSERT INTO @tblNumberGroups
        (
            Units,
            Hundreds,
            Tens
        )
        VALUES
        (@intUnits, (@intNumberValue % 1000) / 100, (@intNumberValue % 1000) % 100)
        SELECT @intNumberValue = CAST(@intNumberValue / 1000 AS INTEGER)
        SET @intUnits = @intUnits + 1
    END

    -- Remove last unit added
    SET @intUnits = @intUnits - 1

    -- Concatenate text number by reading number groups in reverse order
    SELECT @strReturn
        = ISNULL(@strReturn, ' ')
          + ISNULL(
                      ISNULL((CASE Hundreds
                                  WHEN 1 THEN
                                      'ONE HUNDRED '
                                  WHEN 2 THEN
                                      'TWO HUNDRED '
                                  WHEN 3 THEN
                                      'THREE HUNDRED '
                                  WHEN 4 THEN
                                      'FOUR HUNDRED '
                                  WHEN 5 THEN
                                      'FIVE HUNDRED '
                                  WHEN 6 THEN
                                      'SIX HUNDRED '
                                  WHEN 7 THEN
                                      'SEVEN HUNDRED '
                                  WHEN 8 THEN
                                      'EIGHT HUNDRED '
                                  WHEN 9 THEN
                                      'NINE HUNDRED '
                              END
                             ),
                             ' '
                            ) + CASE
                                    WHEN (
                                             Hundreds > 0
                                             OR Units < @intUnits
                                         )
                                         AND Tens > 0 THEN
                                        ' AND '
                                    ELSE
                                        ' '
                                END + ISNULL(   (CASE Tens / 10
                                                     WHEN 2 THEN
                                                         'TWENTY '
                                                     WHEN 3 THEN
                                                         'THIRTY '
                                                     WHEN 4 THEN
                                                         'FORTY '
                                                     WHEN 5 THEN
                                                         'FIFTY '
                                                     WHEN 6 THEN
                                                         'SIXTY '
                                                     WHEN 7 THEN
                                                         'SEVENTY '
                                                     WHEN 8 THEN
                                                         'EIGHTY '
                                                     WHEN 9 THEN
                                                         'NINETY '
                                                 END
                                                ),
                                                ' '
                                            ) + ISNULL(   (CASE Tens
                                                               WHEN 10 THEN
                                                                   'TEN '
                                                               WHEN 11 THEN
                                                                   'ELEVEN '
                                                               WHEN 12 THEN
                                                                   'TWELVE '
                                                               WHEN 13 THEN
                                                                   'THIRTEEN '
                                                               WHEN 14 THEN
                                                                   'FOURTEEN '
                                                               WHEN 15 THEN
                                                                   'FIFTEEN '
                                                               WHEN 16 THEN
                                                                   'SIXTEEN '
                                                               WHEN 17 THEN
                                                                   'SEVENTEEN '
                                                               WHEN 18 THEN
                                                                   'EIGHTEEN '
                                                               WHEN 19 THEN
                                                                   'NINETEEN '
                                                           END
                                                          ),
                                                          ' '
                                                      )
                      + COALESCE(
CASE
WHEN Tens % 10 = 1
AND Tens / 10 <> 1 THEN
'ONE '
END,
CASE
WHEN Tens % 10 = 2
AND Tens / 10 <> 1 THEN
'TWO '
END,
CASE
WHEN Tens % 10 = 3
AND Tens / 10 <> 1 THEN
'THREE '
END,
CASE
WHEN Tens % 10 = 4
AND Tens / 10 <> 1 THEN
'FOUR '
END,
CASE
WHEN Tens % 10 = 5
AND Tens / 10 <> 1 THEN
'FIVE '
END,
CASE
WHEN Tens % 10 = 6
AND Tens / 10 <> 1 THEN
'SIX '
END,
CASE
WHEN Tens % 10 = 7
AND Tens / 10 <> 1 THEN
'SEVEN '
END,
CASE
WHEN Tens % 10 = 8
AND Tens / 10 <> 1 THEN
'EIGHT '
END,
CASE
WHEN Tens % 10 = 9
AND Tens / 10 <> 1 THEN
'NINE '
END, ' '
)
                      + COALESCE(
CASE
WHEN Units = 1
AND (
Hundreds > 0
OR Tens > 0
) THEN
'THOUSAND '
END,
CASE
WHEN Units = 2
AND (
Hundreds > 0
OR Tens > 0
) THEN
'MILLION '
END,
CASE
WHEN Units = 3
AND (
Hundreds > 0
OR Tens > 0
) THEN
'BILLION '
END,
CASE
WHEN Units = 4
AND (
Hundreds > 0
OR Tens > 0
) THEN
'TRILLION '
END, ' '),
                      ' '
                  )
    FROM @tblNumberGroups
    ORDER BY units DESC

    -- Get rid of all the spaces
    WHILE CHARINDEX('  ', @strReturn) > 0
    BEGIN
        SET @strReturn = REPLACE(@strReturn, '  ', ' ')
    END

    SET @strReturn = LTRIM(RTRIM(@strReturn))

    RETURN @strReturn
END

GO
----------------------------------********************************----------------------------------------

CREATE FUNCTION [dbo].[GetNumericToRupees] (@RUPEES AS DECIMAL(30, 2))
RETURNS VARCHAR(2000)
AS
BEGIN
    DECLARE @INNTBL_01 TABLE
    (
        RECNO INT IDENTITY(1, 1),
        MTEXT NVARCHAR(50)
    )

    DECLARE @INNTBL_02 TABLE
    (
        RECNO INT IDENTITY(1, 1),
        MTEXT NVARCHAR(50)
    )

    DECLARE @AMOUNT NUMERIC(38, 0)

    DECLARE @PAISE AS INT

    SET @AMOUNT = FLOOR(@RUPEES)

    SET @PAISE = CAST(CONVERT(DECIMAL(10, 0), (@RUPEES % 1) * 100) AS INT)


    --STEP 2:

    --NOW ADD UP THE SALT AND PEPPER ONTO TABLE  I.E. INSERT THE WORDS INTO IT

    INSERT INTO @INNTBL_01
    SELECT 'One '

    INSERT INTO @INNTBL_01
    SELECT 'Two '

    INSERT INTO @INNTBL_01
    SELECT 'Three '

    INSERT INTO @INNTBL_01
    SELECT 'Four '

    INSERT INTO @INNTBL_01
    SELECT 'Five '

    INSERT INTO @INNTBL_01
    SELECT 'Six '

    INSERT INTO @INNTBL_01
    SELECT 'Seven '

    INSERT INTO @INNTBL_01
    SELECT 'Eight '

    INSERT INTO @INNTBL_01
    SELECT 'Nine '

    INSERT INTO @INNTBL_01
    SELECT 'Ten '

    INSERT INTO @INNTBL_01
    SELECT 'Eleven '

    INSERT INTO @INNTBL_01
    SELECT 'Twelve '

    INSERT INTO @INNTBL_01
    SELECT 'Thirteen '

    INSERT INTO @INNTBL_01
    SELECT 'Fourteen '

    INSERT INTO @INNTBL_01
    SELECT 'Fifteen '

    INSERT INTO @INNTBL_01
    SELECT 'Sixteen '

    INSERT INTO @INNTBL_01
    SELECT 'Seventeen '

    INSERT INTO @INNTBL_01
    SELECT 'Eighteen '

    INSERT INTO @INNTBL_01
    SELECT 'Nineteen '

    INSERT INTO @INNTBL_01
    SELECT 'Twenty '

    -- SIMILARY, INSERT THE MULTIPLES

    INSERT INTO @INNTBL_02
    SELECT 'Ten '

    INSERT INTO @INNTBL_02
    SELECT 'Twenty '

    INSERT INTO @INNTBL_02
    SELECT 'Thirty '

    INSERT INTO @INNTBL_02
    SELECT 'Forty '

    INSERT INTO @INNTBL_02
    SELECT 'Fifty '

    INSERT INTO @INNTBL_02
    SELECT 'Sixty '

    INSERT INTO @INNTBL_02
    SELECT 'Seventy '

    INSERT INTO @INNTBL_02
    SELECT 'Eighty '

    INSERT INTO @INNTBL_02
    SELECT 'Ninety '

    --STEP 3:

    ----CHECK FOR THE LIMIT OF THE AMOUNT I.E. WHAT IS THE PLACE VALUE OF DIGITS -- LACS, THOUSANDS OR HUNDREDS

    DECLARE @WORD VARCHAR(2000)

    SELECT @WORD = ''

    DECLARE @M_AMT01 BigInt,
            @M_AMT02 BigInt

    IF @AMOUNT >= 10000000
    BEGIN

        SET @M_AMT01 = @AMOUNT

        SELECT @AMOUNT = (@AMOUNT % 10000000)



        SET @M_AMT01 = (@M_AMT01 - @AMOUNT) / 10000000

        DECLARE @WORD1 VARCHAR(300)

        SET @WORD1 = ''

        IF @M_AMT01 <= 20
           AND @M_AMT01 <> 0
        BEGIN

            SET @WORD1 =
            (
                SELECT @WORD1 + MTEXT FROM @INNTBL_01 WHERE RECNO = @M_AMT01
            )

        END

        SET @WORD = dbo.GetNumberToWords(@M_AMT01) + ' Crore '

    END

    IF @AMOUNT < 10000000
       AND @AMOUNT >= 100000
    BEGIN

        SET @M_AMT01 = @AMOUNT

        SELECT @AMOUNT = (@AMOUNT % 100000)

        SET @M_AMT01 = (@M_AMT01 - @AMOUNT) / 100000

        SET @WORD1 = ''

        IF @M_AMT01 < 100
           AND @M_AMT01 > 20
        BEGIN

            SET @M_AMT02 = @M_AMT01

            SET @M_AMT01 = (@M_AMT01 % 10)

            SET @M_AMT02 = (@M_AMT02 - @M_AMT01) / 10

            SET @WORD1 =
            (
                SELECT @WORD1 + MTEXT FROM @INNTBL_02 WHERE RECNO = @M_AMT02
            )

        END

        IF @M_AMT01 <= 20
           AND @M_AMT01 <> 0
        BEGIN

            SET @WORD1 =
            (
                SELECT @WORD1 + MTEXT FROM @INNTBL_01 WHERE RECNO = @M_AMT01
            )

        END

        SET @WORD = @WORD + @WORD1 + 'Lakh '

    END

    IF @AMOUNT < 100000
       AND @AMOUNT >= 1000
    BEGIN

        SET @M_AMT01 = @AMOUNT

        SET @AMOUNT = (@AMOUNT % 1000)

        SET @M_AMT01 = (@M_AMT01 - @AMOUNT) / 1000

        SET @WORD1 = ''

        IF @M_AMT01 < 100
           AND @M_AMT01 > 20
        BEGIN

            SET @M_AMT02 = @M_AMT01

            SET @M_AMT01 = (@M_AMT01 % 10)

            SET @M_AMT02 = (@M_AMT02 - @M_AMT01) / 10

            SET @WORD1 =
            (
                SELECT @WORD1 + MTEXT + '' FROM @INNTBL_02 WHERE RECNO = @M_AMT02
            )

        END

        IF @M_AMT01 <= 20
           AND @M_AMT01 <> 0
        BEGIN

            SET @WORD1 =
            (
                SELECT @WORD1 + MTEXT + '' FROM @INNTBL_01 WHERE RECNO = @M_AMT01
            )

        END

        SET @WORD = @WORD + @WORD1 + 'Thousand '

    END

    IF @AMOUNT < 1000
       AND @AMOUNT >= 100
    BEGIN

        SET @M_AMT01 = @AMOUNT

        SET @AMOUNT = (@AMOUNT % 100)

        SET @M_AMT01 = (@M_AMT01 - @AMOUNT) / 100

        SET @WORD =
        (
            SELECT @WORD + ' ' + MTEXT + 'Hundred ' FROM @INNTBL_01 WHERE RECNO = @M_AMT01
        )

    END

    IF @AMOUNT < 100
       AND @AMOUNT > 20
    BEGIN

        SET @M_AMT01 = @AMOUNT

        SET @AMOUNT = (@AMOUNT % 10)

        SET @M_AMT01 = (@M_AMT01 - @AMOUNT) / 10

        SET @WORD =
        (
            SELECT @WORD + MTEXT + '' FROM @INNTBL_02 WHERE RECNO = @M_AMT01
        )

    END

    IF @AMOUNT <= 20
       AND @AMOUNT >= 1
    BEGIN

        SET @WORD =
        (
            SELECT @WORD + MTEXT + '' FROM @INNTBL_01 WHERE RECNO = @AMOUNT
        )

    END


    SET @WORD = @WORD + ' '

    -- STEP 4:

    -- CALCULATE THE PAISE ALSO.

    DECLARE @WORDP VARCHAR(300)

    SET @WORDP = ''

    IF @PAISE <> 0
    BEGIN

        IF @PAISE < 100
           AND @PAISE > 20
        BEGIN

            DECLARE @PAISE_01 VARCHAR(300)

            SET @PAISE_01 = @PAISE

            SET @PAISE = (@PAISE % 10)

            SET @PAISE_01 = (@PAISE_01 - @PAISE) / 10

            SET @WORDP =
            (
                SELECT @WORDP + MTEXT FROM @INNTBL_02 WHERE RECNO = @PAISE_01
            )

        END

        IF @PAISE <= 20
           AND @PAISE >= 1
        BEGIN

            SET @WORDP =
            (
                SELECT @WORDP + MTEXT FROM @INNTBL_01 WHERE RECNO = @PAISE
            )

        END

        SET @WORD = @WORD + 'and ' + @WORDP + 'paisa'

    END

    IF @AMOUNT >= 1000000000
    BEGIN

        SET @WORD = ''

    END


    SELECT @WORD = REPLACE(@WORD COLLATE Latin1_General_BIN, '  ', ' ');

    Return UPPER(@WORD + ' ONLY')

END
------------------------------------
Go

SELECT  dbo.GetNumericToRupees(625)

Generate Class Object From SQL Table

declare @TableName sysname = 'TABLE_Name'
declare @result Nvarchar(max) = ''

select @result = @result + '
    private ' + ColumnType + ' ' + ' m_' + stuff(replace(ColumnName, '_', ''), 1, 1, lower(left(ColumnName, 1))) + ';'
from
(
    select
        replace(col.name, ' ', '_') ColumnName,
        column_id,
        case typ.name
            when 'bigint' then 'long'
            when 'binary' then 'byte[]'
            when 'bit' then 'bool'
            when 'char' then 'string'
            when 'date' then 'DateTime'
            when 'datetime' then 'DateTime'
            when 'datetime2' then 'DateTime'
            when 'datetimeoffset' then 'DateTimeOffset'
            when 'decimal' then 'decimal'
            when 'float' then 'float'
            when 'image' then 'byte[]'
            when 'int' then 'int'
            when 'money' then 'decimal'
            when 'nchar' then 'char'
            when 'ntext' then 'string'
            when 'numeric' then 'decimal'
            when 'nvarchar' then 'string'
            when 'real' then 'double'
            when 'smalldatetime' then 'DateTime'
            when 'smallint' then 'short'
            when 'smallmoney' then 'decimal'
            when 'text' then 'string'
            when 'time' then 'TimeSpan'
            when 'timestamp' then 'DateTime'
            when 'tinyint' then 'byte'
            when 'uniqueidentifier' then 'Guid'
            when 'varbinary' then 'byte[]'
            when 'varchar' then 'string'
            else 'UNKNOWN_' + typ.name
        end ColumnType
    from sys.columns col
        join sys.types typ on
            col.system_type_id = typ.system_type_id AND col.user_type_id = typ.user_type_id
    where object_id = object_id(@TableName)
) t
order by column_id

SET @result = @result + '
'

select @result = @result + '
    public ' + ColumnType + ' ' + ColumnName + ' { get { return m_' + stuff(replace(ColumnName, '_', ''), 1, 1, lower(left(ColumnName, 1))) + ';} set {m_' + stuff(replace(ColumnName, '_', ''), 1, 1, lower(left(ColumnName, 1))) + ' = value;} }' from
(
    select
        replace(col.name, ' ', '_') ColumnName,
        column_id,
        case typ.name
            when 'bigint' then 'long'
            when 'binary' then 'byte[]'
            when 'bit' then 'bool'
            when 'char' then 'string'
            when 'date' then 'DateTime'
            when 'datetime' then 'DateTime'
            when 'datetime2' then 'DateTime'
            when 'datetimeoffset' then 'DateTimeOffset'
            when 'decimal' then 'decimal'
            when 'float' then 'float'
            when 'image' then 'byte[]'
            when 'int' then 'int'
            when 'money' then 'decimal'
            when 'nchar' then 'char'
            when 'ntext' then 'string'
            when 'numeric' then 'decimal'
            when 'nvarchar' then 'string'
            when 'real' then 'double'
            when 'smalldatetime' then 'DateTime'
            when 'smallint' then 'short'
            when 'smallmoney' then 'decimal'
            when 'text' then 'string'
            when 'time' then 'TimeSpan'
            when 'timestamp' then 'DateTime'
            when 'tinyint' then 'byte'
            when 'uniqueidentifier' then 'Guid'
            when 'varbinary' then 'byte[]'
            when 'varchar' then 'string'
            else 'UNKNOWN_' + typ.name
        end ColumnType
    from sys.columns col
        join sys.types typ on
            col.system_type_id = typ.system_type_id AND col.user_type_id = typ.user_type_id
    where object_id = object_id(@TableName)
) t
order by column_id


SELECT CONVERT(NTEXT,@result)

How To Track Database Changes

CREATE DATABASE Audit


USE [Audit]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO


CREATE PROCEDURE [dbo].[RunDbAudit]

(
    @DataBaseName VARCHAR(100)
)
 
AS
BEGIN


DECLARE @AuditDbName VARCHAR(100);
DECLARE @BaseTable VARCHAR(100);
DECLARE @SqlCmd NVARCHAR(MAX);
DECLARE @ParamDef NVARCHAR(MAX);

SET @BaseTable =  '__DB__'+ @DataBaseName ;
SET @AuditDbName = DB_NAME();




DECLARE @AuditExcludedObjects NVARCHAR(MAX);
SET @AuditExcludedObjects = 'fn_diagramobjects,sysdiagrams,'+@BaseTable+'';

DECLARE @BaseTableCount INT;

SET @SqlCmd = 'SELECT @BaseTableCount = COUNT(*)  FROM '+@AuditDbName+'.INFORMATION_SCHEMA.TABLES
                 WHERE TABLE_CATALOG = @AuditDbName
                 AND  TABLE_NAME = @BaseTable';
SET @ParamDef = '@BaseTable VARCHAR(100), @DataBaseName VARCHAR(100), @AuditDbName VARCHAR(100), @BaseTableCount INT OUTPUT';

                 EXECUTE sp_executesql @SqlCmd,
                 @ParamDef,
                 @BaseTable = @BaseTable, @DataBaseName = @DataBaseName, @AuditDbName = @AuditDbName, @BaseTableCount = @BaseTableCount OUTPUT;


--SELECT @SqlCmd;
--SELECT @BaseTableCount;

IF (@BaseTableCount = 0)
BEGIN

    SET @SqlCmd = '
    SELECT    
    @DataBaseName AS [DB_NAME]
    , name AS [OBJECT_NAME]
    , object_id AS [OBJECT_ID]
    , type AS [OBJECT_TYPE]
    , type_desc AS [TYPE_DESC]
    , create_date AS [CREATED_ON]
    , modify_date AS [MODIFIED_ON]
    , CONVERT(DATETIME,NULL) AS [DELETED_ON]
    , CONVERT(BIT,0) AS [MASTER_TABLE]
    , CONVERT(BIT,0) AS [AUDIT_EXCLUDED]
    , CONVERT(VARCHAR(MAX),'''') AS [CHANGE_INFO]
    , CONVERT(DECIMAL(18,2), 1.00) AS [VERSION]
    INTO [dbo].['+@BaseTable+']
    FROM ['+@DataBaseName+'].sys.objects WHERE type in (''P'',''U'',''FN'',''V'');

    UPDATE [dbo].['+@BaseTable+'] SET [AUDIT_EXCLUDED] = 1 WHERE [OBJECT_NAME] IN (@AuditExcludedObjects)
    ';


    SET @ParamDef = '@AuditExcludedObjects NVARCHAR(MAX), @DataBaseName VARCHAR(100)';
    EXECUTE sp_executesql @SqlCmd,
    @ParamDef,
    @AuditExcludedObjects = @AuditExcludedObjects, @DataBaseName = @DataBaseName
    ;

END
ELSE
BEGIN

------------------------------------------------------------ Audit--------------------------------------------------------------

SET @SqlCmd = '

DECLARE @PrevVer DECIMAL(18,2);
DECLARE @PrevVerDt DATETIME;

DECLARE @NextVer DECIMAL(18,2);
DECLARE @NextVerDt DATETIME;

SET @NextVerDt = GETDATE();
SET @PrevVerDt = (SELECT MAX(MODIFIED_ON) FROM [dbo].['+@BaseTable+'] WHERE [AUDIT_EXCLUDED] = 0);
SET @PrevVer = (SELECT MAX([VERSION]) FROM [dbo].['+@BaseTable+'] WHERE [AUDIT_EXCLUDED] = 0);


SET @NextVer = @PrevVer + 0.01;

IF OBJECT_ID(''tempdb..#temp__DB_OBJECT'') IS NOT NULL DROP TABLE #temp__DB_OBJECT

      SELECT    
      @DataBaseName AS [DB_NAME]
    , name AS [OBJECT_NAME]
    , object_id AS [OBJECT_ID]
    , type AS [OBJECT_TYPE]
    , type_desc AS [TYPE_DESC]
    , create_date AS [CREATED_ON]
    , modify_date AS [MODIFIED_ON]
    , CONVERT(DATETIME,NULL) AS [DELETED_ON]
    , CONVERT(BIT,0) AS [MASTER_TABLE]
    , CONVERT(BIT,0) AS [AUDIT_EXCLUDED]
    , CONVERT(VARCHAR(MAX),'''') AS [CHANGE_INFO]
    , @NextVer AS [VERSION]
    INTO #temp__DB_OBJECT
    FROM ['+@DataBaseName+'].sys.objects WHERE type in (''P'',''U'',''FN'',''V'')
    AND name NOT IN ((SELECT [OBJECT_NAME] FROM [dbo].['+@BaseTable+'] WHERE [AUDIT_EXCLUDED]=1))


    UPDATE P
    SET P.MODIFIED_ON = tmp.MODIFIED_ON, P.[VERSION] = tmp.[VERSION]
    FROM [dbo].['+@BaseTable+'] P
    INNER JOIN #temp__DB_OBJECT tmp ON
    (P.[OBJECT_NAME] = tmp.[OBJECT_NAME] AND P.TYPE_DESC = tmp.TYPE_DESC)
    WHERE P.AUDIT_EXCLUDED = 0
    AND P.MODIFIED_ON <> tmp.MODIFIED_ON



    INSERT INTO [dbo].['+@BaseTable+']
    SELECT t.* FROM #temp__DB_OBJECT t
    LEFT OUTER JOIN [dbo].['+@BaseTable+'] DO ON t.[OBJECT_ID] = DO.[OBJECT_ID]
    WHERE DO.[OBJECT_NAME] IS NULL



    UPDATE P
     SET P.DELETED_ON = @NextVerDt, P.[VERSION] = @NextVer
    FROM [dbo].['+@BaseTable+'] P
    INNER JOIN (
        SELECT
        DO.[OBJECT_NAME],
        DO.[OBJECT_ID],
        DO.[OBJECT_TYPE],
        DO.[TYPE_DESC]
        FROM  [dbo].['+@BaseTable+'] DO
        LEFT OUTER JOIN #temp__DB_OBJECT t ON t.[OBJECT_ID] = DO.[OBJECT_ID]
        WHERE t.[OBJECT_NAME] IS NULL AND DO.AUDIT_EXCLUDED = 0
    ) Q ON (P.[OBJECT_NAME] = Q.[OBJECT_NAME] AND P.OBJECT_TYPE = Q.OBJECT_TYPE AND P.TYPE_DESC = Q.TYPE_DESC)
    WHERE P.[DELETED_ON] IS NULL AND P.AUDIT_EXCLUDED = 0


    DECLARE @CurrentVer DECIMAL(18,2);
    SET @CurrentVer = (SELECT MAX(VERSION) FROM [dbo].['+@BaseTable+'] WHERE AUDIT_EXCLUDED = 0)

    SELECT CASE WHEN @CurrentVer = @NextVer
        THEN ''Current Database Version : '' + CONVERT(VARCHAR,@CurrentVer)  + ''  :: Changes info given below.''
        ELSE ''Current Database Version : '' + CONVERT(VARCHAR,@CurrentVer) + ''  :: Changes in last version given below''
        END AS [Message];

    SELECT * FROM [dbo].['+@BaseTable+'] WHERE [VERSION] = @CurrentVer;


IF OBJECT_ID(''tempdb..#temp__DB_OBJECT'') IS NOT NULL DROP TABLE #temp__DB_OBJECT
';


SET @ParamDef = '@DataBaseName VARCHAR(100)';

EXECUTE sp_executesql @SqlCmd
,@ParamDef
,@DataBaseName = @DataBaseName;


------------------------------------------------------------/Audit--------------------------------------------------------------
END

   


END


exec RunDbAudit 'DATABASE NAME' --RUN 2 TIMES FOR 1st RUN

Convert HTML Tables To DataSet In C#

private DataSet ConvertHTMLTablesToDataSet(string HTML) {
        // Declarations
        DataSet ds = new DataSet();
        DataTable dt = null;
        DataRow dr = null;
        DataColumn dc = null;
        string TableExpression = "<table[^>]*>(.*?)</table>";
        string HeaderExpression = "<th[^>]*>(.*?)</th>";
        string RowExpression = "<tr[^>]*>(.*?)</tr>";
        string ColumnExpression = "<td[^>]*>(.*?)</td>";
        bool HeadersExist = false;
        int iCurrentColumn = 0;
        int iCurrentRow = 0;
        // Get a match for all the tables in the HTML
        MatchCollection Tables = Regex.Matches(HTML, TableExpression, RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase);
        // Loop through each table element
        foreach(Match Table in Tables) {
            // Reset the current row counter and the header flag
            iCurrentRow = 0;
            HeadersExist = false;
            // Add a new table to the DataSet
            dt = new DataTable();
            //Create the relevant amount of columns for this table (use the headers if they exist, otherwise use default names)
            // if (Table.Value.Contains("<th"))
            if (Table.Value.Contains("<th")) {
                // Set the HeadersExist flag
                HeadersExist = true;
                // Get a match for all the rows in the table
                MatchCollection Headers = Regex.Matches(Table.Value, HeaderExpression, RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase);
                // Loop through each header element
                foreach(Match Header in Headers) {
                    dt.Columns.Add(Header.Groups[1].ToString());
                }
            } else {
                for (int iColumns = 1; iColumns <= Regex.Matches(Regex.Matches(Regex.Matches(Table.Value, TableExpression, RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase)[0].ToString(), RowExpression, RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase)[0].ToString(), ColumnExpression, RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase).Count; iColumns++) {
                    dt.Columns.Add("Column " + iColumns);
                }
            }
            //Get a match for all the rows in the table
            MatchCollection Rows = Regex.Matches(Table.Value, RowExpression, RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase);
            // Loop through each row element
            foreach(Match Row in Rows) {
                    // Only loop through the row if it isn't a header row
                    if (!(iCurrentRow == 0 && HeadersExist)) {
                        // Create a new row and reset the current column counter
                        dr = dt.NewRow();
                        iCurrentColumn = 0;
                        // Get a match for all the columns in the row
                        MatchCollection Columns = Regex.Matches(Row.Value, ColumnExpression, RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase);
                        // Loop through each column element
                        foreach(Match Column in Columns) {
                                // Add the value to the DataRow
                                dr[iCurrentColumn] = Column.Groups[1].ToString();
                                // Increase the current column
                                iCurrentColumn++;
                            }
                            // Add the DataRow to the DataTable
                        dt.Rows.Add(dr);
                    }
                    // Increase the current row counter
                    iCurrentRow++;
                }
                // Add the DataTable to the DataSet
            ds.Tables.Add(dt);
        }
        return ds;
    }  

Find out the SQL Database Actual Size and used size

set nocount on
select
   [FileSizeMB]   =
      convert(numeric(10,2),sum(round(a.size/128.,2))),
        [UsedSpaceMB]   =
      convert(numeric(10,2),sum(round(fileproperty( a.name,'SpaceUsed')/128.,2))) ,
        [UnusedSpaceMB]   =
      convert(numeric(10,2),sum(round((a.size-fileproperty( a.name,'SpaceUsed'))/128.,2))) ,
   [Type] =
      case when a.groupid is null then '' when a.groupid = 0 then 'Log' else 'Data' end,
   [DBFileName]   = isnull(a.name,'*** Total for all files ***')
from
   sysfiles a
group by
   groupid,
   a.name
   with rollup
having
   a.groupid is null or
   a.name is not null
order by
   case when a.groupid is null then 99 when a.groupid = 0 then 0 else 1 end,
   a.groupid,
   case when a.name is null then 99 else 0 end,
   a.name

Query to produce time pattern with 30 minutes interval

DECLARE @lTimeinterval INT = 30;

WITH mycte
     AS (SELECT 1                                                                                 AS Time_ID,
                RIGHT(CONVERT(VARCHAR(16), Dateadd(day, Datediff(day, 0, Getdate()), 0), 120), 5) AS Time_Slot
         UNION ALL
         SELECT Time_ID + 1,
                RIGHT(CONVERT(VARCHAR(16), Dateadd(minute, Time_ID * @lTimeinterval, Dateadd(day, Datediff(day, 0, Getdate()), 0)), 120), 5)
         FROM   mycte
         WHERE  Dateadd(minute, Time_ID * @lTimeinterval, Dateadd(day, Datediff(day, 0, Getdate()), 0)) < Dateadd(day, Datediff(day, 0, Getdate()) + 1, 0))
SELECT Time_Slot
FROM   mycte