Tag: SQLNewBlogger

  • An Update to Skipping the Leading Digit in T-SQL–#SQLNewBlogger

    There was an interesting question in a forum, which I wrote about before. How do you skip the leading digit in a numeric value. I had looked at a UNION, but someone had a better suggestion, so I’m adding to the post.

    Another post for me that is simple and hopefully serves as an example for people trying to get blogging as #SQLNewBloggers. Here are some hints to get started.

    Another Predicate

    In the previous post, I used a <> and then a > and < with a UNION. Howver, someone noted that NOT BETWEEN is an option. I could rewrite the query this way:

    SELECT *
     FROM dbo.Room AS r
     WHERE room NOT BETWEEN  200 AND 299
    

    This gives me the same result:

    2022-10-05 14_32_43-SQLQuery6.sql - ARISTOTLE.sandbox (ARISTOTLE_Steve (61))_ - Microsoft SQL Server

    This also results in a seek.

    2022-10-05 14_33_30-SQLQuery6.sql - ARISTOTLE.sandbox (ARISTOTLE_Steve (61))_ - Microsoft SQL Server

    The BETWEEN or NOT BETWEN is sargable, meaning we can use an index to find those values that fall into this ordering and exclude them.

    Worth remembering BETWEEN when writing queries for ranges.

    SQL New Blogger

    An update to my post, showing a better way, showing I am happy to take advice from others, and I can improve code. This is a skill that employers need, especially when teams need to become more consistent with coding when working together. Showing you can adapt and grow is a good skill.

    You could write a simple blog like this that shows how you might change some code you wrote in the past. I bet it takes less than 30 minutes.

  • Checking Database Compatability = #SQLNewBlogger

    Recently I needed to check the compatibility level of a database and SSMS didn’t work. This is what I did in T-SQL.https://learn.microsoft.com/en-us/sql/t-sql/statements/alter-database-transact-sql-compatibility-level?view=sql-server-ver16

    Another post for me that is simple and hopefully serves as an example for people trying to get blogging as #SQLNewBRloggers. Here are some hints to get started.

    Querying the System

    I would have assumed I could use the DatabaseProperyEX() function to get this, but as I look through the list of properties, the compat level isn’t in there.

    When I look through the Docs for the compat level, I find that the page for database compatibility, the page mentions that querying a DMV is the way to check this. Seems strange, but I guess that’s what you do.

    Here’s the query:

    SELECT name, compatibility_level FROM sys.databases;

    Y0u can filter this by database name if you need it.

    I needed this as I was testing SQL Server 2022, but my SSMS version (18.10), didn’t recognize level 160. I assumed that was what should have been there, but I needed this query to verify.

    Now, hopefully I’ll remember that I just need to query the DMV.

    SQL New Blogger

    This was a quick post, really just over 5 minutes to write. It’s not super technical, but it does show that I can research something and solve a problem. And I have an alternative when my main tool doesn’t work.

    Good skills to showcase on a blog.

  • Replacing NULLs in a Left Join–#SQLNewBlogger

    I saw someone ask a question on how to replace NULL in a left join and decided to write a post. I realized this is one of those simple things that people new to SQL might not get.

    Another post for me that is simple and hopefully serves as an example for people trying to get blogging as #SQLNewBloggers. Here are some hints to get started.

    A Left Join Example

    Let’s create a table of customers and orders with a few values in each. This is common, where we have customers that we might add as prospects in some CRM type system. Then we link orders to customers.

    Use this code:

    DROP TABLE IF EXISTS dbo.Customer
    GO
    CREATE TABLE dbo.Customer
    ( CustomerID INT NOT NULL IDENTITY(1,1) CONSTRAINT CustomerPK PRIMARY KEY
    , CustomerName VARCHAR(20)
    )
    GO
    INSERT dbo.Customer (CustomerName)
    VALUES
       ('Joe'),
       ('Bob'),
       ('Sally'),
       ('Amy')
    GO
    DROP TABLE IF EXISTS dbo.OrderHeader
    GO
    CREATE TABLE dbo.OrderHeader
    ( OrderID INT NOT NULL IDENTITY(1,1) CONSTRAINT OrderHeaderPK PRIMARY KEY
    , CustomerID INT
    , OrderNote VARCHAR(100)
    )
    GO
    INSERT dbo.OrderHeader (CustomerID, OrderNote)
    VALUES
       (1, 'Initial Order'),
       (1, 'Re-order'),
       (3, 'Initial Order')
    GO

    Potentially, we have customers without orders. If we use an inner join, we only see customers with orders. Using the left join below, we see all customers with their corresponding orders.

    SELECT
       c.CustomerID
    , c.CustomerName
    , oh.OrderID
    , oh.OrderNote
    FROM
       dbo.Customer AS c
       LEFT JOIN dbo.OrderHeader AS oh
         ON oh.CustomerID = c.CustomerID;
    GO

    I see these results:

    2022-09-02 14_00_08-SQLQuery6.sql - ARISTOTLE.sandbox (ARISTOTLE_Steve (58))_ - Microsoft SQL Server

    This works, but really, I’d like to clean up the results to show something better.

    Looking for NULLs

    I can use a couple of functions to look for a NULL value in my results. Both ISNULL and COALESCE can help here. ISNULL is for a single expression and replaces NULL with value, while COALESCE works by returning the first non-NULL expression. I’ll use ISNULL here and in another post look at COALESCE.

    Here’s a better query that replaces one value with a NA and another with a blank.

    SELECT
       c.CustomerID
    , c.CustomerName
    , ISNULL(oh.OrderID, 0) AS OrderID
    , ISNULL(oh.OrderNote, 'No orders placed') AS OrderNote
    FROM
       dbo.Customer AS c
       LEFT JOIN dbo.OrderHeader AS oh
         ON oh.CustomerID = c.CustomerID;
    GO

    Here are the results. Note that I return a 0 for the OrderID. This is because the result set is a numeric, and I need these types to match.

    2022-09-02 14_04_37-SQLQuery6.sql - ARISTOTLE.sandbox (ARISTOTLE_Steve (58))_ - Microsoft SQL Server

    I could also return a string if I cast all OrderIDs to strings, as shown below.

    SELECT
       c.CustomerID
    , c.CustomerName
    , ISNULL(CAST(oh.OrderID AS VARCHAR(20)), 'N/A') AS OrderID
    , ISNULL(oh.OrderNote, 'No orders placed') AS OrderNote
    FROM
       dbo.Customer AS c
       LEFT JOIN dbo.OrderHeader AS oh
         ON oh.CustomerID = c.CustomerID;
    GO

    This produces these results.

    2022-09-02 14_05_29-SQLQuery6.sql - ARISTOTLE.sandbox (ARISTOTLE_Steve (58))_ - Microsoft SQL Server

    Both cases clean up the NULL values with something that makes more sense to a person looking at the data in a report.

    SQLNewBlogger

    This was a post inspired by a question I saw. This is how I’d solve the issue, and decided to share that knowledge more widely, both to help others and also provide an example of where I might have a hiring manager ask me about this from noticing my blog.

    This post took about 15 minutes to write. You could easily do this on your blog.

  • Import a CSV with a Header Row using BCP–#SQLNewBlogger

    Another post for me that is simple and hopefully serves as an example for people trying to get blogging as #SQLNewBloggers. Here are some hints to get started.

    I was demoing something recently and needed to show someone how to grab some data from a CSV text file. Since this was a task the person needed to do regularly, but with different files, they wanted to ensure this was programmatic from a command line call outside of SQL Server. They knew the basics of bcp, but weren’t sure how to deal with a header row.

    This is actually fairly simple as you will see.

    BCP Basics

    I have a simple file that looks like this:

    Time,System Production (Wh)
    08/01/2022,"58875"
    08/02/2022,"61260"
    08/03/2022,"60866"
    08/04/2022,"66395"

    I have a basic table of this structure:

    CREATE TABLE [dbo].[Stage](
         [ProdTime] [varchar](20) NULL,
         [ProdValue] [varchar](100) NULL
    ) ON [PRIMARY]
    GO

    This is just a demo import from this sample file. If I run a basic bcp command, I’d typically run this:

    bcp dbo.stage in export.csv -S Aristotle\SQL2017 -d way0utwest -T -t "," –c

    This runs easily, as you see below:

    2022-08-17 12_56_58-D__Downloads

    However, this is my data:

    2022-08-17 12_56_51-solarloading.sql - ARISTOTLE_SQL2017.way0utwest (ARISTOTLE_Steve (69))_ - Micros

    That’s not right. The first row is a header row, and while I can quickly and easily fix this, it’s better not to have to process this. Easier to fix this on the import.

    To do this, I need to look at the bcp documentation and include a flag. The –F flag is for the first row, which I want to set to 2. If I truncate the table and run this command:

    bcp dbo.stage in export.csv -S Aristotle\SQL2017 -d way0utwest -T -t "," -c -F 2

    I see these results:

    2022-08-17 13_02_04-solarloading.sql - ARISTOTLE_SQL2017.way0utwest (ARISTOTLE_Steve (69))_ - Micros

    No header row. There are still issues with this import, but this solves one problem, which is what the SQL New Blogger post is for.

    SQLNewBlogger

    This is a quick example of a post that is part of my daily work. I was showing a customer this, and I had to mock something up, so I grabbed a little sample data and did that.

    I spent about 15 minutes around other work getting this post written and screenshots taken. You could do this as well and show how you import data in a cleaner fashion.