Umang Patel

Find Replace in Text Column Type

Umang Patel — Mon, 09 Mar 2009 17:30:02 +0000

Text Data Type

Most of the functions and techniques you can use for other character data types will not work on a text data type. The data in columns of data type text are not normally stored on the same data page with the data in other columns of a table. What is stored with the other columns of a table is the pointer that tells SQL Server where it can find the characters you store in the text column. I believe this is what makes SQL Server treat the text data type differently.

You can’t concatenate characters to a text data type the way you would for a varchar column. You must first cast the text column to a varchar and then concatenate. That works fine until you have more than 8,000 characters in your text column.

You can’t use the function’s LEFT, RIGHT, or LEN on a column of data type text without casting the column as varchar(8000). Again, you will be fine unless you have more than 8,000 characters in the column. To get the length you can use the function DATALENGTH instead of LEN.

UPDATETEXT

Use the below SQL script to make find and replace work in the Text type column.

/*** Search & Replace ** Use Ctrl+Shift+M to replace template values**/

set xact_abort on

begin tran

declare @otxt varchar(1000)
set @otxt = ‘’

declare @ntxt varchar(1000)
set @ntxt = ‘’

declare @txtlen int
set @txtlen = len(@otxt)

declare @ptr binary(16)
declare @pos int
declare @id int

declare curs cursor local fast_forward
for
select id,
textptr(),
charindex(@otxt, )-1
from

where
PATINDEX(‘%’ + @otxt + ‘%’, ) > 0

open curs

fetch next from curs into @id, @ptr, @pos

while @@fetch_status = 0
begin
While @pos > 0
BEGIN
  Select
  @pos = CHARINDEX(@otxt, solution) – 1
  FROM
  Where id = @id

print ‘Text found in row id=’ + cast(@id as varchar) + ‘ at pos=’ + cast(@pos as varchar)

updatetext . @ptr @pos @txtlen @ntxt
END
fetch next from curs into @id, @ptr, @pos

end
close curs
deallocate curs
commit tran

Working Hours in a Month – SQL Server

Umang Patel — Mon, 02 Feb 2009 21:09:53 +0000

/*
Type:  Function
Name:  dbo.fnGetWorkingHoursInMonth
Author:  Umang Patel
Dependencies: None
Usage:  select dbo.fnGetWorkingHoursInMonth(getdate(), null)
  select dbo.fnGetWorkingHoursInMonth(’01/01/2008′, 4)
Parameters: @currentDate(datetime)
  - The date to use as a starting point

@workingHoursInADay(int) – Optional, default is 8
- The number of working hours in a day
Description:

Gets the number of business days in a month
*/
create function dbo.fnGetWorkingHoursInMonth(
@currentDate datetime,
@workingHoursInADay int = null
)
returns int
as

begin

if @workingHoursInADay is null
set @workingHoursInADay = 8

return dbo.fnGetBusinessDaysInMonth(@currentDate) * @workingHoursInADay

end

Working Days in a Month – SQL Server

Umang Patel — Mon, 02 Feb 2009 21:08:49 +0000

/*
Type:  Function
Name:  dbo.fnGetBusinessDaysInMonth
Author:  Umang Patel
Dependencies: None
Usage:  select dbo.fnGetBusinessDaysInMonth(getdate())
  select dbo.fnGetBusinessDaysInMonth(’01/01/2008′)
Parameters: @currentDate(datetime)
  - The date to use as a starting point
Description:

Gets the number of business days in a month
*/
alter function dbo.fnGetBusinessDaysInMonth(
@currentDate datetime
)
returns int
as
begin

declare @dateRange int
declare @beginningOfMonthDate datetime, @endOfMonthDate datetime

– Get the beginning of the month
set @beginningOfMonthDate = dateadd(month, -1, dateadd(day, -1, dateadd(month, datediff(month, 0, @currentDate) + 1, 1)))

– Get the the beginning date of the next month
set @endOfMonthDate = dateadd(day, -1, dateadd(month, datediff(month, 0, @currentDate) + 1, 1))

– Get the date range between the beginning and the end of the month
set @dateRange = datediff(day, @beginningOfMonthDate, @endOfMonthDate)

return
(
– Get the number of business days by getting the number
– of full weeks * 5 days a week plus the number days remaining
– minus any days from the remaining days that are a weekend day
select @dateRange / 7 * 5 + @dateRange % 7 -
(
         select count(*)
  from
         (
             select 0 as d
             union
             select 1
             union
             select 2
             union
             select 3
             union
             select 4
             union
             select 5
             union
             select 6
         ) weekdays
         where d < @dateRange % 7
          and
   datename(weekday, dateadd(day, -1, @endOfMonthDate) – d)
          in (‘Saturday’, ‘Sunday’)
)
)

end

SSIS Package Protection Level

Umang Patel — Wed, 07 Jan 2009 21:01:15 +0000

Decrypt package secrets

The default setting for the SSIS package ProtectionLevel property is EncryptSensitiveWithUserKey. When the package is saved, SSIS encrypts only the parts of the package that contain properties that are marked “sensitive,” such as passwords, usernames, and connection strings. Therefore, when the package is reloaded, the current user must satisfy the encryption requirements for the sensitive properties to be decrypted. However, the current user does not have to satisfy the encryption requirements to load the package. When you run the package through a SQL Server Agent job step, the default account is the SQL Server Agent Service account. This default account is most likely a different user than the package author. Therefore, the SQL Server Agent job step can load and start to run the job step, but the package fails because it cannot complete a connection. For example, the package cannot complete an OLE DB connection or an FTP connection. The package fails because it cannot decrypt the credentials that it must have to connect.

Important Consider the development process and the environment to determine which accounts are needed and used on each computer. The EncryptSensitiveWithUserKey setting of the ProtectionLevel property is a powerful setting. This setting should not be discounted because it causes deployment complications at first. You can encrypt the packages when you are logged in to the appropriate account. You can also use the Dtutil.exe SSIS command-line utility to change the protection levels by using a .cmd file and the SQL Server Agent command subsystem. For example, follow these steps. Because you can use the Dtutil.exe utility in batch files and loops, you can follow these steps for several packages at the same time.

Modify the package that you want to encrypt by using a password.
Use the Dtutil.exe utility through an Operating System (cmd Exec) SQL Server Agent job step to change the ProtectionLevel property to EncryptSensitiveWithUserKey. This process involves decrypting the package by using the password, and then re-encrypting the package. The user key that is used to encrypt the package is the SQL Server Agent job step setting in the Run As list.
Note Because the key includes the user name and the computer name, the effect of moving the packages to another computer may be limited.

Other Solution

Set the SSIS Package protection level to EncryptSensitiveWithPassword and this will require to set the protection level password when Package is being run by the SQL Job, its require to set the password while configuring the steps.

But this will resolve the issue with development environment and deploying in the SQL Server.

Delete .svn Folders in Windows

Umang Patel — Tue, 30 Dec 2008 14:24:47 +0000

I found this good script to remove the .svn folders from Windows.

FOR /F “tokens=*” %%G IN (‘DIR /B /AD /S *.svn*’) DO RMDIR /S /Q %%G

Just copy and paste above script and create a batch file with conventional name, and run the batch file from parent folder.

Extension Methods in C# 3.0

Umang Patel — Fri, 12 Dec 2008 19:34:58 +0000

Extension methods are static methods that can be invoked using instance method syntax. In effect, extension methods make it possible to extend existing types and constructed types with additional methods.

Note Extension methods are less discoverable and more limited in functionality than instance methods. For those reasons, it is recommended that extension methods be used sparingly and only in situations where instance methods are not feasible or possible.

Extension members of other kinds, such as properties, events, and operators, are being considered but are currently not supported.

Declaring Extension Methods
Extension methods are declared by specifying the keyword this as a modifier on the first parameter of the methods. Extension methods can only be declared in static classes. The following is an example of a static class that declares two extension methods:namespace

Acme.Utilities
{
public static class Extensions
{
public static int ToInt32(this string s) {
return Int32.Parse(s);
}
public static T[] Slice(this T[] source, int index, int count) {
if (index < result =” new”>

Importing Extension Methods
Extension methods are imported through using-namespace-directives. In addition to importing the types contained in a namespace, a using-namespace-directive imports all extension methods in all static classes in the namespace. In effect, imported extension methods appear as additional methods on the types that are given by their first parameter and have lower precedence than regular instance methods. For example, when the Acme.Utilities namespace from the example above is imported with the using-namespace-directiveusing

Acme.Utilities;
it becomes possible to invoke the extension methods in the static class Extensions

using instance method syntax:string s = “1234″;
int i = s.ToInt32(); // Same as Extensions.ToInt32(s)
int[] digits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int[] a = digits.Slice(4, 3); // Same as Extensions.Slice(digits, 4, 3)

Extension Method Invocations
The detailed rules for extension method invocation are described in the following. In a method invocation of one of the

formsexpr.identifier( )
expr . identifier ( args )
expr . identifier <> ( )
expr . identifier <> ( args )

if the normal processing of the invocation finds no applicable instance methods (specifically, if the set of candidate methods for the invocation is empty), an attempt is made to process the construct as an extension method invocation. The method invocation is first rewritten to one of the following, respectively:identifier ( expr )

identifier ( expr , args )
identifier <> ( expr )
identifier <> ( expr , args )

The rewritten form is then processed as a static method invocation, except for the way in which identifier is resolved: Starting with the closest enclosing namespace declaration, continuing with each enclosing namespace declaration, and ending with the containing compilation unit, successive attempts are made to process the rewritten method invocation with a method group consisting of all accessible extension methods with the name given by identifier imported by the namespace declaration’s using-namespace-directives. The first method group that yields a non-empty set of candidate methods is the one chosen for the rewritten method invocation. If all attempts yield empty sets of candidate methods, a compile-time error occurs.

The preceding rules mean that instance methods take precedence over extension methods, and extension methods imported in inner namespace declarations take precedence over extension methods imported in outer namespace declarations.

For example: using N1;

namespace N1
{
public static class E
{
public static void F(this object obj, int i) { }
public static void F(this object obj, string s) { }
}
}
class A { }
class B
{
public void F(int i) { }
}
class C
{
public void F(object obj) { }
}
class X
{
static void Test(A a, B b, C c) {
a.F(1); // E.F(object, int)
a.F(“hello”); // E.F(object, string)
b.F(1); // B.F(int)
b.F(“hello”); // E.F(object, string)
c.F(1); // C.F(object)
c.F(“hello”); // C.F(object)
}
}

In the example, B’s method takes precedence over the first extension method, and C’s method takes precedence over both extension methods.

Text Qualifier in Column Names

Umang Patel — Fri, 12 Dec 2008 18:00:13 +0000

If you have a flat file with quotes around the data as text qualifiers you may have seen the issue where the headers has the quotes even after you put the quote in as the text qualifier. This is a simple issue to resolve. If you check the box “Columns names in the first data row” SSIS sets the first row as the metadata for the column names.

The problem comes when the data has a text qualifier. The text qualifiers end up in the column names.

At this point some people will and check the “Columns names in the first data row” first, and then put in a text qualifier. The problem with that is the text qualifiers end up in the metadata.

To fix this, always enter the text qualifier first then check the box for the column headers.

This will tell SSIS that the text qualifiers are in the first row before it sets that row as the metadata.