SQL Function to ignore specific criteria - sql

Question

I often write SQL scripts that have repetitive several lines in the WHERE statement to eliminate records.
For instance:
SELECT *
FROM tblAll
WHERE Field1 NOT LIKE '%AA%'
AND Field1 NOT LIKE '%BB%'
AND Field1 NOT LIKE '%00'
It would be less prone to mistakes if I didn't have to add these lines each time. How can I create a function that would help me to do this instead?:
SELECT *
FROM tblAll
WHERE Field1 NOT LIKE Function
This is what I have currently:
CREATE FUNCTION [dbo].[ExcludeField1]
(
#Field1 varchar(max),
#Date datetime
)
RETURNS VARCHAR(15) AS
BEGIN
DECLARE #Field1 varchar(15)
DECLARE #Date datetime
SELECT TOP 1 #Field1=Field1 ,#Date=Date
FROM tblAll A
WHERE A.Date=#Date
AND Field1 NOT LIKE '%AA%'
AND Field1 NOT LIKE 'BB%'
AND Field1 NOT LIKE '%00%'
ORDER BY LEN(A.Field1) ASC ;
RETURN #Field1
END
GO
But I feel I'm missing something vital. The function only provides what I consider to be valid values for Field1. So my future scripts should be:
Field1 = #Field1
What's not right?

Answer 1

What you are trying to do may not be the best approach.
You are trying to short circuit the speed of the code by adding in something that makes it easier to program.
If you have large files, this could be disastrous. If you have small files, it's still cumbersome.
You may find it better (and more readable) to create a temp table that executes just your repetitive stuff first, and then call that smaller temp file into your other code. This makes it more readable for future people finding your code AND reduces the size (and complexity) of your following code. Depending on the type of SQL you are running, you may even be able to put your temp table code into a sub proc that can be called before each SQL query that needs it.
Still, you'll get better performance just adding in the extra code to each query that needs it. That way SQL can decide what the fastest way is to grab your data and send it back to you. (Even if the SQL code is much bulkier and you have to repeat the same snippets in lots of different queries.)
However if you insist on being able to insert code snippets that don't change. You could try building the SQL code in a different language (like Visual Basic, C, or VBA, etc) where you can create a string of code. Then you can connect to your SQL database and send the generated SQL code over and have it executed. This gives you the luxury of building all kinds of Frankenstein code. (And could even let you build interaction front ends so users can add all kinds of different parameters.) But beware... there be all kinds of nasty dragons for you play with in those caves.
Personally, I'd go with temp files if your goal is to simplify and bring some order to your repetitive code.
Hope that helps a bit. :)
EDIT
Oooops, let's not forget dynamic SQL (if your version of SQL has it):
DECLARE #sql nvarchar(max);
DECLARE #snippet nvarchar(max);
set #snippet=
'Field1 NOT LIKE ''%AA%''
AND Field1 NOT LIKE ''%BB%''
AND Field1 NOT LIKE ''%00''';
set #sql=
'SELECT
Field1
,Field2
FROM tblAll
WHERE '
+ #snippet +
'ORDER BY
Field1;'
exec(#sql);
This is actually the best way for you to control repetitive code. It allows you to lock it down in one variable that you can insert into larger/many SQL statements. That way, if you need to make future changes to the snippet, you only need to make the change in one place instead of having to hunt down all the queries that have the code.
But it also gives the ability for the SQL engine to create the fastest code for returning your data.
Remember... function calls can be very expensive for processing. Avoid them if possible.