Sql-server – Convert a numeric column with number eg.(-1222222) to two float column with two decimal places eg (-12222.22)

SELECT (count(refinst) * 100)::numeric / NULLIF(count(*), 0) AS refinst_pct
    -- count(refinst) * 100.0 / NULLIF(count(*), 0) AS refinst_pct  -- simpler
FROM   patients;

• Do not use a subselect. Both aggregates can be derived from the same query. Cheaper.

• Also, this is not a case for window functions, since you want to compute a single result, and not one result per row.

• Cast to any numeric type that supports fractional digits, like @a_horse already explained.
  Since you want to round() to two fractional digits I suggest numeric (which is the same as decimal in Postgres).
  It's enough to cast one value involved in a calculation, preferably the first. Postgres automatically settles for the type that does not lose information.
  Or, simpler yet: since we multiply anyway, use a numeric constant that's coerced to numeric automatically because of the decimal point (100.0).

• It's generally a good idea to multiply before you divide. This typically minimizes rounding errors and is cheaper.
  In this case, the first multiplication (count(refinst) * 100) can be computed with cheap and exact integer arithmetic. Only then we cast to numeric and divide by the next integer (which we do not cast additionally).

• NULLIF(count(*), 0) prevents division by zero (raising an exception). We get NULL as (unknown) percentage if there are no rows at all.

Rounded to two fractional digits:

SELECT round((count(refinst) * 100)::numeric / NULLIF(count(*), 0), 2) AS refinst_pct
FROM   patients;

From a high level, you'd simply do this:

SELECT *
FROM dbo.member m
    INNER JOIN dbo.tasklist_data tld ON m.UID = tld.TaskID;

The INNER JOIN will take rows from dbo.member where the UID column values match values contained in the TaskID column from the tasklist_data table. If you wanted ALL the rows from dbo.member, and only matching rows from dbo.tasklist_data, you'd rewrite that as:

SELECT *
FROM dbo.member m
    LEFT JOIN dbo.tasklist_data tld ON m.UID = tld.TaskID;

Steve Stedman has an excellent resource for understanding how the different types of JOIN statements work.

If you need to do this on more than two tables, you simply add JOIN clauses as necessary:

SELECT *
FROM dbo.member m
    INNER JOIN dbo.tasklist_data tld ON m.UID = tld.TaskID
    INNER JOIN dbo.some_other_table sot ON m.UID = sot.some_column_name;

I have broken a (arguably) cardinal sin above by using SELECT * to return all columns from all of the tables mentioned in the FROM clause of the query. It is generally considered good practice to explicitly specify the columns required, for instance:

SELECT m.UID
    , m.SomeColumn1
    , m.SomeColumn2
    , tld.TaskID
    , tld.SomeColumn3
FROM dbo.member m
    INNER JOIN dbo.tasklist_data tld ON m.UID = tld.TaskID;