使用以前的非空值填充表中的空值。 每列有几个空值？

Question

I need to convert Table A to Table B (That is fill all the null values with the previous non null value for each column)

The main task is to fill the null values with the previous non null values for each column.

Here is the Original Table:

FromCompany Container   Numbers     ToCompany        Location
DISCOVERY   HALU 330308   5         MAGNA CHARGE     St-Laurent
            ATSU 827944   0         LEEZA DIST. 
                          4     
COLUMBIA    CAIU 807457   3         La Cie Canada    Baie D'Urfe
                          6     
                          0     

The Final Table should be:

FromCompany Container   Numbers ToCompany       Location
DISCOVERY   HALU 330308 5       MAGNA CHARGE    St-Laurent
DISCOVERY   ATSU 827944 0       LEEZA DIST      St-Laurent
DISCOVERY   ATSU 827944 4       LEEZA DIST      St-Laurent
COLUMBIA    CAIU 807457 3       La Cie Canada   Baie D'Urfe
COLUMBIA    CAIU 807457 6       La Cie Canada   Baie D'Urfe
COLUMBIA    CAIU 807457 0       La Cie Canada   Baie D'Urfe

Help would be greatly appreciated.

Answer 1

As largely commented, you do need a column to order the dataset. As your data comes from a CSV file, you can, for example, edit the file before loading it to add an autoincremented row number.

Assuming that you have this column ( id ) in place, here is a SQLServer solution for the question of filling NULL values with the first preceeding non- NULL value in the same column.

The basic idea is to put each record into a group, whose number corresponds to the id of the first record that has a non-null value. With 5 columns to fill, we need 5 groups.

SELECT
    t.* ,
    MAX(CASE WHEN FromCompany IS NOT NULL THEN id END) OVER(ORDER BY id ROWS UNBOUNDED PRECEDING) AS grpFromCompany,
    MAX(CASE WHEN Container   IS NOT NULL THEN id END) OVER(ORDER BY id ROWS UNBOUNDED PRECEDING) AS grpContainer,
    MAX(CASE WHEN Numbers     IS NOT NULL THEN id END) OVER(ORDER BY id ROWS UNBOUNDED PRECEDING) AS grpNumbers,
    MAX(CASE WHEN ToCompany   IS NOT NULL THEN id END) OVER(ORDER BY id ROWS UNBOUNDED PRECEDING) AS grpToCompany,
    MAX(CASE WHEN Location    IS NOT NULL THEN id END) OVER(ORDER BY id ROWS UNBOUNDED PRECEDING) AS grpLocation
FROM mytable t

Returns :

id | FromCompany | Container   | Numbers | ToCompany     | Location    | grpFromCompany | grpContainer | grpNumbers | grpToCompany | grpLocation
-: | :---------- | :---------- | ------: | :------------ | :---------- | -------------: | -----------: | ---------: | -----------: | ----------:
 1 | DISCOVERY   | HALU 330308 |       5 | MAGNA CHARGE  | St-Laurent  |              1 |            1 |          1 |            1 |           1
 2 | null        | ATSU 827944 |       0 | LEEZA DIST.   | null        |              1 |            2 |          2 |            2 |           1
 3 | null        | null        |       4 | null          | null        |              1 |            2 |          3 |            2 |           1
 4 | COLUMBIA    | CAIU 807457 |       3 | La Cie Canada | Baie D'Urfe |              4 |            4 |          4 |            4 |           4
 5 | null        | null        |       6 | null          | null        |              4 |            4 |          5 |            4 |           4
 6 | null        | null        |       0 | null          | null        |              4 |            4 |          6 |            4 |           4

Now we can turn this into a CTE, and use it to lookup the relevant values in the table :

WITH mycte AS (
    SELECT
        t.* ,
        MAX(CASE WHEN FromCompany IS NOT NULL THEN id END) OVER(ORDER BY id ROWS UNBOUNDED PRECEDING) AS grpFromCompany,
        MAX(CASE WHEN Container   IS NOT NULL THEN id END) OVER(ORDER BY id ROWS UNBOUNDED PRECEDING) AS grpContainer,
        MAX(CASE WHEN Numbers     IS NOT NULL THEN id END) OVER(ORDER BY id ROWS UNBOUNDED PRECEDING) AS grpNumbers,
        MAX(CASE WHEN ToCompany   IS NOT NULL THEN id END) OVER(ORDER BY id ROWS UNBOUNDED PRECEDING) AS grpToCompany,
        MAX(CASE WHEN Location    IS NOT NULL THEN id END) OVER(ORDER BY id ROWS UNBOUNDED PRECEDING) AS grpLocation
    FROM mytable t
)
SELECT 
   id,
   (SELECT FromCompany FROM mytable WHERE id = grpFromCompany) AS FromCompany,
   (SELECT Container   FROM mytable WHERE id = grpFromCompany) AS Container,
   (SELECT Numbers     FROM mytable WHERE id = grpNumbers) AS Numbers,
   (SELECT ToCompany   FROM mytable WHERE id = grpToCompany) AS ToCompany,
   (SELECT Location    FROM mytable WHERE id = grpLocation) AS Location
FROM mycte 

GO

id | FromCompany | Container   | Numbers | ToCompany     | Location   
-: | :---------- | :---------- | ------: | :------------ | :----------
 1 | DISCOVERY   | HALU 330308 |       5 | MAGNA CHARGE  | St-Laurent 
 2 | DISCOVERY   | HALU 330308 |       0 | LEEZA DIST.   | St-Laurent 
 3 | DISCOVERY   | HALU 330308 |       4 | LEEZA DIST.   | St-Laurent 
 4 | COLUMBIA    | CAIU 807457 |       3 | La Cie Canada | Baie D'Urfe
 5 | COLUMBIA    | CAIU 807457 |       6 | La Cie Canada | Baie D'Urfe
 6 | COLUMBIA    | CAIU 807457 |       0 | La Cie Canada | Baie D'Urfe

db<>fiddle here

Answer 2

Normally if your table had an identity column or a way to guarantee row sorting, you could use a CTE to achieve this with relative efficiency. However, we don't have that luxury here, so another solution is to use a much less efficient CURSOR instead.

-- Cursor variables
DECLARE @FromCompanyCursor varchar(20),
        @ContainerCursor varchar(20),
        @NumbersCursor int,
        @ToCompanyCursor varchar(20),
        @LocationCursor varchar(20),
        @FromCompany varchar(20),
        @Container varchar(20),
        @Numbers int,
        @ToCompany varchar(20),
        @Location varchar(20);


-- Cursor declaration
DECLARE C CURSOR FOR
(
SELECT  FromCompany,
        Container,
        Numbers,
        ToCompany,
        Location
FROM TableName
)
FOR UPDATE OF FromCompany, Container, Numbers, ToCompany, Location;

OPEN C;

-- Get first row from the cursor
FETCH NEXT FROM C INTO @FromCompanyCursor, @ContainerCursor, @NumbersCursor, @ToCompanyCursor, @LocationCursor;

-- While we still have rows to iterate over
WHILE @@FETCH_STATUS = 0
BEGIN
    -- Keep track of the last non-null value
    SELECT @FromCompany = CASE WHEN @FromCompanyCursor IS NOT NULL THEN @FromCompanyCursor ELSE @FromCompany END,
           @Container = CASE WHEN @ContainerCursor IS NOT NULL THEN @ContainerCursor ELSE @Container END,
           @Numbers = CASE WHEN @NumbersCursor IS NOT NULL THEN @NumbersCursor ELSE @Numbers END,
           @ToCompany = CASE WHEN @ToCompanyCursor IS NOT NULL THEN @ToCompanyCursor ELSE @ToCompany END,
           @Location = CASE WHEN @LocationCursor IS NOT NULL THEN @LocationCursor ELSE @Location END;

    -- Update the table with the last non-null values
    UPDATE TableName
    SET FromCompany = @FromCompany,
        Container = @Container,
        Numbers = @Numbers,
        ToCompany = @ToCompany,
        Location = @Location
    WHERE CURRENT OF C;

    -- Get the next row from the cursor
    FETCH NEXT FROM C INTO @FromCompanyCursor, @ContainerCursor, @NumbersCursor, @ToCompanyCursor, @LocationCursor;
END

-- Don't forget to close the cursor!
CLOSE C;
DEALLOCATE C;

Note that procedural-based operations like these are incredibly inefficient in SQL Server, and as such a solution such as this one should be used as a one-time operation, or as part of a scheduled maintenance job.