We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
The type inference algorithm should use `TEXT` rather than `VARCHAR`
## Reproduce

1. "New Table" > "Import Data" > "Copy and Paste Text"

1. Paste the following data and proceed to create and view the table.

    ```txt
    first_name
    Marge
    Homer
    Lisa
    Bart
    Maggie
    ```

1. From the `columns` API, expect the response for the `first_name` column to have `"type": "TEXT"`

1. Observe instead that the column is `VARCHAR` without a length set.

## Rationale

- I spoke with @kgodey about the Mathesar Text type today and she say that Mathesar should only be configuring either: `TEXT` columns or `VARCHAR` columns with a length specified. She may be able to elaborate on the thinking that went into this decision.


## Additional context

- In #1118, we are doing some work to bring the front end into alignment with the above expectations when the user manually configures the DB settings for the Text 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: `db/columns/operations/infer_types.py`
Content:
```
1 import logging
2 
3 from sqlalchemy import VARCHAR, TEXT, Text
4 from sqlalchemy.exc import DatabaseError
5 
6 from db.columns.exceptions import DagCycleError
7 from db.columns.operations.alter import alter_column_type
8 from db.tables.operations.select import get_oid_from_table, reflect_table
9 from db.types.operations.cast import get_supported_alter_column_types
10 from db.types import base
11 
12 
13 logger = logging.getLogger(__name__)
14 
15 MAX_INFERENCE_DAG_DEPTH = 100
16 
17 TYPE_INFERENCE_DAG = {
18     base.PostgresType.BOOLEAN.value: [],
19     base.MathesarCustomType.EMAIL.value: [],
20     base.PostgresType.INTERVAL.value: [],
21     base.PostgresType.NUMERIC.value: [
22         base.PostgresType.BOOLEAN.value,
23     ],
24     base.STRING: [
25         base.PostgresType.BOOLEAN.value,
26         base.PostgresType.DATE.value,
27         base.PostgresType.NUMERIC.value,
28         base.MathesarCustomType.MATHESAR_MONEY.value,
29         base.PostgresType.TIMESTAMP_WITHOUT_TIME_ZONE.value,
30         base.PostgresType.TIMESTAMP_WITH_TIME_ZONE.value,
31         # We only infer to TIME_WITHOUT_TIME_ZONE as time zones don't make much sense
32         # without additional date information. See postgres documentation for further
33         # details: https://www.postgresql.org/docs/13/datatype-datetime.html
34         base.PostgresType.TIME_WITHOUT_TIME_ZONE.value,
35         base.PostgresType.INTERVAL.value,
36         base.MathesarCustomType.EMAIL.value,
37         base.MathesarCustomType.URI.value,
38     ],
39 }
40 
41 
42 def _get_reverse_type_map(engine):
43     supported_types = get_supported_alter_column_types(engine)
44     reverse_type_map = {v: k for k, v in supported_types.items()}
45     reverse_type_map.update(
46         {
47             Text: base.STRING,
48             TEXT: base.STRING,
49             VARCHAR: base.STRING,
50         }
51     )
52     return reverse_type_map
53 
54 
55 def infer_column_type(schema, table_name, column_name, engine, depth=0, type_inference_dag=TYPE_INFERENCE_DAG):
56     if depth > MAX_INFERENCE_DAG_DEPTH:
57         raise DagCycleError("The type_inference_dag likely has a cycle")
58     reverse_type_map = _get_reverse_type_map(engine)
59 
60     table = reflect_table(table_name, schema, engine)
61     column_type = table.columns[column_name].type.__class__
62     column_type_str = reverse_type_map.get(column_type)
63 
64     logger.debug(f"column_type_str: {column_type_str}")
65     table_oid = get_oid_from_table(table_name, schema, engine)
66     for type_str in type_inference_dag.get(column_type_str, []):
67         try:
68             with engine.begin() as conn:
69                 alter_column_type(table_oid, column_name, engine, conn, type_str)
70             logger.info(f"Column {column_name} altered to type {type_str}")
71             column_type = infer_column_type(
72                 schema,
73                 table_name,
74                 column_name,
75                 engine,
76                 depth=depth + 1,
77                 type_inference_dag=type_inference_dag,
78             )
79             break
80         # It's expected we catch this error when the test to see whether
81         # a type is appropriate for a column fails.
82         except DatabaseError:
83             logger.info(
84                 f"Cannot alter column {column_name} to type {type_str}"
85             )
86     return column_type
87
```

Path: `db/tables/operations/create.py`
Content:
```
1 from sqlalchemy import Column, String, Table, MetaData
2 from sqlalchemy.ext import compiler
3 from sqlalchemy.schema import DDLElement
4 
5 from db.columns.utils import init_mathesar_table_column_list_with_defaults
6 from db.schemas.operations.create import create_schema
7 
8 
9 def create_mathesar_table(name, schema, columns, engine, metadata=None):
10     """
11     This method creates a Postgres table in the specified schema using the
12     given name and column list.  It adds internal mathesar columns to the
13     table.
14     """
15     columns = init_mathesar_table_column_list_with_defaults(columns)
16     create_schema(schema, engine)
17     # We need this so that we can create multiple mathesar tables in the
18     # same MetaData, enabling them to reference each other in the
19     # SQLAlchemy context (e.g., for creating a ForeignKey relationship)
20     if metadata is None:
21         metadata = MetaData(bind=engine, schema=schema)
22     table = Table(
23         name,
24         metadata,
25         *columns,
26         schema=schema
27     )
28     table.create(engine)
29     return table
30 
31 
32 def create_string_column_table(name, schema, column_names, engine):
33     """
34     This method creates a Postgres table in the specified schema, with all
35     columns being String type.
36     """
37     columns_ = [Column(name=column_name, type_=String) for column_name in column_names]
38     table = create_mathesar_table(name, schema, columns_, engine)
39     return table
40 
41 
42 class CreateTableAs(DDLElement):
43     def __init__(self, name, selectable):
44         self.name = name
45         self.selectable = selectable
46 
47 
48 @compiler.compiles(CreateTableAs)
49 def compile_create_table_as(element, compiler, **_):
50     return "CREATE TABLE %s AS (%s)" % (
51         element.name,
52         compiler.sql_compiler.process(element.selectable, literal_binds=True),
53     )
54
```
--- 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/db/columns/operations/infer_types.py b/db/columns/operations/infer_types.py
--- a/db/columns/operations/infer_types.py
+++ b/db/columns/operations/infer_types.py
@@ -21,7 +21,7 @@
     base.PostgresType.NUMERIC.value: [
         base.PostgresType.BOOLEAN.value,
     ],
-    base.STRING: [
+    base.PostgresType.TEXT.value: [
         base.PostgresType.BOOLEAN.value,
         base.PostgresType.DATE.value,
         base.PostgresType.NUMERIC.value,
@@ -44,9 +44,9 @@
     reverse_type_map = {v: k for k, v in supported_types.items()}
     reverse_type_map.update(
         {
-            Text: base.STRING,
-            TEXT: base.STRING,
-            VARCHAR: base.STRING,
+            Text: base.PostgresType.TEXT.value,
+            TEXT: base.PostgresType.TEXT.value,
+            VARCHAR: base.PostgresType.TEXT.value,
         }
     )
     return reverse_type_map
diff --git a/db/tables/operations/create.py b/db/tables/operations/create.py
--- a/db/tables/operations/create.py
+++ b/db/tables/operations/create.py
@@ -1,4 +1,4 @@
-from sqlalchemy import Column, String, Table, MetaData
+from sqlalchemy import Column, TEXT, Table, MetaData
 from sqlalchemy.ext import compiler
 from sqlalchemy.schema import DDLElement
 
@@ -34,7 +34,7 @@
     This method creates a Postgres table in the specified schema, with all
     columns being String type.
     """
-    columns_ = [Column(name=column_name, type_=String) for column_name in column_names]
+    columns_ = [Column(name=column_name, type_=TEXT) for column_name in column_names]
     table = create_mathesar_table(name, schema, columns_, engine)
     return table

{"golden_diff": "diff --git a/db/columns/operations/infer_types.py b/db/columns/operations/infer_types.py\n--- a/db/columns/operations/infer_types.py\n+++ b/db/columns/operations/infer_types.py\n@@ -21,7 +21,7 @@\n     base.PostgresType.NUMERIC.value: [\n         base.PostgresType.BOOLEAN.value,\n     ],\n-    base.STRING: [\n+    base.PostgresType.TEXT.value: [\n         base.PostgresType.BOOLEAN.value,\n         base.PostgresType.DATE.value,\n         base.PostgresType.NUMERIC.value,\n@@ -44,9 +44,9 @@\n     reverse_type_map = {v: k for k, v in supported_types.items()}\n     reverse_type_map.update(\n         {\n-            Text: base.STRING,\n-            TEXT: base.STRING,\n-            VARCHAR: base.STRING,\n+            Text: base.PostgresType.TEXT.value,\n+            TEXT: base.PostgresType.TEXT.value,\n+            VARCHAR: base.PostgresType.TEXT.value,\n         }\n     )\n     return reverse_type_map\ndiff --git a/db/tables/operations/create.py b/db/tables/operations/create.py\n--- a/db/tables/operations/create.py\n+++ b/db/tables/operations/create.py\n@@ -1,4 +1,4 @@\n-from sqlalchemy import Column, String, Table, MetaData\n+from sqlalchemy import Column, TEXT, Table, MetaData\n from sqlalchemy.ext import compiler\n from sqlalchemy.schema import DDLElement\n \n@@ -34,7 +34,7 @@\n     This method creates a Postgres table in the specified schema, with all\n     columns being String type.\n     \"\"\"\n-    columns_ = [Column(name=column_name, type_=String) for column_name in column_names]\n+    columns_ = [Column(name=column_name, type_=TEXT) for column_name in column_names]\n     table = create_mathesar_table(name, schema, columns_, engine)\n     return table\n", "issue": "The type inference algorithm should use `TEXT` rather than `VARCHAR`\n## Reproduce\r\n\r\n1. \"New Table\" > \"Import Data\" > \"Copy and Paste Text\"\r\n\r\n1. Paste the following data and proceed to create and view the table.\r\n\r\n    ```txt\r\n    first_name\r\n    Marge\r\n    Homer\r\n    Lisa\r\n    Bart\r\n    Maggie\r\n    ```\r\n\r\n1. From the `columns` API, expect the response for the `first_name` column to have `\"type\": \"TEXT\"`\r\n\r\n1. Observe instead that the column is `VARCHAR` without a length set.\r\n\r\n## Rationale\r\n\r\n- I spoke with @kgodey about the Mathesar Text type today and she say that Mathesar should only be configuring either: `TEXT` columns or `VARCHAR` columns with a length specified. She may be able to elaborate on the thinking that went into this decision.\r\n\r\n\r\n## Additional context\r\n\r\n- In #1118, we are doing some work to bring the front end into alignment with the above expectations when the user manually configures the DB settings for the Text type.\r\n\r\n\n", "before_files": [{"content": "import logging\n\nfrom sqlalchemy import VARCHAR, TEXT, Text\nfrom sqlalchemy.exc import DatabaseError\n\nfrom db.columns.exceptions import DagCycleError\nfrom db.columns.operations.alter import alter_column_type\nfrom db.tables.operations.select import get_oid_from_table, reflect_table\nfrom db.types.operations.cast import get_supported_alter_column_types\nfrom db.types import base\n\n\nlogger = logging.getLogger(__name__)\n\nMAX_INFERENCE_DAG_DEPTH = 100\n\nTYPE_INFERENCE_DAG = {\n    base.PostgresType.BOOLEAN.value: [],\n    base.MathesarCustomType.EMAIL.value: [],\n    base.PostgresType.INTERVAL.value: [],\n    base.PostgresType.NUMERIC.value: [\n        base.PostgresType.BOOLEAN.value,\n    ],\n    base.STRING: [\n        base.PostgresType.BOOLEAN.value,\n        base.PostgresType.DATE.value,\n        base.PostgresType.NUMERIC.value,\n        base.MathesarCustomType.MATHESAR_MONEY.value,\n        base.PostgresType.TIMESTAMP_WITHOUT_TIME_ZONE.value,\n        base.PostgresType.TIMESTAMP_WITH_TIME_ZONE.value,\n        # We only infer to TIME_WITHOUT_TIME_ZONE as time zones don't make much sense\n        # without additional date information. See postgres documentation for further\n        # details: https://www.postgresql.org/docs/13/datatype-datetime.html\n        base.PostgresType.TIME_WITHOUT_TIME_ZONE.value,\n        base.PostgresType.INTERVAL.value,\n        base.MathesarCustomType.EMAIL.value,\n        base.MathesarCustomType.URI.value,\n    ],\n}\n\n\ndef _get_reverse_type_map(engine):\n    supported_types = get_supported_alter_column_types(engine)\n    reverse_type_map = {v: k for k, v in supported_types.items()}\n    reverse_type_map.update(\n        {\n            Text: base.STRING,\n            TEXT: base.STRING,\n            VARCHAR: base.STRING,\n        }\n    )\n    return reverse_type_map\n\n\ndef infer_column_type(schema, table_name, column_name, engine, depth=0, type_inference_dag=TYPE_INFERENCE_DAG):\n    if depth > MAX_INFERENCE_DAG_DEPTH:\n        raise DagCycleError(\"The type_inference_dag likely has a cycle\")\n    reverse_type_map = _get_reverse_type_map(engine)\n\n    table = reflect_table(table_name, schema, engine)\n    column_type = table.columns[column_name].type.__class__\n    column_type_str = reverse_type_map.get(column_type)\n\n    logger.debug(f\"column_type_str: {column_type_str}\")\n    table_oid = get_oid_from_table(table_name, schema, engine)\n    for type_str in type_inference_dag.get(column_type_str, []):\n        try:\n            with engine.begin() as conn:\n                alter_column_type(table_oid, column_name, engine, conn, type_str)\n            logger.info(f\"Column {column_name} altered to type {type_str}\")\n            column_type = infer_column_type(\n                schema,\n                table_name,\n                column_name,\n                engine,\n                depth=depth + 1,\n                type_inference_dag=type_inference_dag,\n            )\n            break\n        # It's expected we catch this error when the test to see whether\n        # a type is appropriate for a column fails.\n        except DatabaseError:\n            logger.info(\n                f\"Cannot alter column {column_name} to type {type_str}\"\n            )\n    return column_type\n", "path": "db/columns/operations/infer_types.py"}, {"content": "from sqlalchemy import Column, String, Table, MetaData\nfrom sqlalchemy.ext import compiler\nfrom sqlalchemy.schema import DDLElement\n\nfrom db.columns.utils import init_mathesar_table_column_list_with_defaults\nfrom db.schemas.operations.create import create_schema\n\n\ndef create_mathesar_table(name, schema, columns, engine, metadata=None):\n    \"\"\"\n    This method creates a Postgres table in the specified schema using the\n    given name and column list.  It adds internal mathesar columns to the\n    table.\n    \"\"\"\n    columns = init_mathesar_table_column_list_with_defaults(columns)\n    create_schema(schema, engine)\n    # We need this so that we can create multiple mathesar tables in the\n    # same MetaData, enabling them to reference each other in the\n    # SQLAlchemy context (e.g., for creating a ForeignKey relationship)\n    if metadata is None:\n        metadata = MetaData(bind=engine, schema=schema)\n    table = Table(\n        name,\n        metadata,\n        *columns,\n        schema=schema\n    )\n    table.create(engine)\n    return table\n\n\ndef create_string_column_table(name, schema, column_names, engine):\n    \"\"\"\n    This method creates a Postgres table in the specified schema, with all\n    columns being String type.\n    \"\"\"\n    columns_ = [Column(name=column_name, type_=String) for column_name in column_names]\n    table = create_mathesar_table(name, schema, columns_, engine)\n    return table\n\n\nclass CreateTableAs(DDLElement):\n    def __init__(self, name, selectable):\n        self.name = name\n        self.selectable = selectable\n\n\n@compiler.compiles(CreateTableAs)\ndef compile_create_table_as(element, compiler, **_):\n    return \"CREATE TABLE %s AS (%s)\" % (\n        element.name,\n        compiler.sql_compiler.process(element.selectable, literal_binds=True),\n    )\n", "path": "db/tables/operations/create.py"}], "after_files": [{"content": "import logging\n\nfrom sqlalchemy import VARCHAR, TEXT, Text\nfrom sqlalchemy.exc import DatabaseError\n\nfrom db.columns.exceptions import DagCycleError\nfrom db.columns.operations.alter import alter_column_type\nfrom db.tables.operations.select import get_oid_from_table, reflect_table\nfrom db.types.operations.cast import get_supported_alter_column_types\nfrom db.types import base\n\n\nlogger = logging.getLogger(__name__)\n\nMAX_INFERENCE_DAG_DEPTH = 100\n\nTYPE_INFERENCE_DAG = {\n    base.PostgresType.BOOLEAN.value: [],\n    base.MathesarCustomType.EMAIL.value: [],\n    base.PostgresType.INTERVAL.value: [],\n    base.PostgresType.NUMERIC.value: [\n        base.PostgresType.BOOLEAN.value,\n    ],\n    base.PostgresType.TEXT.value: [\n        base.PostgresType.BOOLEAN.value,\n        base.PostgresType.DATE.value,\n        base.PostgresType.NUMERIC.value,\n        base.MathesarCustomType.MATHESAR_MONEY.value,\n        base.PostgresType.TIMESTAMP_WITHOUT_TIME_ZONE.value,\n        base.PostgresType.TIMESTAMP_WITH_TIME_ZONE.value,\n        # We only infer to TIME_WITHOUT_TIME_ZONE as time zones don't make much sense\n        # without additional date information. See postgres documentation for further\n        # details: https://www.postgresql.org/docs/13/datatype-datetime.html\n        base.PostgresType.TIME_WITHOUT_TIME_ZONE.value,\n        base.PostgresType.INTERVAL.value,\n        base.MathesarCustomType.EMAIL.value,\n        base.MathesarCustomType.URI.value,\n    ],\n}\n\n\ndef _get_reverse_type_map(engine):\n    supported_types = get_supported_alter_column_types(engine)\n    reverse_type_map = {v: k for k, v in supported_types.items()}\n    reverse_type_map.update(\n        {\n            Text: base.PostgresType.TEXT.value,\n            TEXT: base.PostgresType.TEXT.value,\n            VARCHAR: base.PostgresType.TEXT.value,\n        }\n    )\n    return reverse_type_map\n\n\ndef infer_column_type(schema, table_name, column_name, engine, depth=0, type_inference_dag=TYPE_INFERENCE_DAG):\n    if depth > MAX_INFERENCE_DAG_DEPTH:\n        raise DagCycleError(\"The type_inference_dag likely has a cycle\")\n    reverse_type_map = _get_reverse_type_map(engine)\n\n    table = reflect_table(table_name, schema, engine)\n    column_type = table.columns[column_name].type.__class__\n    column_type_str = reverse_type_map.get(column_type)\n\n    logger.debug(f\"column_type_str: {column_type_str}\")\n    table_oid = get_oid_from_table(table_name, schema, engine)\n    for type_str in type_inference_dag.get(column_type_str, []):\n        try:\n            with engine.begin() as conn:\n                alter_column_type(table_oid, column_name, engine, conn, type_str)\n            logger.info(f\"Column {column_name} altered to type {type_str}\")\n            column_type = infer_column_type(\n                schema,\n                table_name,\n                column_name,\n                engine,\n                depth=depth + 1,\n                type_inference_dag=type_inference_dag,\n            )\n            break\n        # It's expected we catch this error when the test to see whether\n        # a type is appropriate for a column fails.\n        except DatabaseError:\n            logger.info(\n                f\"Cannot alter column {column_name} to type {type_str}\"\n            )\n    return column_type\n", "path": "db/columns/operations/infer_types.py"}, {"content": "from sqlalchemy import Column, TEXT, Table, MetaData\nfrom sqlalchemy.ext import compiler\nfrom sqlalchemy.schema import DDLElement\n\nfrom db.columns.utils import init_mathesar_table_column_list_with_defaults\nfrom db.schemas.operations.create import create_schema\n\n\ndef create_mathesar_table(name, schema, columns, engine, metadata=None):\n    \"\"\"\n    This method creates a Postgres table in the specified schema using the\n    given name and column list.  It adds internal mathesar columns to the\n    table.\n    \"\"\"\n    columns = init_mathesar_table_column_list_with_defaults(columns)\n    create_schema(schema, engine)\n    # We need this so that we can create multiple mathesar tables in the\n    # same MetaData, enabling them to reference each other in the\n    # SQLAlchemy context (e.g., for creating a ForeignKey relationship)\n    if metadata is None:\n        metadata = MetaData(bind=engine, schema=schema)\n    table = Table(\n        name,\n        metadata,\n        *columns,\n        schema=schema\n    )\n    table.create(engine)\n    return table\n\n\ndef create_string_column_table(name, schema, column_names, engine):\n    \"\"\"\n    This method creates a Postgres table in the specified schema, with all\n    columns being String type.\n    \"\"\"\n    columns_ = [Column(name=column_name, type_=TEXT) for column_name in column_names]\n    table = create_mathesar_table(name, schema, columns_, engine)\n    return table\n\n\nclass CreateTableAs(DDLElement):\n    def __init__(self, name, selectable):\n        self.name = name\n        self.selectable = selectable\n\n\n@compiler.compiles(CreateTableAs)\ndef compile_create_table_as(element, compiler, **_):\n    return \"CREATE TABLE %s AS (%s)\" % (\n        element.name,\n        compiler.sql_compiler.process(element.selectable, literal_binds=True),\n    )\n", "path": "db/tables/operations/create.py"}]}