**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

{
            if (!element.isArray())
                return false;
            auto array = element.getArray();
            ColumnArray & col_arr = assert_cast<ColumnArray &>(dest);
            auto & data = col_arr.getData();
            size_t old_size = data.size();
            bool were_valid_elements = false;
            for (auto value : array)
            {
                if (nested->insertResultToColumn(data, value))
                    were_valid_elements = true;
                else
                    data.insertDefault();
            }
            if (!were_valid_elements)
            {
                data.popBack(data.size() - old_size);
                return false;
            }
            col_arr.getOffsets().push_back(data.size());
            return true;
        }
    private:
        std::unique_ptr<Node> nested;
    };
    class TupleNode : public Node
    {
    public:
        TupleNode(std::vector<std::unique_ptr<Node>> nested_, const std::vector<String> & explicit_names_) : nested(std::move(nested_)), explicit_names(explicit_names_)