Over the years I’ve developed a way of describing them to other people that seems to help alleviate some of the confusion. I tell people that they are essentially in-line views. I.E. a view definition that only exists within a single query.

Take a look at this:

--*********************************************
--********* Begin CTE Definition **************
--*********************************************
WITH
	cteTotalSales (SalesPersonID, NetSales)
	AS
	(
		SELECT SalesPersonID, ROUND(SUM(SubTotal), 2)
		FROM Sales.SalesOrderHeader 
		WHERE SalesPersonID IS NOT NULL
		GROUP BY SalesPersonID
	)
--*********************************************
--********** End CTE Definition ***************
--*********************************************
--************** Begin Query ******************
--*********************************************
INSERT INTO test
	SELECT
		sp.FirstName + ' ' + sp.LastName AS FullName,
		sp.City + ', ' + StateProvinceName AS Location,
		ts.NetSales 
	FROM Sales.vSalesPerson AS sp
	INNER JOIN cteTotalSales AS ts
		ON sp.BusinessEntityID = ts.SalesPersonID
	ORDER BY ts.NetSales DESC
--*********************************************
--*************** End Query *******************
--*********************************************
--*********** End Scope of CTE ****************
--*********************************************

Obviously they aren’t really views, they are Common Table Expressions, but to all intents and purposes you can treat them just like a view. At least in terms of the single query they are defined for. (Yes I realize you can’t index them or anything else like that.) In terms of multiple CTEs at once, as soon the CTE is defined then it is available to be used at any point until the end of scope (the query). In other words the first CTE can be referenced in the second. The first or second can be referenced in the third etc.

Hopefully this makes it easier to understand what a CTE is and how to use it. They really aren’t all that difficult once you think about them the right way and wow can they be handy!

performant
[per-fawr-muh nt]
noun
1. A piece of code that performs well.
“That script is very performant when run on the cloud.”

And an additional entry will be added for the word ask.

noun
1. a question
“I have an ask about the cloud.”

This will certainly upset some people who have enjoyed long hours complaining that “Performant is not a real word!” and “Ask is not a noun.” Well, now they are.

Knowing Microsoft I’m sure there will be plenty of other changes, however, the most extensive I’ve heard about so far involves the example sentences for each word.

Teach
1. She teaches how to create performant code that runs on the cloud.

Library
1. The cloud has more information than a library.

Rain
1. Rain falls from the cloud.

Anyone surprised? Not me.

TL;DR at the bottom.

Let’s start with a bit of background. I’m going to assume that everyone knows the default port number for the default instance is 1433. I’m further going to assume that everyone has the basic logic skills to understand that named instances cannot use that same port number. By default a named instance uses a dynamic port. This port is generated the first time the instance is started and can but does not always (in fact it’s pretty rare) change each time the instance is re-started. That’s important to remember for later. A dynamic port can but does not always change each time the instance is re-started. Now I said, by default a named instance uses a dynamic port and by default a default instance uses port 1433. In both of these cases, just as you would expect, this is configurable. Using the configuration manager you can easily modify the port being used at an instance or even IP level.

Pro Tip: This means I could have three IP address pointing to the same instance, one of them port 1433, one of them a dynamic port, and the third a static port number other than 1433. Extending this somewhat I can create an instance named ServerA\InstanceName, then add two additional IP addresses aliased ServerB and ServerC. The original IP address ServerA I leave as a dynamic port, the IP address for ServerB I make a static port 54123 and the last IP address I point to port 1433. I can now call that instance ServerA\InstanceName, ServerB\InstanceName, ServerC\InstanceName, and, ServerC with no InstanceName. So it now looks like we have a default instance on ServerC even though in reality it’s a named instance. Personally I find this ability to spoof a default instance really cool and if you want to do some additional reading on it try searching for DNS aliasing.

So since a named instance is probably going to be dynamic and even if it wasn’t we typically use the instance name to connect anyway how does the system know what port number to use? This is where the browser service comes in. The first thing that SQL does is ask the browser service (using port 1434) what port the named instance is using so that the connection can be made using that port. (If no port number or instance name is used it is assumed to be the default instance on port 1433.) So when you use the instance name it’s actually a two step process. Connect to the browser to get the port number, then connect to the SQL Server. Please don’t think this means that it’s faster to use the port number. We are talking a very small fraction of a second, once, for the entire connection. No one will notice.

Typically we use the name of the instance instead of the port number just in case the port number changes after a reboot. Not to mention the fact that a name is much easier for a person to understand than a number. It’s pretty easy to understand what ServerA\TEST is going to be used for, ServerA:52345 not so much.

This is a long way to go to get to my mistake right? Necessary background, sorry.

So when would it be best to use the port number rather than the instance name? When there is a firewall involved. Ports on a firewall have to be specifically opened (at least the ones I’ve dealt with do, I’m not an expert). That means that if the port changes dynamically the new port is going to be blocked by the firewall. This is not good. Particularly in production. So my first piece of advice to you is to make sure that your port is set to static if you are working behind a firewall. Next, you will remember that I said that calling an instance by name is a two step process, right? Two steps, two ports. That means that two holes have to be opened up in the firewall. Possibly not a huge issue, except that port 1434 is pretty well known.

Start TL;DR here:

So now we come to it (finally). These users were behind a firewall. They always referenced the port number in order to avoid having to open port 1434 in the firewall. They included the name of the instance as well because that makes it much easier to understand what instance they are talking about (particularly with our crazy server name naming conventions).

In case you are interested I apologized (in my head) for all of the mean things I said about them (in my head).

To start with I created some test data.

-- Create a table with a bunch of rows and one column 
-- with string data.
SELECT CAST(t.name + ' ' + c.name AS nvarchar(max)) AS StringToFix
	INTO BadStringList
FROM sys.tables t
CROSS JOIN sys.all_columns c

ALTER TABLE BadStringList ADD Id INT NOT NULL IDENTITY (1,1) 
     CONSTRAINT pk_BadStringList PRIMARY KEY


-- Put in one random (probably bad) character into about 
-- 2 percent of the rows.  Then do it 75 times
; WITH MyCTE AS (
SELECT TOP (2) percent StringToFix, STUFF(StringToFix, 
		CAST(rand((len(StringToFix) * datepart(ms,getdate()))^2) * len(StringToFix) AS Int) + 1, 1,
		NCHAR(CAST(rand((len(StringToFix) * datepart(ms,getdate()))^2) * 65025 AS Int))) AS Stuffed
FROM BadStringList
ORDER BY NEWID()
)
UPDATE MyCTE
SET StringToFix = Stuffed
GO 75

Here is my clean up code. Note it doesn’t actually clean the bad data out of the source, it produces a result with clean data.

DECLARE @Pattern varchar(50) = '%[^a-zA-Z0-9_''{}"() *&%$#@!?/\;:,.<>]%';

WITH FixBadChars AS (SELECT StringToFix, StringToFix AS FixedString, 1 AS MyCounter, Id
				FROM BadStringList
				UNION ALL
				SELECT StringToFix, Stuff(FixedString, PatIndex(@Pattern, 
					FixedString COLLATE Latin1_General_BIN2), 1, '') AS FixedString, 
					MyCounter + 1, Id
				FROM FixBadChars
				WHERE FixedString COLLATE Latin1_General_BIN2 LIKE @Pattern)
SELECT StringToFix, FixedString, MyCounter, Id
FROM FixBadChars
WHERE MyCounter = 
		(SELECT MAX(MyCounter) 
		FROM FixBadChars Fixed
		WHERE Fixed.Id = FixBadChars.Id)
OPTION (MAXRECURSION 1000);

This returned ~170k cleaned rows in under 30 seconds.

So here is what it does. Let’s start with the pattern I’m using.

DECLARE @Pattern varchar(50) = '%[^a-zA-Z0-9_''{}"() *&%$#@!?/\;:,.<>]%';

A basic start is this ‘[a-z]’ which will match a single character a-z. ^ in pattern matching is a NOT, so [^a-z] matches anything that is NOT a-z. Then we add in all the other characters [^a-zA-Z0-9_”{}”() *&%$#@!?/\;:,.] which will match any character that is not an upper or lower a-z, a didget 0-9, or one of the symboles listed. This is our approved list. Fair warning I was not able to figure out how to get it to work with []s in the list. Maybe someone who is better at pattern matching than me can figure it out. Last but not least add %’s on either end and you have pattern that will find a string that has any character that is not in the approved list.

Next I’m using a recursive CTE to loop through the string. Notice that the anchor is a test against the string to be fixed to see if there are any more bad characters. I also have a counter so that in the main query I can pull the entry for each string with the largest counter. That being the fixed row. I’m using a subquery to get the fixed row, joining on my primary key Id. In my case the query also works fine if you use StringToFix (assuming that it is unique). Basically you just need a unique per row value to join on. It helps if it’s indexed (30 seconds vs 45 for my run).

WHERE MyCounter = 
		(SELECT MAX(MyCounter) 
		FROM FixBadChars Fixed
		WHERE Fixed.StringToFix = FixBadChars.StringToFix)

Two more minior settings.

COLLATE Latin1_General_BIN2

The COLLATE is necessary because otherwise some unicode characters get missed by the PATINDEX command. I’m using SQL_Latin1_General_CP1_CS_AS as my default collation but any collation should work.

OPTION (MAXRECURSION 1000)

The recursive CTE will recurse once for each bad character in a string. So the deepest the query will recurse is the maximum number of bad characters in a single string. Realistically the default MAXRECURSION of 100 is probably sufficient in this case but I believe in better safe than sorry.

And that’s it. A non-RBAR way to clean a string. Jeff Moden would be so proud.

So if I don’t expect to be selected, why submit anything? Well, a couple of reasons really. Practice is one. I’m not a natural writer. I’ve gotten good at blog posts over the last few years because I’ve written a lot of them. Articles still come hard for me and I couldn’t write an abstract to save my life without some help (more on that later). Peer pressure is another. Let’s face it, the speakers table is where all the cool kids sit. Any time I can use peer pressure to actually improve myself I’m going to do it. In fact right now I’m using peer pressure to battle a very strong case of stage fright. They are neck and neck, I’ll let you know how it goes. Lastly I was kind of pushed into it (and I appreciate it). This is a bit more of a story and again something that I’ll take advantage of when it’s useful.

So a couple of days ago on twitter Thomas LaRock (b/t) said “Ok, 2nd #sqlpass session submitted. Now thinking the next one should be co-presented. Anyone want to submit with me?”. Now I couldn’t let that one pass, so I responded jokingly “Wow that would be tempting if I’d ever presented before :)” and he told me to pitch him an idea. As it happens I had an idea I was interested in, so I did. I’ll kill a bit of suspense here by saying up front I am not co-presenting anything with Thomas LaRock. He was nice to let me pitch something to him, but as I said up front, I’m not a speaker. Yet. But now I have this idea in my head, so later when Tom Roush (b/t) challenged me by saying “Ken, I’ll submit one if you will. Tag. You’re it. :-)”. And when, a little later Mike Fal (b/t) jumped on the bandwagon as well, I gave in.

So off I go to write an abstract. Thomas and later Jes Borland (b/t) offered to help me out, which is good because as I said earlier I had no idea what I was doing. The first thing that Thomas asked me as what are the top three points I want an attendee to learn in my session. With a little help I ended up with:

1. Attendees will learn about permissions, securables, and principals
2. Attendees will learn how to extract security details at the database and server instance level.
3. Attendees will learn how to apply best practices such as the concept of least privilege.

 
The next step was to turn that into an abstract. Thomas told me to turn those three thoughts into a 4-5 sentence story. I’m going to cut a long story short here and say I played with it several times until I got it right. No special advice here, just me passing ideas to Thomas and Jes and them saying versions of “Not bad, what about this”. Eventually I ended up with this:

In the modern age, data is a company’s most valuable resource and, unfortunately, data crimes are common. Because of this, everyone that works with SQL Server should have a basic understanding of database security. Attend this session to learn the what, how, and why of database security. Learn what permissions, securables, and principals are. Learn how to manage database security. Most importantly, learn what the best practices are and why they are important. Your company’s data is your responsibility, and after attending this session you can step up and keep it safe.

And so I submitted my first session for the Summit. Then I found out that 24HOP is calling for speakers, and specifically speakers who have not spoken at Summit before. Well that fits me too! So I submitted my session for that also.

So what’s next? Well now I start to write my presentation. Since, of course this is also new to me, I’m going to ask around (and Google) what types of fonts to use, what layouts make the best PPT slides etc. And as I move through the process I’ll be sure to write more posts in the hope that they can help the next person trying to learn to be a speaker.

So good luck to everyone trying what I am, and speaker or not, I hope to see ya’ll at the 2015 Summit!

Recently I posted Tales of a DBA fed up with NOLOCK and I got a fair number of comments (at least for me). And don’t get me wrong, I love comments, and I appreciated every single one. What they did was make me realize that I want to clarify my stance on NOLOCK.

I wrote my posts in part as practice for the various technologies I used (ddl triggers and policy based management) and in part as catharsis for an obnoxious situation. I wouldn’t put either in production for exactly the opposite reason as the Cargo Cults. NOLOCK has it’s uses and shouldn’t be completely restricted, just like it shouldn’t be used everywhere.

It’s a useful setting, under the right circumstances.
 

So what is NOLOCK?

A number of DBAs and developers don’t realize that NOLOCK is basically an alias. It is a query hint that causes SQL to use the READ UNCOMMITTED isolation level for the table (or query) specified. Which begs the question? What is the READ UNCOMMITTED isolation level? Read uncommitted isolation level allows for dirty reads. And what does that mean? (Every notice how trying to define a word tends to lead to trying to define the words you used and then you have to define those words and so on.) So a dirty read is where SQL Server will allow a page to be read even if there is an exclusive lock on it. And vise-versa, it doesn’t take shared locks that block updates.

Note: Because NOLOCK and READ UNCOMMITTED are the same thing putting SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED at the top of a piece of code and putting NOLOCK on every table reference in that piece of code is redundant. And repetitive. And annoys the &*#$ out of me.

So now that we know what NOLOCK is what are some common misconceptions?
 

Common misunderstandings about NOLOCK

NOLOCK doesn’t take locks.
READ UNCOMMITTED/NOLOCK (I’m just going to say NOLOCK from here on.) does take locks. This is the biggest misunderstanding I see. If nothing else a shared schema lock will be taken on the table. So some blocking will occur (schema changes, truncates etc.)

NOLOCK makes queries go faster.
No again. It looks like a query goes faster because there is reduced blocking. If you run that query on a server with no other users it’s going to run just as quickly whether or not you include NOLOCK. It can aid with concurrency issues but nothing else. So no magic fast button, sorry.

The only bad data I’ll see is what hasn’t been committed yet.
Another huge misunderstanding. Aaron Bertrand (b/t) did a great summary in his post Bad Habits Nolock Everywhere.

In it he mentioned not only the possibility of seeing data that hasn’t been committed, but seeing duplicate rows, or missing existing rows. (He also mentions index corruption and read errors although those don’t really fit under the heading of bad data.)

Additional reading on the problems of NOLOCK (to name a very very few)

• Aaron Bertrand (b/t) – Should I use nolock on #temp tables?
• SQL Server Customer Advisory Team – Previously committed rows might be missed if NOLOCK hint is used
• Jason Strate (b/t) – The side effect of nolock.
• Andrew Kelley (b) – How dirty are your reads.
• Kendra Little (b/t) – There something about NOLOCK webcast video

So what’s NOLOCK good for?

Earlier I said that NOLOCK has it’s uses but all I’ve discussed so far is the problems. In fact Kalen Delaney (b/t) said they should have called NOOCK I_DONT_CARE_ABOUT_MY_DATA_JUST_GIVE_ME_ANYTHING. So what’s it good for? Personally I use NOLOCK if I need to pull an approximate number of rows inserted so far during a bulk insert. I don’t need information that’s exactly correct and I don’t want to interfere with the load. That’s really the key. NOLOCK is great, if and ONLY if, you don’t need exact information and don’t want to interfere with what else is going on.
 

Summary

So NOLOCK is useful, but not all the time. It has some very significant issues and should not .. I repeat should NOT be used all the time. But that doesn’t mean it’s evil either. It has it’s uses and can be very handy at times. I would categorize NOLOCK as one of those Sr level tools. It’s a tool that you really need to understand before you start making use of it.

• Local Temporary Tables
  SELECT * INTO #LocalTempTable FROM sys.databases
• Global Temporary Tables
  SELECT * INTO ##GlobalTempTable FROM sys.databases

 
They are really pretty much the same. The only major difference is scope.

A local temporary table (#) is scoped to the current connection only. That means it can cross batches. (If you don’t know what I mean by a batch you can read what I wrote about GO the batch separator.) It also means that when you close the session the temporary table is dropped. You can manually drop a temp table but unless there is a need during your code you don’t have to.

So what’s different about a global temporary table? Well first of all (as you probably saw above) you use two #s when you create it. The Global part references the fact that scope is much broader. Any session can call a global temporary table even if it’s connected using a different login than the one that originally created the table. Global temporary tables are still dropped automatically (temporary remember?) but not until all tasks have stopped referencing it and the original session has been closed.

Now I did find something interesting while looking at temp tables. Remember that all temp tables are stored in TempDB. That means we can find the object_id for them like this:

-- Create temp tables first
SELECT * INTO #LocalTempTable FROM sys.databases
SELECT * INTO ##GlobalTempTable FROM sys.databases

SELECT object_id('tempdb.dbo.#LocalTempTable')
UNION ALL 
SELECT object_id('tempdb.dbo.##GlobalTempTable')

-1434584985
309576141

Every single time I tried it the local temporary table had a negative object ID and the global temporary table had a positive one. I’m not really sure if there is any significance there but I’ve only ever seen negative object IDs on system objects before.

Next let’s reverse the process and get the object name for the those object_ids.

SELECT object_name(object_id('tempdb.dbo.#LocalTempTable'),DB_ID('tempdb'))
UNION ALL
SELECT object_name(object_id('tempdb.dbo.##GlobalTempTable'),DB_ID('tempdb'))

#LocalTempTable_____________________________________________________________________________________________________000000000008
##GlobalTempTable

Notice that ##GlobalTempTable is named normally, #LocalTempTable on the other hand has a rather obvious extension with a number at the end. This is fairly logical since any number of sessions can have the same temporary table, all stored in TempDB, and if they had the same name there would be a problem.

Oh and quick note, all of the above queries were done from the same session. If you create the temp tables then run the object_id/object_name queries from a different session you will get NULL for the #LocalTempTable, while ##GlobalTempTable will work the same.

One little editorial comment at the end here. As with almost all things SQL Server, temp tables can be overused. They are very useful tools but if they are the only tool you use you can easily cause yourself some grief.

To set up a solution in SSMS start by creating a new project.

I’m choosing to use the template for a “SQL Server Management Studio Project” for “SQL Server Scripts”. And I fill in the name and location of the new project. (If you have much experience with Visual Studio this is all going to look very familiar.)

I now have a blank solution. I add new queries to the Queries section, rename them (right click, select rename), add the script I want and save.

And now I have a list of commonly used scripts.

I should warn you that when you open SSMS and start working it creates a blank solution that get’s filled with any open query windows under Miscellaneous Files.

If you decide to open your Quick Scripts solution later in the day (let’s say you now have a dozen scripts open) then you need to be careful. The default option is to close your current solution, and that is going to close all of your currently open scripts. If you select the Add to Solution option then it will open the new solution along side your current Miscellaneous solution.

Now all you need to do to open up one of your scripts is double-click it in your solution. Handy right?

This SQL Server 2000 system table is included as a view for backward compatibility. We recommend that you use the current SQL Server system views instead. To find the equivalent system view or views, see Mapping SQL Server 2000 System Tables to SQL Server 2005 System Views. This feature will be removed in a future version of Microsoft SQL Server. Avoid using this feature in new development work, and plan to modify applications that currently use this feature.

And we follow the link for Mapping SQL Server 2000 System Tables to SQL Server 2005 System Views we see that sysprocesses is mapped to sys.dm_exec_connections, sys.dm_exec_sessions, and sys.dm_exec_requests. As it happens these are three of my favorite DMOs. Database_Id is in sys.dm_exec_requests but that only helps if the session is actually doing something. In SQL 2012 and up you can find database_id in sys.dm_exec_sessions and this appears to map exactly to the dbid in sysprocesses. So quest solved right! Nope, 90% of the servers I’m working in currently are pre 2012. So now I’m in kind of a conundrum. I could write a query using sysprocesses, but I try to avoid using deprecated features when I can, or I can use sp_who, which I already complained about above.

Then I remembered sys.dm_tran_locks. This DMO displays information on locks currently held in the system. And yay us, being in a database is considered a lock! In fact it is a shared database lock. So now we write the query:

SELECT sys.databases.name DB_Name, request_session_id
FROM sys.dm_tran_locks
JOIN sys.databases
	ON sys.dm_tran_locks.resource_database_id = sys.databases.database_id
WHERE resource_type = 'DATABASE'
ORDER BY request_session_id

This is great! Except that it doesn’t show a shared database lock for master. Not sure why, but it doesn’t. Not really a big deal since chances are I’m never going to be doing anything to master that requires me to know who’s in it. I could go and look in sys.dm_exec_sessions for any session_ids that aren’t in sys.dm_tran_locks but then I’m going to get a number of sessions that, at least according to sysprocesses, belong to dbid 0. It probably doesn’t matter since they are all going to be system connections and again I don’t really need that information anyway. But just in case here is the code anyway.

SELECT sys.databases.name DB_Name, request_session_id
FROM sys.dm_tran_locks
JOIN sys.databases
	ON sys.dm_tran_locks.resource_database_id = sys.databases.database_id
WHERE resource_type = 'DATABASE'
UNION ALL
SELECT 'master' DB_Name, session_id
FROM sys.dm_exec_sessions
WHERE sys.dm_exec_sessions.session_id NOT IN (
		SELECT request_session_id
		FROM sys.dm_tran_locks
		WHERE resource_type = 'DATABASE')
ORDER BY request_session_id

Pretty simple. There are a number of free blogging sites out there. Personally I use WordPress. All you need to do is go to http://www.wordpress.com and sign up for a free space.

I have a blog but setting it up seems like a lot of work.

If you are looking at the setup of mature sites (about pages, formatting, themes etc) then you are forgetting just how long those sites have been up. Start by writing a few posts, then if you feel like it, write an about page. Over time you can add more and more to your blog. Eventually it will look just as evolved as any other.

I don’t have any ideas on what to write about / I don’t have anything to say

This is the easiest one to address. If you are having a hard time coming up with something to write about then use someone else’s ideas. SQL Judo (Russ Thomas) (b/t) does a monthly challenge. Write your answer to one of those challenges. Every month we have a blog party called #tsql2sday. Originally started by Adam Machanic (b/t) each month a different blogger hosts and comes up with an idea for us all to post on. Join in. That’s two different ideas each month.

One other thing that most experienced bloggers do is keep a list of ideas. Some weeks I’ll come up with 4 or 5 ideas, other weeks none. As I come up with ideas I write them down. Then if I don’t have any idea what I want to write about that day I just refer back to my list.

I’m afraid I’ll make a mistake

Ever. Single. Time. Every time I write a new post I’m terrified I’ve made a mistake. I test everything, check against BOL and bloggers I trust and sometimes I go so far as email one or two experts to make sure I’m right. On the other hand, fear of making a mistake is just a form of stage fright. Once you’ve been writing for a bit the fear becomes easier to deal with. I mean everyone makes a mistake now and again right? It’s not really a big deal. What’s the worst that can happen? Someone puts in a comment and corrects you. Usually it’s a polite comment and you’ll learn something (and what could be better right?) I’ve heard of people putting down rude or even mean comments, but in over two years I’ve never had anyone do it to me. And even if I did get one I might be aggravated for a bit but then I would get over it pretty quickly. Sticks and stones right?

On a related note if you aren’t comfortable with your writing skills and want some help there you can submit your posts to Michael J Swart(B/T) who offers to help you become a better writer. He helped me with this post and here is a before and after example I did a while back.

I don’t have time

This is a hard one. You just have to make the time. Schedule yourself half an hour to an hour once a week to do some writing. Personally I write in the evening while my wife and her family watch TV. A long time ago I decided I wasn’t that interested in TV and there are other things I’d rather do. These days that’s reading/writing about SQL Server. But then again I’m a sad confused sort of person. For those of you with a life this is going to be a bit more difficult.

No one is going to read what I write.

I’m going to be honest here. At first, no, not too many people are going to even know you have a blog. But in time you’ll be surprised at how interested people can be in what you have to say. Try syndicating your blog to SQL Server Central and/or Toad World. Both sites are popular places to read blogs so you will end up getting a fair amount of traffic from them.

Excuses are just that. You can always find one, but if you really want to get something done there is almost always a way. If you have any other reasons you don’t feel like you can manage to write a blog but you really want to feel free to drop me a line and I’ll see what I can do to help.