prompt: You will be provided with a partial code base and an issue statement explaining a problem to resolve.
  <issue>
  Athena Iceberg Tables parsing issue
  Hi,
  I want to parse a SQL Statement that creates an Iceberg table on Athena:
  
  ```sql
  create table if not exists tmp.mytable (
      name string
  )
  location 's3://bucket/tmp/mytable/'
  tblproperties (
    'table_type'='iceberg',
    'format'='parquet'
  );
  ```
  running 
  ```python
  stmts = sqlglot.parse(sql, read=sqlglot.Dialects.ATHENA)
  stmts[0].sql()
  ```
  returns:
  ```sql
  CREATE TABLE IF NOT EXISTS tmp.mytable 
      (name TEXT) 
  LOCATION 's3://bucket/tmp/mytable/' 
  WITH (
      table_type='iceberg', 
      FORMAT='parquet'
  )
  ```
  
  Unfortunately, the syntax in Athena is different for Iceberg Tables and Hive-style tables.
  
  The parsed statement should look like this:
  
  ```sql
  CREATE TABLE IF NOT EXISTS tmp.mytable 
      (name STRING) 
  LOCATION 's3://bucket/tmp/mytable/' 
  TBLPROPERTIES (
      'table_type'='iceberg', 
      'FORMAT'='parquet'
  )
  ```
  
  Instead of WITH -> TBLPROPERTIES
  The keys in the this block are wrapped in upper quotes and iceberg has slightly different data types. In this case STRING instead of TEXT
  
  https://docs.aws.amazon.com/athena/latest/ug/querying-iceberg-supported-data-types.html
  https://docs.aws.amazon.com/athena/latest/ug/querying-iceberg-creating-tables.html
  
  
  
  </issue>
  <code>
  [start of sqlglot/dialects/athena.py]
  1 from __future__ import annotations
  2 
  3 from sqlglot.dialects.trino import Trino
  4 from sqlglot.tokens import TokenType
  5 
  6 
  7 class Athena(Trino):
  8     class Parser(Trino.Parser):
  9         STATEMENT_PARSERS = {
  10             **Trino.Parser.STATEMENT_PARSERS,
  11             TokenType.USING: lambda self: self._parse_as_command(self._prev),
  12         }
  13
  [end of sqlglot/dialects/athena.py]
  </code>
  
  I need you to solve this issue by generating a single patch file that I can apply directly to this repository using git apply. Please respond with a single patch file in the following format.
  <patch>
  diff --git a/file.py b/file.py
  --- a/file.py
  +++ b/file.py
  @@ -1,27 +1,35 @@
   def euclidean(a, b):
  -    while b:
  -        a, b = b, a % b
  -    return a
  +    if b == 0:
  +        return a
  +    return euclidean(b, a % b)
   
   
   def bresenham(x0, y0, x1, y1):
       points = []
       dx = abs(x1 - x0)
       dy = abs(y1 - y0)
  -    sx = 1 if x0 < x1 else -1
  -    sy = 1 if y0 < y1 else -1
  -    err = dx - dy
  +    x, y = x0, y0
  +    sx = -1 if x0 > x1 else 1
  +    sy = -1 if y0 > y1 else 1
   
  -    while True:
  -        points.append((x0, y0))
  -        if x0 == x1 and y0 == y1:
  -            break
  -        e2 = 2 * err
  -        if e2 > -dy:
  -            err -= dy
  -            x0 += sx
  -        if e2 < dx:
  -            err += dx
  -            y0 += sy
  +    if dx > dy:
  +        err = dx / 2.0
  +        while x != x1:
  +            points.append((x, y))
  +            err -= dy
  +            if err < 0:
  +                y += sy
  +                err += dx
  +            x += sx
  +    else:
  +        err = dy / 2.0
  +        while y != y1:
  +            points.append((x, y))
  +            err -= dx
  +            if err < 0:
  +                x += sx
  +                err += dy
  +            y += sy
  +
  +    points.append((x, y))
       return points
  
  </patch>
golden_diff: diff --git a/sqlglot/dialects/athena.py b/sqlglot/dialects/athena.py
  --- a/sqlglot/dialects/athena.py
  +++ b/sqlglot/dialects/athena.py
  @@ -1,5 +1,6 @@
   from __future__ import annotations
   
  +from sqlglot import exp
   from sqlglot.dialects.trino import Trino
   from sqlglot.tokens import TokenType
   
  @@ -10,3 +11,27 @@
               **Trino.Parser.STATEMENT_PARSERS,
               TokenType.USING: lambda self: self._parse_as_command(self._prev),
           }
  +
  +    class Generator(Trino.Generator):
  +        PROPERTIES_LOCATION = {
  +            **Trino.Generator.PROPERTIES_LOCATION,
  +            exp.LocationProperty: exp.Properties.Location.POST_SCHEMA,
  +        }
  +
  +        TYPE_MAPPING = {
  +            **Trino.Generator.TYPE_MAPPING,
  +            exp.DataType.Type.TEXT: "STRING",
  +        }
  +
  +        TRANSFORMS = {
  +            **Trino.Generator.TRANSFORMS,
  +            exp.FileFormatProperty: lambda self, e: f"'FORMAT'={self.sql(e, 'this')}",
  +        }
  +
  +        def property_sql(self, expression: exp.Property) -> str:
  +            return (
  +                f"{self.property_name(expression, string_key=True)}={self.sql(expression, 'value')}"
  +            )
  +
  +        def with_properties(self, properties: exp.Properties) -> str:
  +            return self.properties(properties, prefix=self.seg("TBLPROPERTIES"))
  
verification_info: {"golden_diff": "diff --git a/sqlglot/dialects/athena.py b/sqlglot/dialects/athena.py\n--- a/sqlglot/dialects/athena.py\n+++ b/sqlglot/dialects/athena.py\n@@ -1,5 +1,6 @@\n from __future__ import annotations\n \n+from sqlglot import exp\n from sqlglot.dialects.trino import Trino\n from sqlglot.tokens import TokenType\n \n@@ -10,3 +11,27 @@\n             **Trino.Parser.STATEMENT_PARSERS,\n             TokenType.USING: lambda self: self._parse_as_command(self._prev),\n         }\n+\n+    class Generator(Trino.Generator):\n+        PROPERTIES_LOCATION = {\n+            **Trino.Generator.PROPERTIES_LOCATION,\n+            exp.LocationProperty: exp.Properties.Location.POST_SCHEMA,\n+        }\n+\n+        TYPE_MAPPING = {\n+            **Trino.Generator.TYPE_MAPPING,\n+            exp.DataType.Type.TEXT: \"STRING\",\n+        }\n+\n+        TRANSFORMS = {\n+            **Trino.Generator.TRANSFORMS,\n+            exp.FileFormatProperty: lambda self, e: f\"'FORMAT'={self.sql(e, 'this')}\",\n+        }\n+\n+        def property_sql(self, expression: exp.Property) -> str:\n+            return (\n+                f\"{self.property_name(expression, string_key=True)}={self.sql(expression, 'value')}\"\n+            )\n+\n+        def with_properties(self, properties: exp.Properties) -> str:\n+            return self.properties(properties, prefix=self.seg(\"TBLPROPERTIES\"))\n", "issue": "Athena Iceberg Tables parsing issue\nHi,\r\nI want to parse a SQL Statement that creates an Iceberg table on Athena:\r\n\r\n```sql\r\ncreate table if not exists tmp.mytable (\r\n    name string\r\n)\r\nlocation 's3://bucket/tmp/mytable/'\r\ntblproperties (\r\n  'table_type'='iceberg',\r\n  'format'='parquet'\r\n);\r\n```\r\nrunning \r\n```python\r\nstmts = sqlglot.parse(sql, read=sqlglot.Dialects.ATHENA)\r\nstmts[0].sql()\r\n```\r\nreturns:\r\n```sql\r\nCREATE TABLE IF NOT EXISTS tmp.mytable \r\n    (name TEXT) \r\nLOCATION 's3://bucket/tmp/mytable/' \r\nWITH (\r\n    table_type='iceberg', \r\n    FORMAT='parquet'\r\n)\r\n```\r\n\r\nUnfortunately, the syntax in Athena is different for Iceberg Tables and Hive-style tables.\r\n\r\nThe parsed statement should look like this:\r\n\r\n```sql\r\nCREATE TABLE IF NOT EXISTS tmp.mytable \r\n    (name STRING) \r\nLOCATION 's3://bucket/tmp/mytable/' \r\nTBLPROPERTIES (\r\n    'table_type'='iceberg', \r\n    'FORMAT'='parquet'\r\n)\r\n```\r\n\r\nInstead of WITH -> TBLPROPERTIES\r\nThe keys in the this block are wrapped in upper quotes and iceberg has slightly different data types. In this case STRING instead of TEXT\r\n\r\nhttps://docs.aws.amazon.com/athena/latest/ug/querying-iceberg-supported-data-types.html\r\nhttps://docs.aws.amazon.com/athena/latest/ug/querying-iceberg-creating-tables.html\r\n\r\n\n", "before_files": [{"content": "from __future__ import annotations\n\nfrom sqlglot.dialects.trino import Trino\nfrom sqlglot.tokens import TokenType\n\n\nclass Athena(Trino):\n    class Parser(Trino.Parser):\n        STATEMENT_PARSERS = {\n            **Trino.Parser.STATEMENT_PARSERS,\n            TokenType.USING: lambda self: self._parse_as_command(self._prev),\n        }\n", "path": "sqlglot/dialects/athena.py"}]}