docstr: test #9701.
  
  this tests insertmanyvalues as well as decimal / floating point
  RETURNING types
docstr_tok: ["test","#","9701.","this","tests","insertmanyvalues","as","well","as","decimal","\/","floating","point","RETURNING","types"]
code: def test_insert_w_floats(
      self,
      connection,
      metadata,
      sort_by_parameter_order,
      type_,
      value,
      do_rounding,
      multiple_rows,
  ):
      """test #9701.
  
      this tests insertmanyvalues as well as decimal / floating point
      RETURNING types
  
      """
  
      t = Table(
          # Oracle backends seems to be getting confused if
          # this table is named the same as the one
          # in test_imv_returning_datatypes.  use a different name
          "f_t",
          metadata,
          Column("id", Integer, Identity(), primary_key=True),
          Column("value", type_),
      )
  
      t.create(connection)
  
      result = connection.execute(
          t.insert().returning(
              t.c.id,
              t.c.value,
              sort_by_parameter_order=bool(sort_by_parameter_order),
          ),
          [{"value": value} for i in range(10)]
          if multiple_rows
          else {"value": value},
      )
  
      if multiple_rows:
          i_range = range(1, 11)
      else:
          i_range = range(1, 2)
  
      # we want to test only that we are getting floating points back
      # with some degree of the original value maintained, that it is not
      # being truncated to an integer.  there's too much variation in how
      # drivers return floats, which should not be relied upon to be
      # exact, for us to just compare as is (works for PG drivers but not
      # others) so we use rounding here.  There's precedent for this
      # in suite/test_types.py::NumericTest as well
  
      if do_rounding:
          eq_(
              {(id_, round(val_, 5)) for id_, val_ in result},
              {(id_, round(value, 5)) for id_ in i_range},
          )
  
          eq_(
              {
                  round(val_, 5)
                  for val_ in connection.scalars(select(t.c.value))
              },
              {round(value, 5)},
          )
      else:
          eq_(
              set(result),
              {(id_, value) for id_ in i_range},
          )
  
          eq_(
              set(connection.scalars(select(t.c.value))),
              {value},
          )
  
imports: from decimal import Decimal
  import uuid
  from .None import testing
  from ..None import fixtures
  from ..assertions import eq_
  from ..config import requirements
  from ..schema import Column
  from ..schema import Table
  from ...None import Double
  from ...None import Float
  from ...None import Identity
  from ...None import Integer
  from ...None import literal
  from ...None import literal_column
  from ...None import Numeric
  from ...None import select
  from ...None import String
  from ...types import LargeBinary
  from ...types import UUID
  from ...types import Uuid
label_desc: Use image node_id 8 for calling the ReturningTest obj's underlying member method code with example usage: obj.test_insert_w_floats(connection, metadata, sort_by_parameter_order, type_, value, do_rounding, multiple_rows) without return types