We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
[OmniSci] Add float32 dtype support
Looks like our calcite serializer doesn't support float32 type.

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `modin/experimental/engines/omnisci_on_ray/frame/calcite_serializer.py`
Content:
```
1 # Licensed to Modin Development Team under one or more contributor license agreements.
2 # See the NOTICE file distributed with this work for additional information regarding
3 # copyright ownership.  The Modin Development Team licenses this file to you under the
4 # Apache License, Version 2.0 (the "License"); you may not use this file except in
5 # compliance with the License.  You may obtain a copy of the License at
6 #
7 #     http://www.apache.org/licenses/LICENSE-2.0
8 #
9 # Unless required by applicable law or agreed to in writing, software distributed under
10 # the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
11 # ANY KIND, either express or implied. See the License for the specific language
12 # governing permissions and limitations under the License.
13 
14 from .expr import (
15     BaseExpr,
16     LiteralExpr,
17     OpExpr,
18     AggregateExpr,
19 )
20 from .calcite_algebra import (
21     CalciteBaseNode,
22     CalciteInputRefExpr,
23     CalciteInputIdxExpr,
24     CalciteScanNode,
25     CalciteProjectionNode,
26     CalciteFilterNode,
27     CalciteAggregateNode,
28     CalciteCollation,
29     CalciteSortNode,
30     CalciteJoinNode,
31     CalciteUnionNode,
32 )
33 import json
34 import numpy as np
35 
36 
37 class CalciteSerializer:
38     dtype_strings = {
39         "int8": "TINYINT",
40         "int16": "SMALLINT",
41         "int32": "INTEGER",
42         "int64": "BIGINT",
43         "bool": "BOOLEAN",
44         "float64": "DOUBLE",
45     }
46 
47     def serialize(self, plan):
48         return json.dumps({"rels": [self.serialize_item(node) for node in plan]})
49 
50     def expect_one_of(self, val, *types):
51         for t in types:
52             if isinstance(val, t):
53                 return
54         raise TypeError("Can not serialize {}".format(type(val).__name__))
55 
56     def serialize_item(self, item):
57         if isinstance(item, CalciteBaseNode):
58             return self.serialize_node(item)
59         elif isinstance(item, BaseExpr):
60             return self.serialize_expr(item)
61         elif isinstance(item, CalciteCollation):
62             return self.serialize_obj(item)
63         elif isinstance(item, list):
64             return [self.serialize_item(v) for v in item]
65 
66         self.expect_one_of(item, str, int)
67         return item
68 
69     def serialize_node(self, node):
70         # We need to setup context for proper references
71         # serialization
72         if isinstance(
73             node,
74             (
75                 CalciteScanNode,
76                 CalciteProjectionNode,
77                 CalciteFilterNode,
78                 CalciteAggregateNode,
79                 CalciteSortNode,
80                 CalciteJoinNode,
81                 CalciteUnionNode,
82             ),
83         ):
84             return self.serialize_obj(node)
85         else:
86             raise NotImplementedError(
87                 "Can not serialize {}".format(type(node).__name__)
88             )
89 
90     def serialize_obj(self, obj):
91         res = {}
92         for k, v in obj.__dict__.items():
93             if k[0] != "_":
94                 res[k] = self.serialize_item(v)
95         return res
96 
97     def serialize_typed_obj(self, obj):
98         res = self.serialize_obj(obj)
99         res["type"] = self.serialize_dtype(obj._dtype)
100         return res
101 
102     def serialize_expr(self, expr):
103         if isinstance(expr, LiteralExpr):
104             return self.serialize_literal(expr)
105         elif isinstance(expr, CalciteInputRefExpr):
106             return self.serialize_obj(expr)
107         elif isinstance(expr, CalciteInputIdxExpr):
108             return self.serialize_input_idx(expr)
109         elif isinstance(expr, OpExpr):
110             return self.serialize_typed_obj(expr)
111         elif isinstance(expr, AggregateExpr):
112             return self.serialize_typed_obj(expr)
113         else:
114             raise NotImplementedError(
115                 "Can not serialize {}".format(type(expr).__name__)
116             )
117 
118     def serialize_literal(self, literal):
119         if literal.val is None:
120             return {
121                 "literal": None,
122                 "type": "BIGINT",
123                 "target_type": "BIGINT",
124                 "scale": 0,
125                 "precision": 19,
126                 "type_scale": 0,
127                 "type_precision": 19,
128             }
129         if type(literal.val) is str:
130             return {
131                 "literal": literal.val,
132                 "type": "CHAR",
133                 "target_type": "CHAR",
134                 "scale": -2147483648,
135                 "precision": len(literal.val),
136                 "type_scale": -2147483648,
137                 "type_precision": len(literal.val),
138             }
139         if type(literal.val) in (int, np.int8, np.int16, np.int32, np.int64):
140             target_type, precision = self.opts_for_int_type(type(literal.val))
141             return {
142                 "literal": int(literal.val),
143                 "type": "DECIMAL",
144                 "target_type": target_type,
145                 "scale": 0,
146                 "precision": len(str(literal.val)),
147                 "type_scale": 0,
148                 "type_precision": precision,
149             }
150         if type(literal.val) in (float, np.float64):
151             str_val = f"{literal.val:f}"
152             precision = len(str_val) - 1
153             scale = precision - str_val.index(".")
154             return {
155                 "literal": int(str_val.replace(".", "")),
156                 "type": "DECIMAL",
157                 "target_type": "DOUBLE",
158                 "scale": scale,
159                 "precision": precision,
160                 "type_scale": -2147483648,
161                 "type_precision": 15,
162             }
163         if type(literal.val) is bool:
164             return {
165                 "literal": literal.val,
166                 "type": "BOOLEAN",
167                 "target_type": "BOOLEAN",
168                 "scale": -2147483648,
169                 "precision": 1,
170                 "type_scale": -2147483648,
171                 "type_precision": 1,
172             }
173         raise NotImplementedError(f"Can not serialize {type(literal.val).__name__}")
174 
175     def opts_for_int_type(self, int_type):
176         if int_type is np.int8:
177             return "TINYINT", 3
178         if int_type is np.int16:
179             return "SMALLINT", 5
180         if int_type is np.int32:
181             return "INTEGER", 10
182         if int_type in (np.int64, int):
183             return "BIGINT", 19
184         raise NotImplementedError(f"Unsupported integer type {int_type.__name__}")
185 
186     def serialize_dtype(self, dtype):
187         return {"type": type(self).dtype_strings[dtype.name], "nullable": True}
188 
189     def serialize_input_idx(self, expr):
190         return expr.input
191
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/modin/experimental/engines/omnisci_on_ray/frame/calcite_serializer.py b/modin/experimental/engines/omnisci_on_ray/frame/calcite_serializer.py
--- a/modin/experimental/engines/omnisci_on_ray/frame/calcite_serializer.py
+++ b/modin/experimental/engines/omnisci_on_ray/frame/calcite_serializer.py
@@ -41,6 +41,7 @@
         "int32": "INTEGER",
         "int64": "BIGINT",
         "bool": "BOOLEAN",
+        "float32": "FLOAT",
         "float64": "DOUBLE",
     }

{"golden_diff": "diff --git a/modin/experimental/engines/omnisci_on_ray/frame/calcite_serializer.py b/modin/experimental/engines/omnisci_on_ray/frame/calcite_serializer.py\n--- a/modin/experimental/engines/omnisci_on_ray/frame/calcite_serializer.py\n+++ b/modin/experimental/engines/omnisci_on_ray/frame/calcite_serializer.py\n@@ -41,6 +41,7 @@\n         \"int32\": \"INTEGER\",\n         \"int64\": \"BIGINT\",\n         \"bool\": \"BOOLEAN\",\n+        \"float32\": \"FLOAT\",\n         \"float64\": \"DOUBLE\",\n     }\n", "issue": "[OmniSci] Add float32 dtype support\nLooks like our calcite serializer doesn't support float32 type.\n", "before_files": [{"content": "# Licensed to Modin Development Team under one or more contributor license agreements.\n# See the NOTICE file distributed with this work for additional information regarding\n# copyright ownership.  The Modin Development Team licenses this file to you under the\n# Apache License, Version 2.0 (the \"License\"); you may not use this file except in\n# compliance with the License.  You may obtain a copy of the License at\n#\n#     http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software distributed under\n# the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF\n# ANY KIND, either express or implied. See the License for the specific language\n# governing permissions and limitations under the License.\n\nfrom .expr import (\n    BaseExpr,\n    LiteralExpr,\n    OpExpr,\n    AggregateExpr,\n)\nfrom .calcite_algebra import (\n    CalciteBaseNode,\n    CalciteInputRefExpr,\n    CalciteInputIdxExpr,\n    CalciteScanNode,\n    CalciteProjectionNode,\n    CalciteFilterNode,\n    CalciteAggregateNode,\n    CalciteCollation,\n    CalciteSortNode,\n    CalciteJoinNode,\n    CalciteUnionNode,\n)\nimport json\nimport numpy as np\n\n\nclass CalciteSerializer:\n    dtype_strings = {\n        \"int8\": \"TINYINT\",\n        \"int16\": \"SMALLINT\",\n        \"int32\": \"INTEGER\",\n        \"int64\": \"BIGINT\",\n        \"bool\": \"BOOLEAN\",\n        \"float64\": \"DOUBLE\",\n    }\n\n    def serialize(self, plan):\n        return json.dumps({\"rels\": [self.serialize_item(node) for node in plan]})\n\n    def expect_one_of(self, val, *types):\n        for t in types:\n            if isinstance(val, t):\n                return\n        raise TypeError(\"Can not serialize {}\".format(type(val).__name__))\n\n    def serialize_item(self, item):\n        if isinstance(item, CalciteBaseNode):\n            return self.serialize_node(item)\n        elif isinstance(item, BaseExpr):\n            return self.serialize_expr(item)\n        elif isinstance(item, CalciteCollation):\n            return self.serialize_obj(item)\n        elif isinstance(item, list):\n            return [self.serialize_item(v) for v in item]\n\n        self.expect_one_of(item, str, int)\n        return item\n\n    def serialize_node(self, node):\n        # We need to setup context for proper references\n        # serialization\n        if isinstance(\n            node,\n            (\n                CalciteScanNode,\n                CalciteProjectionNode,\n                CalciteFilterNode,\n                CalciteAggregateNode,\n                CalciteSortNode,\n                CalciteJoinNode,\n                CalciteUnionNode,\n            ),\n        ):\n            return self.serialize_obj(node)\n        else:\n            raise NotImplementedError(\n                \"Can not serialize {}\".format(type(node).__name__)\n            )\n\n    def serialize_obj(self, obj):\n        res = {}\n        for k, v in obj.__dict__.items():\n            if k[0] != \"_\":\n                res[k] = self.serialize_item(v)\n        return res\n\n    def serialize_typed_obj(self, obj):\n        res = self.serialize_obj(obj)\n        res[\"type\"] = self.serialize_dtype(obj._dtype)\n        return res\n\n    def serialize_expr(self, expr):\n        if isinstance(expr, LiteralExpr):\n            return self.serialize_literal(expr)\n        elif isinstance(expr, CalciteInputRefExpr):\n            return self.serialize_obj(expr)\n        elif isinstance(expr, CalciteInputIdxExpr):\n            return self.serialize_input_idx(expr)\n        elif isinstance(expr, OpExpr):\n            return self.serialize_typed_obj(expr)\n        elif isinstance(expr, AggregateExpr):\n            return self.serialize_typed_obj(expr)\n        else:\n            raise NotImplementedError(\n                \"Can not serialize {}\".format(type(expr).__name__)\n            )\n\n    def serialize_literal(self, literal):\n        if literal.val is None:\n            return {\n                \"literal\": None,\n                \"type\": \"BIGINT\",\n                \"target_type\": \"BIGINT\",\n                \"scale\": 0,\n                \"precision\": 19,\n                \"type_scale\": 0,\n                \"type_precision\": 19,\n            }\n        if type(literal.val) is str:\n            return {\n                \"literal\": literal.val,\n                \"type\": \"CHAR\",\n                \"target_type\": \"CHAR\",\n                \"scale\": -2147483648,\n                \"precision\": len(literal.val),\n                \"type_scale\": -2147483648,\n                \"type_precision\": len(literal.val),\n            }\n        if type(literal.val) in (int, np.int8, np.int16, np.int32, np.int64):\n            target_type, precision = self.opts_for_int_type(type(literal.val))\n            return {\n                \"literal\": int(literal.val),\n                \"type\": \"DECIMAL\",\n                \"target_type\": target_type,\n                \"scale\": 0,\n                \"precision\": len(str(literal.val)),\n                \"type_scale\": 0,\n                \"type_precision\": precision,\n            }\n        if type(literal.val) in (float, np.float64):\n            str_val = f\"{literal.val:f}\"\n            precision = len(str_val) - 1\n            scale = precision - str_val.index(\".\")\n            return {\n                \"literal\": int(str_val.replace(\".\", \"\")),\n                \"type\": \"DECIMAL\",\n                \"target_type\": \"DOUBLE\",\n                \"scale\": scale,\n                \"precision\": precision,\n                \"type_scale\": -2147483648,\n                \"type_precision\": 15,\n            }\n        if type(literal.val) is bool:\n            return {\n                \"literal\": literal.val,\n                \"type\": \"BOOLEAN\",\n                \"target_type\": \"BOOLEAN\",\n                \"scale\": -2147483648,\n                \"precision\": 1,\n                \"type_scale\": -2147483648,\n                \"type_precision\": 1,\n            }\n        raise NotImplementedError(f\"Can not serialize {type(literal.val).__name__}\")\n\n    def opts_for_int_type(self, int_type):\n        if int_type is np.int8:\n            return \"TINYINT\", 3\n        if int_type is np.int16:\n            return \"SMALLINT\", 5\n        if int_type is np.int32:\n            return \"INTEGER\", 10\n        if int_type in (np.int64, int):\n            return \"BIGINT\", 19\n        raise NotImplementedError(f\"Unsupported integer type {int_type.__name__}\")\n\n    def serialize_dtype(self, dtype):\n        return {\"type\": type(self).dtype_strings[dtype.name], \"nullable\": True}\n\n    def serialize_input_idx(self, expr):\n        return expr.input\n", "path": "modin/experimental/engines/omnisci_on_ray/frame/calcite_serializer.py"}], "after_files": [{"content": "# Licensed to Modin Development Team under one or more contributor license agreements.\n# See the NOTICE file distributed with this work for additional information regarding\n# copyright ownership.  The Modin Development Team licenses this file to you under the\n# Apache License, Version 2.0 (the \"License\"); you may not use this file except in\n# compliance with the License.  You may obtain a copy of the License at\n#\n#     http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software distributed under\n# the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF\n# ANY KIND, either express or implied. See the License for the specific language\n# governing permissions and limitations under the License.\n\nfrom .expr import (\n    BaseExpr,\n    LiteralExpr,\n    OpExpr,\n    AggregateExpr,\n)\nfrom .calcite_algebra import (\n    CalciteBaseNode,\n    CalciteInputRefExpr,\n    CalciteInputIdxExpr,\n    CalciteScanNode,\n    CalciteProjectionNode,\n    CalciteFilterNode,\n    CalciteAggregateNode,\n    CalciteCollation,\n    CalciteSortNode,\n    CalciteJoinNode,\n    CalciteUnionNode,\n)\nimport json\nimport numpy as np\n\n\nclass CalciteSerializer:\n    dtype_strings = {\n        \"int8\": \"TINYINT\",\n        \"int16\": \"SMALLINT\",\n        \"int32\": \"INTEGER\",\n        \"int64\": \"BIGINT\",\n        \"bool\": \"BOOLEAN\",\n        \"float32\": \"FLOAT\",\n        \"float64\": \"DOUBLE\",\n    }\n\n    def serialize(self, plan):\n        return json.dumps({\"rels\": [self.serialize_item(node) for node in plan]})\n\n    def expect_one_of(self, val, *types):\n        for t in types:\n            if isinstance(val, t):\n                return\n        raise TypeError(\"Can not serialize {}\".format(type(val).__name__))\n\n    def serialize_item(self, item):\n        if isinstance(item, CalciteBaseNode):\n            return self.serialize_node(item)\n        elif isinstance(item, BaseExpr):\n            return self.serialize_expr(item)\n        elif isinstance(item, CalciteCollation):\n            return self.serialize_obj(item)\n        elif isinstance(item, list):\n            return [self.serialize_item(v) for v in item]\n\n        self.expect_one_of(item, str, int)\n        return item\n\n    def serialize_node(self, node):\n        # We need to setup context for proper references\n        # serialization\n        if isinstance(\n            node,\n            (\n                CalciteScanNode,\n                CalciteProjectionNode,\n                CalciteFilterNode,\n                CalciteAggregateNode,\n                CalciteSortNode,\n                CalciteJoinNode,\n                CalciteUnionNode,\n            ),\n        ):\n            return self.serialize_obj(node)\n        else:\n            raise NotImplementedError(\n                \"Can not serialize {}\".format(type(node).__name__)\n            )\n\n    def serialize_obj(self, obj):\n        res = {}\n        for k, v in obj.__dict__.items():\n            if k[0] != \"_\":\n                res[k] = self.serialize_item(v)\n        return res\n\n    def serialize_typed_obj(self, obj):\n        res = self.serialize_obj(obj)\n        res[\"type\"] = self.serialize_dtype(obj._dtype)\n        return res\n\n    def serialize_expr(self, expr):\n        if isinstance(expr, LiteralExpr):\n            return self.serialize_literal(expr)\n        elif isinstance(expr, CalciteInputRefExpr):\n            return self.serialize_obj(expr)\n        elif isinstance(expr, CalciteInputIdxExpr):\n            return self.serialize_input_idx(expr)\n        elif isinstance(expr, OpExpr):\n            return self.serialize_typed_obj(expr)\n        elif isinstance(expr, AggregateExpr):\n            return self.serialize_typed_obj(expr)\n        else:\n            raise NotImplementedError(\n                \"Can not serialize {}\".format(type(expr).__name__)\n            )\n\n    def serialize_literal(self, literal):\n        if literal.val is None:\n            return {\n                \"literal\": None,\n                \"type\": \"BIGINT\",\n                \"target_type\": \"BIGINT\",\n                \"scale\": 0,\n                \"precision\": 19,\n                \"type_scale\": 0,\n                \"type_precision\": 19,\n            }\n        if type(literal.val) is str:\n            return {\n                \"literal\": literal.val,\n                \"type\": \"CHAR\",\n                \"target_type\": \"CHAR\",\n                \"scale\": -2147483648,\n                \"precision\": len(literal.val),\n                \"type_scale\": -2147483648,\n                \"type_precision\": len(literal.val),\n            }\n        if type(literal.val) in (int, np.int8, np.int16, np.int32, np.int64):\n            target_type, precision = self.opts_for_int_type(type(literal.val))\n            return {\n                \"literal\": int(literal.val),\n                \"type\": \"DECIMAL\",\n                \"target_type\": target_type,\n                \"scale\": 0,\n                \"precision\": len(str(literal.val)),\n                \"type_scale\": 0,\n                \"type_precision\": precision,\n            }\n        if type(literal.val) in (float, np.float64):\n            str_val = f\"{literal.val:f}\"\n            precision = len(str_val) - 1\n            scale = precision - str_val.index(\".\")\n            return {\n                \"literal\": int(str_val.replace(\".\", \"\")),\n                \"type\": \"DECIMAL\",\n                \"target_type\": \"DOUBLE\",\n                \"scale\": scale,\n                \"precision\": precision,\n                \"type_scale\": -2147483648,\n                \"type_precision\": 15,\n            }\n        if type(literal.val) is bool:\n            return {\n                \"literal\": literal.val,\n                \"type\": \"BOOLEAN\",\n                \"target_type\": \"BOOLEAN\",\n                \"scale\": -2147483648,\n                \"precision\": 1,\n                \"type_scale\": -2147483648,\n                \"type_precision\": 1,\n            }\n        raise NotImplementedError(f\"Can not serialize {type(literal.val).__name__}\")\n\n    def opts_for_int_type(self, int_type):\n        if int_type is np.int8:\n            return \"TINYINT\", 3\n        if int_type is np.int16:\n            return \"SMALLINT\", 5\n        if int_type is np.int32:\n            return \"INTEGER\", 10\n        if int_type in (np.int64, int):\n            return \"BIGINT\", 19\n        raise NotImplementedError(f\"Unsupported integer type {int_type.__name__}\")\n\n    def serialize_dtype(self, dtype):\n        return {\"type\": type(self).dtype_strings[dtype.name], \"nullable\": True}\n\n    def serialize_input_idx(self, expr):\n        return expr.input\n", "path": "modin/experimental/engines/omnisci_on_ray/frame/calcite_serializer.py"}]}