code: def to_sql(
      df,
      name: str,
      con,
      schema=None,
      if_exists: str = "fail",
      index: bool = True,
      index_label=None,
      chunksize=None,
      dtype=None,
      method=None,
  ):
      """
      Write records stored in a DataFrame to a SQL database.
  
      Databases supported by SQLAlchemy [1]_ are supported. Tables can be
      newly created, appended to, or overwritten.
  
      Parameters
      ----------
      name : str
          Name of SQL table.
      con : sqlalchemy.engine.Engine or sqlite3.Connection
          Using SQLAlchemy makes it possible to use any DB supported by that
          library. Legacy support is provided for sqlite3.Connection objects. The user
          is responsible for engine disposal and connection closure for the SQLAlchemy
          connectable See `here                 <https://docs.sqlalchemy.org/en/13/core/connections.html>`_
  
      schema : str, optional
          Specify the schema (if database flavor supports this). If None, use
          default schema.
      if_exists : {'fail', 'replace', 'append'}, default 'fail'
          How to behave if the table already exists.
  
          * fail: Raise a ValueError.
          * replace: Drop the table before inserting new values.
          * append: Insert new values to the existing table.
  
      index : bool, default True
          Write DataFrame index as a column. Uses `index_label` as the column
          name in the table.
      index_label : str or sequence, default None
          Column label for index column(s). If None is given (default) and
          `index` is True, then the index names are used.
          A sequence should be given if the DataFrame uses MultiIndex.
      chunksize : int, optional
          Specify the number of rows in each batch to be written at a time.
          By default, all rows will be written at once.
      dtype : dict or scalar, optional
          Specifying the datatype for columns. If a dictionary is used, the
          keys should be the column names and the values should be the
          SQLAlchemy types or strings for the sqlite3 legacy mode. If a
          scalar is provided, it will be applied to all columns.
      method : {None, 'multi', callable}, optional
          Controls the SQL insertion clause used:
  
          * None : Uses standard SQL ``INSERT`` clause (one per row).
          * 'multi': Pass multiple values in a single ``INSERT`` clause.
          * callable with signature ``(pd_table, conn, keys, data_iter)``.
  
          Details and a sample callable implementation can be found in the
          section :ref:`insert method <io.sql.method>`.
  
          .. versionadded:: 0.24.0
  
      Raises
      ------
      ValueError
          When the table already exists and `if_exists` is 'fail' (the
          default).
  
      See Also
      --------
      read_sql : Read a DataFrame from a table.
  
      Notes
      -----
      Timezone aware datetime columns will be written as
      ``Timestamp with timezone`` type with SQLAlchemy if supported by the
      database. Otherwise, the datetimes will be stored as timezone unaware
      timestamps local to the original timezone.
  
      .. versionadded:: 0.24.0
  
      References
      ----------
      .. [1] http://docs.sqlalchemy.org
      .. [2] https://www.python.org/dev/peps/pep-0249/
  
      Examples
      --------
  
      Create an in-memory SQLite database.
  
      >>> import mars.dataframe as md
      >>> from sqlalchemy import create_engine
      >>> engine = create_engine('sqlite:////tmp/temp.db')
  
      Create a table from scratch with 3 rows.
  
      >>> df = md.DataFrame({'name' : ['User 1', 'User 2', 'User 3']})
      >>> df.execute()
           name
      0  User 1
      1  User 2
      2  User 3
  
      >>> df.to_sql('users', con=engine).execute()
      >>> engine.execute("SELECT * FROM users").fetchall()
      [(0, 'User 1'), (1, 'User 2'), (2, 'User 3')]
  
      >>> df1 = md.DataFrame({'name' : ['User 4', 'User 5']})
      >>> df1.to_sql('users', con=engine, if_exists='append').execute()
      >>> engine.execute("SELECT * FROM users").fetchall()
      [(0, 'User 1'), (1, 'User 2'), (2, 'User 3'),
       (0, 'User 4'), (1, 'User 5')]
  
      Overwrite the table with just ``df1``.
  
      >>> df1.to_sql('users', con=engine, if_exists='replace',
      ...            index_label='id').execute()
      >>> engine.execute("SELECT * FROM users").fetchall()
      [(0, 'User 4'), (1, 'User 5')]
  
      Specify the dtype (especially useful for integers with missing values).
      Notice that while pandas is forced to store the data as floating point,
      the database supports nullable integers. When fetching the data with
      Python, we get back integer scalars.
  
      >>> df = md.DataFrame({"A": [1, None, 2]})
      >>> df.execute()
           A
      0  1.0
      1  NaN
      2  2.0
  
      >>> from sqlalchemy.types import Integer
      >>> df.to_sql('integers', con=engine, index=False,
      ...           dtype={"A": Integer()}).execute()
  
      >>> engine.execute("SELECT * FROM integers").fetchall()
      [(1,), (None,), (2,)]
      """
      op = DataFrameToSQLTable(
          table_name=name,
          con=con,
          schema=schema,
          if_exists=if_exists,
          index=index,
          index_label=index_label,
          chunksize=chunksize,
          dtype=dtype,
          method=method,
      )
      return op(df)
  
file_path: mars/mars/dataframe/datastore/to_sql.py
imports: import pandas
  import cloudpickle
  from ...None import opcodes
  from ...core import recursive_tile
  from ...core.operand import OperatorLogicKeyGeneratorMixin
  from ...serialization.serializables import StringField, AnyField, BoolField, Int64Field, BytesField
  from ..core import DATAFRAME_TYPE
  from ..operands import DataFrameOperand, DataFrameOperandMixin
  from ..utils import parse_index, build_empty_df, build_empty_series, create_sa_connection, patch_sa_engine_execute
label_desc: Use image node_id 1 for calling a global function with example usage: to_sql(df, name, con, schema, if_exists, index, index_label, chunksize, dtype, method) and returns: op