If I need to replace all mentions of "TOTA" in a column with nothing would I use the following concept? It seems simple but all the tutorials that I find are not in plain enough English for someone who picked up SQL last week.
Update Tablename
set indcode =case when indcode in('TOTA', then 'blank' else 'leave it alone' End);
You should set to null for assign blank value
Update Tablename
set indcode = NULL
where indcode ='TOTA';
and use where for filter the row to update
if you need a set of value for filter you can use a IN clause eg
Update Tablename
set indcode = NULL
where indcode in ('TOTA', '0', '000000');
or for complex case you can use case when ..
Update Tablename
set indcode = case when 'TOTA' then NULL
when '0' then '000000'
else indcode
END
You were missing a equal sign and a closing parentheses, and as written you would have updated it to the string blank, not an empty string, and finally, you need to decide if you want it to be updated to an empty (zero-length) string, or to the built-in database value called null, which represents, in all relational databases, that the value is not known or is unspecified (as opposed to explicitly being an empty or zero-length string.)
To update to an empty (zero-Length) string, write'
Update Tablename
set indcode = case when indcode = 'TOTA' then ''
else indcode end;
but you really don't need to update the ones to be left alone, so just add a filter (a Where clause) with that predicate expression
Update Tablename
set indcode = ''
Where indcode = 'TOTA'
If you really want to update it to Null, and not to an empty string, then first check and make sure that the column indCode is set to allow nulls, and write:
Update Tablename
set indcode = Null
Where indcode = 'TOTA'
Related
I am trying to update two variables in a Oracle server as follows:
UPDATE UserTable
SET user_email='asdf#company.com',
(CASE WHEN reason != '' THEN why_update= 'change email server' END)
WHERE user_id = 123
I want to update why_update column only if the user provided a reason for update otherwise leave the column as it is (which is varchar type and can be NULL).
Or any other better solution?
If you're trying to update multiple columns, you would need to do it like:
UPDATE UserTable
SET user_email = 'asdf#company.com',
why_update = CASE WHEN reason IS NOT NULL THEN 'change email server' END
WHERE user_id = 123;
You would always end up updating both columns - in this case, if reason is null, then why_update would be set to NULL, losing any previous value. If you don't want that to happen, you would need to add in an ELSE why_update clause into the CASE expression.
N.B. I have changed your != '' into IS NOT NULL because an empty string ('') is recognised as being a NULL in Oracle. NULL will never match an equals or not equals check, so your above CASE expression won't work as I suspect you want it to work.
THis will work:
UPDATE UserTable
SET user_email='asdf#company.com',
why_update= CASE WHEN reason != '' THEN 'change email server' else why_update END
WHERE user_id = 123
I know that in SQL when we compare two NULL values, result is always false. Hence, statements like
SELECT case when NULL = NULL then '1' else '0' end
will always print '0'. My question is how functions like ISNULL determine whether value is null or not. Because, as per my understanding (and explained in above query) comparison of two null values is always FALSE.
You need to set the set ansi_nulls off and then check your result. Null can be thought of as an unknown value and when you are comparing two unknown values then you will get the result as false only. The comparisons null = null is undefined.
set ansi_nulls off
SELECT case when NULL = NULL then '1' else '0' end
Result:-
1
From MSDN
When SET ANSI_NULLS is OFF, the Equals (=) and Not Equal To (<>)
comparison operators do not follow the ISO standard. A SELECT
statement that uses WHERE column_name = NULL returns the rows that
have null values in column_name. A SELECT statement that uses WHERE
column_name <> NULL returns the rows that have nonnull values in the
column. Also, a SELECT statement that uses WHERE column_name <>
XYZ_value returns all rows that are not XYZ_value and that are not
NULL.
As correctly pointed by Damien in comments the behavior of NULL = NULL is unknown or undefined.
Your initial assumption appears to be that ISNULL is an alias for existing functionality which can be implemented directly within SQL statements, in the same way that a SQL function can. You are then asking how that function works.
This is an incorrect starting point, hence the confusion. Instead, like similar commands such as IN and LIKE, ISNULL is parsed and run within the database engine itself; its actual implementation is most likely written in C.
If you really want to look into the details of the implementation, you could take a look instead at mySQL - it's open source, so you may be able to search through the code to see how ISNULL is implemented there. They even provide a guided tour of the code if required.
... or {2} are you literally asking how the ISNULL function in SQL
Server itself works?
Actually I am asking for the second{2}. How ISNULL function in SQL server
works. If comparison of two nulls is not defined/unknown then how
isnull function compares two null values to return appropriate
results?
Null is a special marker used in Structured Query Language (SQL) to indicate that a data value does not exist in the database. ... NULL (SQL)
ISNULL ( check_expression , replacement_value ) is not concerned with comparison of values at all. It is concerned purely with the existence of value in the first parameter.
It tests if the check_expression has any value. If it does have any value that value is returned. If check_expression has no value the ISNULL function returns the second parameter replacement_value.
It does NOT compare the two values. It tests forthe existence of value in the first parameter only.
set ansi_nulls off
SELECT case when NULL = NULL then '1' else '0' end
result=1
set ansi_nulls on
SELECT case when NULL = NULL then '1' else '0' end
result=0
so that is the difference
I hope it works
SELECT CASE WHEN ISNULL(NULL,NULL) = NULL THEN 1 ELSE 0 END
SELECT case when 'NULL' = 'NULL' then '1' else '0' end
SELECT case when isnull(columnname,'NULL')='NULL' then '1' else '0' end
SET ANSI_NULLS OFF
SELECT case when NULL = NULL then '1' else '0' end
How do I update a column value (varchar(20), not null) with a "blank" value?
If you want to update it with NULL you will need to change it to allow NULL. Otherwise update with an empty string "".
Update TableName Set ColumnName='' where [Condtion] // To update column with an enpty values
If there have any int column which you may want to do null
Update TABLE_NAME set name = '',id = cast(NULLIF(id,'') as NVARCHAR)
So I have a simple query that returns a listing of products
SELECT Model, CategoryID
FROM Products
WHERE (Model = '010-00749-01')
This returns
010-00749-01 00000000-0000-0000-0000-000000000000
010-00749-01 NULL
Which is correct, so I wanted only the products whose CategoryID is not '00000000-0000-0000-0000-000000000000' so I have
SELECT Model, CategoryID
FROM Products
WHERE (Model = '010-00749-01')
AND (CategoryID <> '00000000-0000-0000-0000-000000000000')
But this returns no result. So I changed the query to
SELECT Model, CategoryID
FROM Products
WHERE (Model = '010-00749-01')
AND ((CategoryID <> '00000000-0000-0000-0000-000000000000') OR (CategoryID IS NULL))
Which returns expected result
010-00749-01 NULL
Can someone explain this behavior to me?
MS SQL Server 2008
Check out the full reference on Books Online - by default ANSI_NULLS is on meaning you'd need to use the approach you have done. Otherwise, you could switch that setting OFF at the start of the query to switch the behaviour round.
When SET ANSI_NULLS is ON, a SELECT
statement that uses WHERE column_name
= NULL returns zero rows even if there are null values in column_name. A
SELECT statement that uses WHERE
column_name <> NULL returns zero rows
even if there are nonnull values in
column_name.
...
When SET ANSI_NULLS
is ON, all comparisons against a null
value evaluate to UNKNOWN. When SET
ANSI_NULLS is OFF, comparisons of all
data against a null value evaluate to
TRUE if the data value is NULL.
Here's a simple example to demonstrate the behaviour with regard to comparisons against NULL:
-- This will print TRUE
SET ANSI_NULLS OFF;
IF NULL <> 'A'
PRINT 'TRUE'
ELSE
PRINT 'FALSE'
-- This will print FALSE
SET ANSI_NULLS ON;
IF NULL <> 'A'
PRINT 'TRUE'
ELSE
PRINT 'FALSE'
In general, you have to remember that NULL generally means UNKNOWN. That means if you say CategoryID <> '00000000-0000-0000-0000-000000000000' you have to assume that the query will only return values that it KNOWS will meet your criteria. Since there is a NULL (UNKNOWN) result, it does not actually know if that record meets your criteria and therefore will not be returned in the dataset.
Basically, a NULL is the absence of any value. So trying to compare the NULL in CategoryId to a varchar value in the query will always result in a false evaluation.
You might want to try using the COALESCE function, something like:
SELECT ModelId, CategoryID
FROM Products
WHERE (ModelId = '010-00749-01')
AND ( COALESCE( CategoryID, '' ) <> '00000000-0000-0000-0000-000000000000' )
EDIT
As noted by AdaTheDev the COALESCE function will negate any indices that may exist on the CategoryID column, which can affect the query plan and performance.
look at this:
1=1 --true
1=0 --false
null=null --false
null=1 --false
1<>1 --false
1<>0 --true
null<>null --false
null<>1 --false <<<--why you don't get the row with: AND (CategoryID <> '00000000-0000-0000-0000-000000000000')
Null gets special treatment. You need to explicitly test for null. See http://msdn.microsoft.com/en-us/library/ms188795.aspx
You may try using the Coalesce function to set a default value for fields that have null:
SELECT Model , CategoryID
FROM Products
WHERE Model = '010-00749-01'
AND Coalesce(CategoryID,'') <> '00000000-0000-0000-0000-000000000000'
I think the problem lies in your understanding of NULL which basically means "nothing." You can't compare anything to nothing, much like you can't divide a number by 0. It's just rules of math/science.
Edit:
As Ada has pointed out, this could cause an indexed field to no longer use an index.
Solution:
You can create an index using the coalesce function: eg create index ... coalesce(field)
You can add a not null constraint to prevent NULLs from ever appearing
A de facto standard of mine is to always assign default values and never allow nulls
How do I clear the value from a cell and make it NULL?
I think Zack properly answered the question but just to cover all the bases:
Update myTable set MyColumn = NULL
This would set the entire column to null as the Question Title asks.
To set a specific row on a specific column to null use:
Update myTable set MyColumn = NULL where Field = Condition.
This would set a specific cell to null as the inner question asks.
If you've opened a table and you want to clear an existing value to NULL, click on the value, and press Ctrl+0.
If you are using the table interface you can type in NULL (all caps)
otherwise you can run an update statement where you could:
Update table set ColumnName = NULL where [Filter for record here]
Use This:
Update Table Set Column = CAST(NULL As Column Type) where Condition
Like This:
Update News Set Title = CAST(NULL As nvarchar(100)) Where ID = 50
Ctrl+0 or empty the value and hit enter.
Just as a little extension to Jeff Martin's and Zack Peterson's solution.
If you still want to set several values from the columns to null you can simply set the query to
UPDATE myTable SET MyColumn1 = NULL, MyColumn2 = NULL, MyColumn3 = NULL, ...
CTRL+0 doesn't seem to work when connected to an Azure DB.
However, to create an empty string, you can always just hit 'anykey then delete' inside a cell.