Add files via upload

Author: exajobs

User_Defined_Function/FN_SPLIT.sql

@@ -0,0 +1,104 @@
+# Microsoft SQL Server functions
+Start all functions from if exist statement:
+```sql
+IF OBJECT_ID('dbo.udf_FunctionName', 'FN') IS NULL
+EXECUTE ('CREATE FUNCTION dbo.udf_FunctionName() RETURNS INT AS BEGIN RETURN 1 END;');
+GO
+
+
+ALTER FUNCTION dbo.udf_FunctionName(
+```
+
+It helps to save all grants for function (analog `CREATE OR REPLACE PROCEDURE` in [Oracle](http://docs.oracle.com/cd/B19306_01/server.102/b14200/statements_6009.htm 'Offical Oracle Documentation')).
+
+
+## [udf_PatExclude8K](udf_PatExclude8K.sql)
+Author: Alan Burstein<br/>
+Original link: http://www.sqlservercentral.com/scripts/T-SQL/117890/<br />
+Tested on SQL Server version: 2008/2012/2014/2016<br />
+Purpose: Given a string (@String) and a pattern (@Pattern) of characters to remove, remove the patterned characters from the string.<br />
+Usage:
+```sql
+--===== Basic Syntax Example
+ SELECT CleanedString 
+ FROM dbo.udf_PatExclude8K(@String, @Pattern);
+
+--===== Remove all but Alpha characters
+ SELECT CleanedString
+ FROM dbo.SomeTable st
+ CROSS APPLY dbo.udf_PatExclude8K(st.SomeString,'%[^A-Za-z]%');
+
+--===== Remove all but Numeric digits
+ SELECT CleanedString
+ FROM dbo.SomeTable st
+ CROSS APPLY dbo.udf_PatExclude8K(st.SomeString,'%[^0-9]%');
+```
+
+
+## [udf_GetNumsAB](udf_GetNumsAB.sql)
+Author: Alan Burstein<br/>
+Original link: http://www.sqlservercentral.com/scripts/Set+Based/139370/<br />
+Tested on SQL Server version: 2008/2012/2014/2016<br />
+Purpose: Creates up to 100,544,625 sequential numbers beginning with @low and ending with @high. Used to replace iterative methods such as loops, cursors and recursive CTEs to solve SQL problems. Based on Itzik Ben-Gan's getnums function with some tweeks and enhancements and added functionality. The logic for getting rn to begin at 0 or 1 is based comes from Jeff Moden's fnTally function.<br />
+Usage:
+```sql
+--===== 1. Using RN (rownumber)
+ -- (1.1) The best way to get the numbers 1,2,3...@high (e.g. 1 to 5):
+ SELECT RN FROM dbo.udf_GetNumsAB(1,5,1,1);
+
+ -- (1.2) The best way to get the numbers 0,1,2...@high-1 (e.g. 0 to 5):
+ SELECT RN FROM dbo.udf_GetNumsAB(0,5,1,0);
+
+--===== 2. Using N1
+ -- (2.1) To begin with numbers other than 0 or 1 use N1 (e.g. -3 to 3):
+ SELECT N1 FROM dbo.udf_GetNumsAB(-3,3,1,1);
+
+ -- (2.2) ROW_NUMBER() is built in. If you want a ROW_NUMBER() include RN:
+ SELECT RN, N1 FROM dbo.udf_GetNumsAB(-3,3,1,1);
+
+ -- (2.3) If you wanted a ROW_NUMBER() that started at 0 you would do this:
+ SELECT RN, N1 FROM dbo.udf_GetNumsAB(-3,3,1,0);
+
+--===== 3. Using N2 and @gap
+ -- (3.1) To get 0,10,20,30...100, set @low to 0, @high to 100 and @gap to 10:
+ SELECT N1 FROM dbo.udf_GetNumsAB(0,100,10,1);
+
+ -- (3.2) Note that N2=N1+@gap; this allows you to create a sequence of ranges.
+ --       For example, to get (0,10),(10,20),(20,30).... (90,100):
+ SELECT N1, N2 FROM dbo.udf_GetNumsAB(0,90,10,1);
+
+ -- (3.3) Remember that a rownumber is included and it can begin at 0 or 1:
+ SELECT RN, N1, N2 FROM dbo.udf_GetNumsAB(0,90,10,1);
+
+--===== (4) A real life example using RN, N1 and N2:
+ -- Beginning with @StartDate, to generate ranges of weeks that occur between 
+ -- @startDate & @EndDate:
+```
+
+
+## [udf_Is16digitValidCard](udf_Is16digitValidCard.sql)
+Author: Phil Factor<br/>
+Original link: https://www.simple-talk.com/blogs/2016/02/16/the-luhn-algorithm-in-sql/<br />
+Tested on SQL Server version: 2008/2012/2014/2016<br />
+Description: The Luhn test is used by most credit card companies to check the basic validity of a credit card number. It is not an anti-fraud measure but a quick check on data corruption. It still allows any digits that are odd or even to be switched in the sequence. Most credit cards are compatible with Luhn algorithm.
+1. It is often applied to SSNs, company organization numbers, and OCR numbers for internet payments. The algorithm is simple.
+2. Take out the spaces from the string containing the credit card numbers
+3. Reverse the string containing the credit card numbers.
+4. Sum every digit whose order in the sequence is an odd number (1,3,5,7 …) to create a partial sum s1
+5. Multiply each even digit by two, and then sum the digits of the number if the answer is greater than nine. (e,g if digit is 8 then 8*2=16, then add the resulting digits: 1+6=7).
+6. Sum the partial sums of the even digits to form s2
+7. if s1 + s2 ends in zero then the original number is in the form of a valid credit card number as verified by the Luhn test.
+
+
+## [udf_IsValidCard](udf_IsValidCard.sql)
+Author: Phil Factor<br/>
+Original link: https://www.simple-talk.com/blogs/2016/02/16/the-luhn-algorithm-in-sql/<br />
+Tested on SQL Server version: 2008/2012/2014/2016<br />
+Description: The Luhn test is used by most credit card companies to check the basic validity of a credit card number. It is not an anti-fraud measure but a quick check on data corruption. It still allows any digits that are odd or even to be switched in the sequence. Most credit cards are compatible with Luhn algorithm.
+1. It is often applied to SSNs, company organization numbers, and OCR numbers for internet payments. The algorithm is simple.
+2. Take out the spaces from the string containing the credit card numbers
+3. Reverse the string containing the credit card numbers.
+4. Sum every digit whose order in the sequence is an odd number (1,3,5,7 …) to create a partial sum s1
+5. Multiply each even digit by two, and then sum the digits of the number if the answer is greater than nine. (e,g if digit is 8 then 8*2=16, then add the resulting digits: 1+6=7).
+6. Sum the partial sums of the even digits to form s2
+7. if s1 + s2 ends in zero then the original number is in the form of a valid credit card number as verified by the Luhn test.

User_Defined_Function/README.md

@@ -0,0 +1,25 @@
+IF OBJECT_ID('dbo.udf_ConvertHexLSN') IS NULL
+   EXECUTE ('CREATE FUNCTION udf_ConvertHexLSN() RETURNS TABLE AS RETURN SELECT 1 AS A;');
+GO
+
+
+ALTER FUNCTION dbo.udf_ConvertHexLSN(
+    @lsnc varchar(25)
+)
+/*
+Author: Max Vernon
+Original link: https://www.sqlserverscience.com/internals/convert-lsn-hex-decimal/
+
+SELECT * FROM dbo.udf_ConvertHexLSN('00000268:0000356c:0001');
+*/
+RETURNS TABLE
+WITH SCHEMABINDING
+AS
+    RETURN
+    (
+        SELECT TOP(1)
+               LSNd = CONVERT(varchar(8), CONVERT(int, CONVERT(varbinary(8), '0x' + CONVERT(varchar(10),      LEFT(@lsnc, 8), 0), 1), 1))
+              + ':' + CONVERT(varchar(8), CONVERT(int, CONVERT(varbinary(8), '0x' + CONVERT(varchar(10), SUBSTRING(@lsnc, 10, 8), 0), 1)), 1)
+              + ':' + CONVERT(varchar(8), CONVERT(int, CONVERT(varbinary(8), '0x' + CONVERT(varchar(10),     RIGHT(@lsnc, 4), 0), 1), 1))
+    );
+GO

User_Defined_Function/dbo.ConvertHexLSN.sql

@@ -0,0 +1,64 @@
+IF OBJECT_ID('dbo.udf_InitCap') IS NULL
+   EXECUTE ('CREATE FUNCTION dbo.udf_InitCap() RETURNS nvarchar(max) AS RETURN SELECT 1 AS A;');
+GO
+
+ALTER FUNCTION dbo.udf_InitCap(
+    @StrStr nvarchar(max)
+    )
+/*
+SELECT dbo.udf_InitCap(N'test STRING ß');
+
+Source link: https://github.com/ktaranov/sqlserver-kit/blob/master/User_Defined_Function/dbo.udf_InitCap.sql
+Original link: https://gist.github.com/jef-sure/f67bc2c06c4804ca832f1dc5550c8db4
+Author: Anton Petrusevich
+Created Date: 2018-09-24
+Modified Date: 2019-07-23 by Konstantin Taranov
+*/
+RETURNS nvarchar(max) AS
+BEGIN
+     DECLARE @StrNew nvarchar(max);
+     DECLARE @c nvarchar(1);
+     DECLARE @x integer;
+     DECLARE @StrLen integer;
+     DECLARE @CloseBracket nvarchar(5);
+     DECLARE @OpenBracket varchar(5);
+     DECLARE @mode varchar(20) = 'upper';
+     SELECT @StrNew = '', @x = 1, @StrLen = LEN(@StrStr)+1;
+     SELECT @OpenBracket = CHAR(34) + CHAR(39) + CHAR(40) + CHAR(91) + CHAR(123);
+     SELECT @CloseBracket = CHAR(34) + CHAR(39) + CHAR(41) + CHAR(93) + CHAR(125);
+     WHILE @x < @StrLen
+     BEGIN 
+        SET @c = SUBSTRING(@StrStr, @x, 1);
+        DECLARE @pbi INT;
+        DECLARE @cb NCHAR(1);
+        IF @c = 'ß' or unicode(LOWER(@c)) <> unicode(UPPER(@c))
+        BEGIN
+            IF @mode = 'lower'
+                SET @c = lower(@c);
+            IF @mode = 'upper'
+            BEGIN
+                SET @c = upper(@c);
+                SET @mode = 'lower';
+            END;
+        END;
+        ELSE
+        BEGIN
+            SET @pbi = CHARINDEX(@c, @OpenBracket);
+            IF @pbi <> 0
+            BEGIN
+                SET @cb = SUBSTRING(@CloseBracket, @pbi, 1);
+                SET @mode = 'preserve';
+            END
+            ELSE
+                IF @mode <> 'preserve'
+                    SET @mode = 'upper';
+                ELSE
+                    IF @c = @cb
+                        SET @mode = 'upper';
+        END;
+        SET @StrNew = @StrNew + @c;
+        SET @x = @x +1;
+    END;
+    RETURN @StrNew;
+END;
+GO

User_Defined_Function/dbo.udf_InitCap.sql

@@ -0,0 +1,116 @@
+IF OBJECT_ID('dbo.udf_LCS') IS NULL
+   EXECUTE ('CREATE FUNCTION dbo.udf_LCS() RETURNS nvarchar(max) AS RETURN SELECT 1 AS A;');
+GO
+
+
+ALTER FUNCTION dbo.udf_LCS
+  /**
+summary:   >
+ The longest common subsequence (LCS) problem is the problem of finding the
+ longest subsequence common to all sequences in two sequences. It differs
+ from problems of finding common substrings: unlike substrings, subsequences
+ are not required to occupy consecutive positions within the original
+ sequences. For example, the sequences "1234" and "1224533324" have an LCS of "1234"
+Author: Phil Factor
+Revision: 1.1
+Created Date: 2019-04-05
+Modified date: 2019-07-08 Konstantin Taranov
+Original link: https://www.red-gate.com/simple-talk/blogs/using-json-for-matrices-in-sql-server/
+example:
+ code:
+     SELECT dbo.udf_LCS ('1234', '1224533324');
+     SELECT dbo.udf_LCS ('thisisatest', 'testing123testing');
+     SELECT dbo.udf_LCS ( 'XMJYAUZ', 'MZJAWXU');
+     SELECT dbo.udf_LCS ( 'beginning-middle-ending', 'beginning-diddle-dum-ending');
+returns:   >
+  the longest common subsequence as a string
+**/
+  (@xString varchar(max), @yString varchar(max))
+RETURNS varchar(max)
+AS
+  BEGIN
+
+    DECLARE @ii int = 1; --inner index
+    DECLARE @jj int = 1; --next loop index
+    DECLARE @West int; --array reference number to left
+    DECLARE @NorthWest int; --array reference previous left
+    DECLARE @North int; --array reference previous
+    DECLARE @Max int; --holds the maximum of two values
+    DECLARE @Current int; --current number of matches
+    DECLARE @Matrix nvarchar(max);
+    DECLARE @PreviousRow nvarchar(2000); -- the previous matrix row
+    DECLARE @JSON nvarchar(4000); --json work variable
+    DECLARE @Numbers TABLE (jj int);
+-- SQL Prompt formatting off
+
+INSERT INTO @Numbers(jj) --this is designed for words of max 40 characters
+VALUES(1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13),(14),(15),
+      (16),(17),(18),(19),(20),(21),(22),(23),(24),(25),(26),(27),(28),
+      (29),(30),(31),(32),(33),(34),(35),(36),(37),(38),(39),(40)
+-- SQL Prompt formatting on
+--the to start with, the first row is all zeros.
+    SELECT @PreviousRow =
+      N'[' + Replicate('0,', Len(@xString) + 1) + N'"'
+      + Substring(@yString, 1, 1) + N'"]';
+    SELECT @Matrix = @PreviousRow;--add this to the matrix
+    /* we now build the matrix in bottom up fashion.  */
+    WHILE (@ii <= Len(@yString))
+      BEGIN
+        SELECT @West = 0, @JSON = NULL;
+        --now create a row in just one query
+        SELECT @NorthWest =
+          Json_Value(@PreviousRow, '$[' + Cast(jj - 1 AS varchar(5)) + ']'),
+          @North =
+            Json_Value(@PreviousRow, '$[' + Cast(jj AS varchar(5)) + ']'),
+          @Max = CASE WHEN @West > @North THEN @West ELSE @North END,
+          @Current =
+            CASE WHEN Substring(@xString, jj, 1) = Substring(@yString, @ii, 1) THEN
+                   @NorthWest + 1 ELSE @Max END,
+          @JSON =
+            Coalesce(@JSON + ',', '[0,')
+            + Coalesce(Cast(@Current AS varchar(5)), 'null'), @West = @Current
+          FROM @Numbers AS f
+          WHERE f.jj <= Len(@xString);
+          --and store the result as the previous row
+        SELECT @PreviousRow =
+               @JSON + N',"' + Substring(@yString, @ii, 1) + N'"]';
+          --and add the reow to the matrix
+        SELECT @Matrix = Coalesce(@Matrix + ',
+               ', '') + @PreviousRow, @ii = @ii + 1;
+      END;
+    --we add the boundong brackets.
+    SELECT @Matrix = N'[' + @Matrix + N']';
+    SELECT @ii = Len(@yString), @jj = Len(@xString);
+    DECLARE @previousColScore INT, @PreviousRowScore INT, @Ychar NCHAR;
+    DECLARE @Subsequence NVARCHAR(4000) = '';
+    WHILE (@Current > 0)
+      BEGIN
+        SELECT @Ychar = Substring(@yString, @ii, 1);
+        IF (@Ychar = Substring(@xString, @jj, 1))
+-- If current character in X[] and Y[] are same, then it is part of LCS
+          SELECT @ii = @ii - 1, @jj = @jj - 1,
+            @Subsequence = @Ychar + @Subsequence, @Current = @Current - 1;
+        ELSE
+--If not same, then find the larger of two and traverse in that direction 
+          BEGIN
+            --find out the two scores, one to the north and one to the west
+            SELECT @PreviousRowScore =
+              Json_Value(
+                          @Matrix,
+                          'strict $[' + Convert(varchar(5), @ii - 1) + ']['
+                          + Convert(varchar(5), @jj) + ']'
+                        ),
+              @previousColScore =
+                Json_Value(
+                            @Matrix,
+                            'strict $[' + Convert(varchar(5), @ii) + ']['
+                            + Convert(varchar(5), @jj - 1) + ']'
+                          );
+           --either go north or west
+            IF @PreviousRowScore < @previousColScore SELECT @jj = @jj - 1;
+            ELSE SELECT @ii = @ii - 1;
+          END;
+      END;
+    RETURN @Subsequence;
+  END;
+GO