code: def test_from_element(self):
      t_env = self.t_env
      field_names = [
          "a",
          "b",
          "c",
          "d",
          "e",
          "f",
          "g",
          "h",
          "i",
          "j",
          "k",
          "l",
          "m",
          "n",
          "o",
          "p",
          "q",
      ]
      field_types = [
          DataTypes.BIGINT(),
          DataTypes.DOUBLE(),
          DataTypes.STRING(),
          DataTypes.STRING(),
          DataTypes.DATE(),
          DataTypes.TIME(),
          DataTypes.TIMESTAMP(3),
          DataTypes.INTERVAL(DataTypes.SECOND(3)),
          DataTypes.ARRAY(DataTypes.DOUBLE()),
          DataTypes.ARRAY(DataTypes.DOUBLE(False)),
          DataTypes.ARRAY(DataTypes.STRING()),
          DataTypes.ARRAY(DataTypes.DATE()),
          DataTypes.DECIMAL(38, 18),
          DataTypes.ROW(
              [
                  DataTypes.FIELD("a", DataTypes.BIGINT()),
                  DataTypes.FIELD("b", DataTypes.DOUBLE()),
              ]
          ),
          DataTypes.MAP(DataTypes.STRING(), DataTypes.DOUBLE()),
          DataTypes.BYTES(),
          PythonOnlyUDT(),
      ]
      schema = DataTypes.ROW(
          list(
              map(
                  lambda field_name, field_type: DataTypes.FIELD(
                      field_name, field_type
                  ),
                  field_names,
                  field_types,
              )
          )
      )
  
      sink_table_ddl = """
              CREATE TABLE Results(
              a BIGINT,
              b DOUBLE,
              c STRING,
              d STRING,
              e DATE,
              f TIME,
              g TIMESTAMP(3),
              h INT,
              i ARRAY<DOUBLE>,
              j ARRAY<DOUBLE NOT NULL>,
              k ARRAY<STRING>,
              l ARRAY<DATE>,
              m DECIMAL(38, 18),
              n ROW<a BIGINT, b DOUBLE>,
              o MAP<STRING, DOUBLE>,
              p BYTES,
              q ARRAY<DOUBLE NOT NULL>)
              WITH ('connector'='test-sink')
          """
      self.t_env.execute_sql(sink_table_ddl)
  
      t = t_env.from_elements(
          [
              (
                  1,
                  1.0,
                  "hi",
                  "hello",
                  datetime.date(1970, 1, 2),
                  datetime.time(1, 0, 0),
                  datetime.datetime(1970, 1, 2, 0, 0),
                  datetime.timedelta(days=1, microseconds=10),
                  [1.0, None],
                  array.array("d", [1.0, 2.0]),
                  ["abc"],
                  [datetime.date(1970, 1, 2)],
                  Decimal(1),
                  Row("a", "b")(1, 2.0),
                  {"key": 1.0},
                  bytearray(b"ABCD"),
                  PythonOnlyPoint(3.0, 4.0),
              )
          ],
          schema,
      )
      t.execute_insert("Results").wait()
      actual = source_sink_utils.results()
  
      expected = [
          "+I[1, 1.0, hi, hello, 1970-01-02, 01:00, 1970-01-02T00:00, "
          "86400, [1.0, null], [1.0, 2.0], [abc], [1970-01-02], "
          "1.000000000000000000, +I[1, 2.0], {key=1.0}, [65, 66, 67, 68], [3.0, 4.0]]"
      ]
      self.assert_equals(actual, expected)
  
file_path: flink/flink-python/pyflink/table/tests/test_calc.py
imports: import array
  import datetime
  from decimal import Decimal
  from pyflink.common import Row
  from pyflink.table import DataTypes
  from pyflink.table.expressions import row
  from pyflink.table.tests.test_types import PythonOnlyPoint, PythonOnlyUDT
  from pyflink.testing import source_sink_utils
  from pyflink.testing.test_case_utils import PyFlinkStreamTableTestCase
label_desc: Use image node_id 5 for calling the StreamTableCalcTests obj's underlying member method code with example usage: obj.test_from_element() without return types