**Describe the bug**

JSONExtract returns 0 for numbers with floating-point for type *float / Float32*.

**How to reproduce**

```sql
WITH '{ "v":1.1}' AS raw
SELECT 
    JSONExtract(raw, 'v', 'float') AS float32_1,
    JSONExtract(raw, 'v', 'Float32') AS float32_2,
    JSONExtractFloat(raw, 'v') AS float64_1,
    JSONExtract(raw, 'v', 'double') AS float64_2

/*
┌─float32_1─┬─float32_2─┬─float64_1─┬─float64_2─┐
│         0 │         0 │       1.1 │       1.1 │
└───────────┴───────────┴───────────┴───────────┘
*/
```

```sql
WITH '{ "v":1E-2}' AS raw
SELECT 
    JSONExtract(raw, 'v', 'float') AS float32_1,
    JSONExtract(raw, 'v', 'Float32') AS float32_2,
    JSONExtractFloat(raw, 'v') AS float64_1,
    JSONExtract(raw, 'v', 'double') AS float64_2

/*
┌─float32_1─┬─float32_2─┬─float64_1─┬─float64_2─┐
│         0 │         0 │      0.01 │      0.01 │
└───────────┴───────────┴───────────┴───────────┘
*/
```

**Expected behavior**

I think either need to add support *float / Float32* type or throw an exception to point to need to use *double / Float64* type.

**Additional context**
CH v. 20.6.4.44

case TypeIndex::String: return std::make_unique<StringNode>();
            case TypeIndex::FixedString: return std::make_unique<FixedStringNode>();
            case TypeIndex::Enum8:
                return std::make_unique<EnumNode<Int8>>(static_cast<const DataTypeEnum8 &>(*type).getValues());
            case TypeIndex::Enum16:
                return std::make_unique<EnumNode<Int16>>(static_cast<const DataTypeEnum16 &>(*type).getValues());
            case TypeIndex::Nullable:
            {
                return std::make_unique<NullableNode>(build(function_name, static_cast<const DataTypeNullable &>(*type).getNestedType()));
            }
            case TypeIndex::Array:
            {
                return std::make_unique<ArrayNode>(build(function_name, static_cast<const DataTypeArray &>(*type).getNestedType()));
            }
            case TypeIndex::Tuple:
            {
                const auto & tuple = static_cast<const DataTypeTuple &>(*type);
                const auto & tuple_elements = tuple.getElements();
                std::vector<std::unique_ptr<Node>> elements;
                for (const auto & tuple_element : tuple_elements)
                    elements.emplace_back(build(function_name, tuple_element));
                return std::make_unique<TupleNode>(std::move(elements), tuple.haveExplicitNames() ? tuple.getElementNames() : Strings{});
            }
            default:
                throw Exception{"Function " + String(function_name) + " doesn't support the return type schema: " + type->getName(), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
        }
    }
};
template <typename JSONParser>
class JSONExtractImpl