May you check this simple select case...

Question

Guys, please, can you check this stupid code? I'm totally shattered and maybe I don't see the simple thing...
with cte as (
SELECT CORE FROM IMPORTOIL group by core)
,cte2 as
(select core , mps, technology
from cte xx right join GeneratorTypo gt on xx.core=gt.mps)
select core, mps, technology , case core when null then 'Import ' else technology end from cte2
even if I got several core NULL it retrieve for the select case only the technology and never the 'Import'. Pratically, if ( I miss 2012 wit the simple iif) the core is null write the same value that there is in technology otherwise write 'Import'...what's
wrong with that?

Answer 1

Please post DDL, so that people do not have to guess what the keys, constraints, Declarative Referential Integrity, data types, etc. in your schema are. Learn how to follow ISO-11179 data element naming conventions and formatting rules. Nothing here is correct! 
Temporal data should use ISO-8601 formats. Code should be in Standard SQL as much as possible and not local dialect. 
This is minimal polite behavior on SQL forums. You also need to learn the syntax for a CASE expression: 
CASE WHEN core IS NULL THEN 'IMPORT ' ELSE technology END
The CASE expression is an *expression* and not a control statement; that is, it returns a value of one data type. SQL-92 stole the idea and the syntax from the ADA programming language. Here is the BNF for a <case specification>:
 <case specification> ::= <simple case> | <searched case>
 <simple case> ::=
    CASE <case operand>
      <simple when clause>...
      [<else clause>]
    END
 <searched case> ::=
    CASE
      <searched when clause>...
      [<else clause>]
    END
 <simple when clause> ::= WHEN <when operand> THEN <result>
 <searched when clause> ::= WHEN <search condition> THEN <result>
 <else clause> ::= ELSE <result>
 <case operand> ::= <value expression>
 <when operand> ::= <value expression>
 <result> ::= <result expression> | NULL
 <result expression> ::= <value expression>
The searched CASE expression is probably the most used version of the expression. The WHEN ... THEN ... clauses are executed in left to right order. The first WHEN clause that tests TRUE returns the value given in its THEN clause. And, yes, you can nest CASE
expressions inside each other. If no explicit ELSE clause is given for the CASE expression, then the database will insert a default ELSE NULL clause. If you want to return a NULL in a THEN clause, then you must use a CAST (NULL AS <data type>) expression.
I recommend always giving the ELSE clause, so that you can change it later when you find something explicit to return. 
The <simple case expression> is defined as a searched CASE expression in which all the WHEN clauses are made into equality comparisons against the <case operand>. For example
  CASE iso_sex_code
  WHEN 0 THEN 'Unknown'
  WHEN 1 THEN 'Male'
  WHEN 2 THEN 'Female'
  WHEN 9 THEN 'N/A'
  ELSE NULL END
could also be written as:
  CASE 
  WHEN iso_sex_code = 0 THEN 'Unknown'
  WHEN iso_sex_code = 1 THEN 'Male'
  WHEN iso_sex_code = 2 THEN 'Female'
  WHEN iso_sex_code = 9 THEN 'N/A'
  ELSE NULL END
There is a gimmick in this definition, however. The expression
 CASE foo
 WHEN 1 THEN 'bar'
 WHEN NULL THEN 'no bar'
 END
becomes 
 CASE WHEN foo = 1 THEN 'bar'
      WHEN foo = NULL THEN 'no_bar'  -- error!
      ELSE NULL END 
The second WHEN clause is always UNKNOWN. 
The SQL-92 Standard defines other functions in terms of the CASE expression, which makes the language a bit more compact and easier to implement. For example, the COALESCE () function can be defined for one or two expressions by
1) COALESCE (<value exp #1>) is equivalent to (<value exp #1>) 
2) COALESCE (<value exp #1>, <value exp #2>) is equivalent to 
   CASE WHEN <value exp #1> IS NOT NULL 
        THEN <value exp #1> 
        ELSE <value exp #2> END
then we can recursively define it for (n) expressions, where (n >= 3), in the list by 
COALESCE (<value exp #1>, <value exp #2>, . . ., n), as equivalent to:
   CASE WHEN <value exp #1> IS NOT NULL 
        THEN <value exp #1> 
        ELSE COALESCE (<value exp #2>, . . ., n) 
   END
Likewise, NULLIF (<value exp #1>, <value exp #2>) is equivalent to:
   CASE WHEN <value exp #1> = <value exp #2> 
        THEN NULL 
        ELSE <value exp #1> END
It is important to be sure that you have a THEN or ELSE clause with a data type that the compiler can find to determine the highest data type for the expression. 
A trick in the WHERE clause is use it for a complex predicate with material implications. 
WHERE CASE 
      WHEN <search condition #1> 
      THEN 1  
      WHEN <search condition #2> 
      THEN 1  
      ELSE 0 END  = 1
Gert-Jan Strik posted some exampels of how ISNULL() and COALESCE() on 2004 Aug 19
CREATE TABLE #t(a CHAR(1));
INSERT INTO #t VALUES (NULL);
SELECT ISNULL(a,'abc') FROM #t; 
SELECT COALESCE(a, 'abc') FROM #t; 
DROP TABLE #t;
He always use COALESCE, with the exception of the following type of 
situation, because of its performance consequences: 
SELECT ..., 
  ISNULL((SELECT COUNT(*)  -- or other aggregate 
           FROM B 
          WHERE B.key = A.key), 0) 
FROM A;
Likewise, Alejandro Mesa came up with this example:
SELECT 13 / COALESCE(CAST(NULL AS INTEGER), 2.00); -- promote to highest type (decimal)
SELECT 13 / ISNULL(CAST(NULL AS INTEGER), 2.00); -- promote to first type (integer)
>> if (I miss 2012 with the simple iif) the core is null write the same value that there is in technology otherwise write 'Import'... what's wrong with that? <<
Why do you want to write non_ANSI/ISO dialect? Do you like your spreadsheets that much? :(
--CELKO-- Books in Celko Series for Morgan-Kaufmann Publishing: Analytics and OLAP in SQL / Data and Databases: Concepts in Practice Data / Measurements and Standards in SQL SQL for Smarties / SQL Programming Style / SQL Puzzles and Answers / Thinking
in Sets / Trees and Hierarchies in SQL