We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
owsql: Wrong auto-discovered DiscreteVariable values
##### Orange version
3.14.0 dev

##### Expected behavior
SQL Table correctly discovers categorical variables.

##### Actual behavior
`DiscreteVariable` values for char fields have additional with space on the end.

##### Steps to reproduce the behavior
SQL for Postgres:

``` sql
CREATE TABLE COMPANY(                                                                                                
   ID INT PRIMARY KEY     NOT NULL,
   ADDRESS        CHAR(50)
);
INSERT INTO COMPANY (ID,ADDRESS) VALUES (1, 'California');
```
In SQL Table select tabel company

##### Additional info (worksheets, data, screenshots, ...)
This issue is because on data query `::text` is used that removes the additional white space.

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `Orange/data/sql/backend/postgres.py`
Content:
```
1 import logging
2 import re
3 import warnings
4 from contextlib import contextmanager
5 from time import time
6 
7 from psycopg2 import Error, OperationalError
8 from psycopg2.pool import ThreadedConnectionPool
9 
10 from Orange.data import ContinuousVariable, DiscreteVariable, StringVariable, TimeVariable
11 from Orange.data.sql.backend.base import Backend, ToSql, BackendError
12 
13 log = logging.getLogger(__name__)
14 
15 EXTENSIONS = ('tsm_system_time', 'quantile')
16 
17 
18 class Psycopg2Backend(Backend):
19     """Backend for accessing data stored in a Postgres database
20     """
21 
22     display_name = "PostgreSQL"
23     connection_pool = None
24     auto_create_extensions = True
25 
26     def __init__(self, connection_params):
27         super().__init__(connection_params)
28 
29         if self.connection_pool is None:
30             self._create_connection_pool()
31 
32         if self.auto_create_extensions:
33             self._create_extensions()
34 
35     def _create_connection_pool(self):
36         try:
37             self.connection_pool = ThreadedConnectionPool(
38                 1, 16, **self.connection_params)
39         except Error as ex:
40             raise BackendError(str(ex)) from ex
41 
42     def _create_extensions(self):
43         for ext in EXTENSIONS:
44             try:
45                 query = "CREATE EXTENSION IF NOT EXISTS {}".format(ext)
46                 with self.execute_sql_query(query):
47                     pass
48             except OperationalError:
49                 warnings.warn("Database is missing extension {}".format(ext))
50 
51     def create_sql_query(self, table_name, fields, filters=(),
52                          group_by=None, order_by=None,
53                          offset=None, limit=None,
54                          use_time_sample=None):
55         sql = ["SELECT", ', '.join(fields),
56                "FROM", table_name]
57         if use_time_sample is not None:
58             sql.append("TABLESAMPLE system_time(%i)" % use_time_sample)
59         if filters:
60             sql.extend(["WHERE", " AND ".join(filters)])
61         if group_by is not None:
62             sql.extend(["GROUP BY", ", ".join(group_by)])
63         if order_by is not None:
64             sql.extend(["ORDER BY", ",".join(order_by)])
65         if offset is not None:
66             sql.extend(["OFFSET", str(offset)])
67         if limit is not None:
68             sql.extend(["LIMIT", str(limit)])
69         return " ".join(sql)
70 
71     @contextmanager
72     def execute_sql_query(self, query, params=None):
73         connection = self.connection_pool.getconn()
74         cur = connection.cursor()
75         try:
76             utfquery = cur.mogrify(query, params).decode('utf-8')
77             log.debug("Executing: %s", utfquery)
78             t = time()
79             cur.execute(query, params)
80             yield cur
81             log.info("%.2f ms: %s", 1000 * (time() - t), utfquery)
82         except Error as ex:
83             raise BackendError(str(ex)) from ex
84         finally:
85             connection.commit()
86             self.connection_pool.putconn(connection)
87 
88     def quote_identifier(self, name):
89         return '"%s"' % name
90 
91     def unquote_identifier(self, quoted_name):
92         if quoted_name.startswith('"'):
93             return quoted_name[1:len(quoted_name) - 1]
94         else:
95             return quoted_name
96 
97     def list_tables_query(self, schema=None):
98         if schema:
99             schema_clause = "AND n.nspname = '{}'".format(schema)
100         else:
101             schema_clause = "AND pg_catalog.pg_table_is_visible(c.oid)"
102         return """SELECT n.nspname as "Schema",
103                           c.relname AS "Name"
104                        FROM pg_catalog.pg_class c
105                   LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
106                       WHERE c.relkind IN ('r','v','m','S','f','')
107                         AND n.nspname <> 'pg_catalog'
108                         AND n.nspname <> 'information_schema'
109                         AND n.nspname !~ '^pg_toast'
110                         {}
111                         AND NOT c.relname LIKE '\\_\\_%'
112                    ORDER BY 1;""".format(schema_clause)
113 
114     def create_variable(self, field_name, field_metadata,
115                         type_hints, inspect_table=None):
116         if field_name in type_hints:
117             var = type_hints[field_name]
118         else:
119             var = self._guess_variable(field_name, field_metadata,
120                                        inspect_table)
121 
122         field_name_q = self.quote_identifier(field_name)
123         if var.is_continuous:
124             if isinstance(var, TimeVariable):
125                 var.to_sql = ToSql("extract(epoch from {})"
126                                    .format(field_name_q))
127             else:
128                 var.to_sql = ToSql("({})::double precision"
129                                    .format(field_name_q))
130         else:  # discrete or string
131             var.to_sql = ToSql("({})::text"
132                                .format(field_name_q))
133         return var
134 
135     def _guess_variable(self, field_name, field_metadata, inspect_table):
136         type_code = field_metadata[0]
137 
138         FLOATISH_TYPES = (700, 701, 1700)  # real, float8, numeric
139         INT_TYPES = (20, 21, 23)  # bigint, int, smallint
140         CHAR_TYPES = (25, 1042, 1043,)  # text, char, varchar
141         BOOLEAN_TYPES = (16,)  # bool
142         DATE_TYPES = (1082, 1114, 1184, )  # date, timestamp, timestamptz
143         # time, timestamp, timestamptz, timetz
144         TIME_TYPES = (1083, 1114, 1184, 1266,)
145 
146         if type_code in FLOATISH_TYPES:
147             return ContinuousVariable.make(field_name)
148 
149         if type_code in TIME_TYPES + DATE_TYPES:
150             tv = TimeVariable.make(field_name)
151             tv.have_date |= type_code in DATE_TYPES
152             tv.have_time |= type_code in TIME_TYPES
153             return tv
154 
155         if type_code in INT_TYPES:  # bigint, int, smallint
156             if inspect_table:
157                 values = self.get_distinct_values(field_name, inspect_table)
158                 if values:
159                     return DiscreteVariable.make(field_name, values)
160             return ContinuousVariable.make(field_name)
161 
162         if type_code in BOOLEAN_TYPES:
163             return DiscreteVariable.make(field_name, ['false', 'true'])
164 
165         if type_code in CHAR_TYPES:
166             if inspect_table:
167                 values = self.get_distinct_values(field_name, inspect_table)
168                 if values:
169                     return DiscreteVariable.make(field_name, values)
170 
171         return StringVariable.make(field_name)
172 
173     def count_approx(self, query):
174         sql = "EXPLAIN " + query
175         with self.execute_sql_query(sql) as cur:
176             s = ''.join(row[0] for row in cur.fetchall())
177         return int(re.findall(r'rows=(\d*)', s)[0])
178 
179     def __getstate__(self):
180         # Drop connection_pool from state as it cannot be pickled
181         state = dict(self.__dict__)
182         state.pop('connection_pool', None)
183         return state
184 
185     def __setstate__(self, state):
186         # Create a new connection pool if none exists
187         self.__dict__.update(state)
188         if self.connection_pool is None:
189             self._create_connection_pool()
190
```
--- 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/Orange/data/sql/backend/postgres.py b/Orange/data/sql/backend/postgres.py
--- a/Orange/data/sql/backend/postgres.py
+++ b/Orange/data/sql/backend/postgres.py
@@ -165,6 +165,8 @@
         if type_code in CHAR_TYPES:
             if inspect_table:
                 values = self.get_distinct_values(field_name, inspect_table)
+                # remove trailing spaces
+                values = [v.rstrip() for v in values]
                 if values:
                     return DiscreteVariable.make(field_name, values)

{"golden_diff": "diff --git a/Orange/data/sql/backend/postgres.py b/Orange/data/sql/backend/postgres.py\n--- a/Orange/data/sql/backend/postgres.py\n+++ b/Orange/data/sql/backend/postgres.py\n@@ -165,6 +165,8 @@\n         if type_code in CHAR_TYPES:\n             if inspect_table:\n                 values = self.get_distinct_values(field_name, inspect_table)\n+                # remove trailing spaces\n+                values = [v.rstrip() for v in values]\n                 if values:\n                     return DiscreteVariable.make(field_name, values)\n", "issue": "owsql: Wrong auto-discovered DiscreteVariable values\n##### Orange version\r\n3.14.0 dev\r\n\r\n##### Expected behavior\r\nSQL Table correctly discovers categorical variables.\r\n\r\n##### Actual behavior\r\n`DiscreteVariable` values for char fields have additional with space on the end.\r\n\r\n##### Steps to reproduce the behavior\r\nSQL for Postgres:\r\n\r\n``` sql\r\nCREATE TABLE COMPANY(                                                                                                \r\n   ID INT PRIMARY KEY     NOT NULL,\r\n   ADDRESS        CHAR(50)\r\n);\r\nINSERT INTO COMPANY (ID,ADDRESS) VALUES (1, 'California');\r\n```\r\nIn SQL Table select tabel company\r\n\r\n##### Additional info (worksheets, data, screenshots, ...)\r\nThis issue is because on data query `::text` is used that removes the additional white space.\n", "before_files": [{"content": "import logging\nimport re\nimport warnings\nfrom contextlib import contextmanager\nfrom time import time\n\nfrom psycopg2 import Error, OperationalError\nfrom psycopg2.pool import ThreadedConnectionPool\n\nfrom Orange.data import ContinuousVariable, DiscreteVariable, StringVariable, TimeVariable\nfrom Orange.data.sql.backend.base import Backend, ToSql, BackendError\n\nlog = logging.getLogger(__name__)\n\nEXTENSIONS = ('tsm_system_time', 'quantile')\n\n\nclass Psycopg2Backend(Backend):\n    \"\"\"Backend for accessing data stored in a Postgres database\n    \"\"\"\n\n    display_name = \"PostgreSQL\"\n    connection_pool = None\n    auto_create_extensions = True\n\n    def __init__(self, connection_params):\n        super().__init__(connection_params)\n\n        if self.connection_pool is None:\n            self._create_connection_pool()\n\n        if self.auto_create_extensions:\n            self._create_extensions()\n\n    def _create_connection_pool(self):\n        try:\n            self.connection_pool = ThreadedConnectionPool(\n                1, 16, **self.connection_params)\n        except Error as ex:\n            raise BackendError(str(ex)) from ex\n\n    def _create_extensions(self):\n        for ext in EXTENSIONS:\n            try:\n                query = \"CREATE EXTENSION IF NOT EXISTS {}\".format(ext)\n                with self.execute_sql_query(query):\n                    pass\n            except OperationalError:\n                warnings.warn(\"Database is missing extension {}\".format(ext))\n\n    def create_sql_query(self, table_name, fields, filters=(),\n                         group_by=None, order_by=None,\n                         offset=None, limit=None,\n                         use_time_sample=None):\n        sql = [\"SELECT\", ', '.join(fields),\n               \"FROM\", table_name]\n        if use_time_sample is not None:\n            sql.append(\"TABLESAMPLE system_time(%i)\" % use_time_sample)\n        if filters:\n            sql.extend([\"WHERE\", \" AND \".join(filters)])\n        if group_by is not None:\n            sql.extend([\"GROUP BY\", \", \".join(group_by)])\n        if order_by is not None:\n            sql.extend([\"ORDER BY\", \",\".join(order_by)])\n        if offset is not None:\n            sql.extend([\"OFFSET\", str(offset)])\n        if limit is not None:\n            sql.extend([\"LIMIT\", str(limit)])\n        return \" \".join(sql)\n\n    @contextmanager\n    def execute_sql_query(self, query, params=None):\n        connection = self.connection_pool.getconn()\n        cur = connection.cursor()\n        try:\n            utfquery = cur.mogrify(query, params).decode('utf-8')\n            log.debug(\"Executing: %s\", utfquery)\n            t = time()\n            cur.execute(query, params)\n            yield cur\n            log.info(\"%.2f ms: %s\", 1000 * (time() - t), utfquery)\n        except Error as ex:\n            raise BackendError(str(ex)) from ex\n        finally:\n            connection.commit()\n            self.connection_pool.putconn(connection)\n\n    def quote_identifier(self, name):\n        return '\"%s\"' % name\n\n    def unquote_identifier(self, quoted_name):\n        if quoted_name.startswith('\"'):\n            return quoted_name[1:len(quoted_name) - 1]\n        else:\n            return quoted_name\n\n    def list_tables_query(self, schema=None):\n        if schema:\n            schema_clause = \"AND n.nspname = '{}'\".format(schema)\n        else:\n            schema_clause = \"AND pg_catalog.pg_table_is_visible(c.oid)\"\n        return \"\"\"SELECT n.nspname as \"Schema\",\n                          c.relname AS \"Name\"\n                       FROM pg_catalog.pg_class c\n                  LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n                      WHERE c.relkind IN ('r','v','m','S','f','')\n                        AND n.nspname <> 'pg_catalog'\n                        AND n.nspname <> 'information_schema'\n                        AND n.nspname !~ '^pg_toast'\n                        {}\n                        AND NOT c.relname LIKE '\\\\_\\\\_%'\n                   ORDER BY 1;\"\"\".format(schema_clause)\n\n    def create_variable(self, field_name, field_metadata,\n                        type_hints, inspect_table=None):\n        if field_name in type_hints:\n            var = type_hints[field_name]\n        else:\n            var = self._guess_variable(field_name, field_metadata,\n                                       inspect_table)\n\n        field_name_q = self.quote_identifier(field_name)\n        if var.is_continuous:\n            if isinstance(var, TimeVariable):\n                var.to_sql = ToSql(\"extract(epoch from {})\"\n                                   .format(field_name_q))\n            else:\n                var.to_sql = ToSql(\"({})::double precision\"\n                                   .format(field_name_q))\n        else:  # discrete or string\n            var.to_sql = ToSql(\"({})::text\"\n                               .format(field_name_q))\n        return var\n\n    def _guess_variable(self, field_name, field_metadata, inspect_table):\n        type_code = field_metadata[0]\n\n        FLOATISH_TYPES = (700, 701, 1700)  # real, float8, numeric\n        INT_TYPES = (20, 21, 23)  # bigint, int, smallint\n        CHAR_TYPES = (25, 1042, 1043,)  # text, char, varchar\n        BOOLEAN_TYPES = (16,)  # bool\n        DATE_TYPES = (1082, 1114, 1184, )  # date, timestamp, timestamptz\n        # time, timestamp, timestamptz, timetz\n        TIME_TYPES = (1083, 1114, 1184, 1266,)\n\n        if type_code in FLOATISH_TYPES:\n            return ContinuousVariable.make(field_name)\n\n        if type_code in TIME_TYPES + DATE_TYPES:\n            tv = TimeVariable.make(field_name)\n            tv.have_date |= type_code in DATE_TYPES\n            tv.have_time |= type_code in TIME_TYPES\n            return tv\n\n        if type_code in INT_TYPES:  # bigint, int, smallint\n            if inspect_table:\n                values = self.get_distinct_values(field_name, inspect_table)\n                if values:\n                    return DiscreteVariable.make(field_name, values)\n            return ContinuousVariable.make(field_name)\n\n        if type_code in BOOLEAN_TYPES:\n            return DiscreteVariable.make(field_name, ['false', 'true'])\n\n        if type_code in CHAR_TYPES:\n            if inspect_table:\n                values = self.get_distinct_values(field_name, inspect_table)\n                if values:\n                    return DiscreteVariable.make(field_name, values)\n\n        return StringVariable.make(field_name)\n\n    def count_approx(self, query):\n        sql = \"EXPLAIN \" + query\n        with self.execute_sql_query(sql) as cur:\n            s = ''.join(row[0] for row in cur.fetchall())\n        return int(re.findall(r'rows=(\\d*)', s)[0])\n\n    def __getstate__(self):\n        # Drop connection_pool from state as it cannot be pickled\n        state = dict(self.__dict__)\n        state.pop('connection_pool', None)\n        return state\n\n    def __setstate__(self, state):\n        # Create a new connection pool if none exists\n        self.__dict__.update(state)\n        if self.connection_pool is None:\n            self._create_connection_pool()\n", "path": "Orange/data/sql/backend/postgres.py"}], "after_files": [{"content": "import logging\nimport re\nimport warnings\nfrom contextlib import contextmanager\nfrom time import time\n\nfrom psycopg2 import Error, OperationalError\nfrom psycopg2.pool import ThreadedConnectionPool\n\nfrom Orange.data import ContinuousVariable, DiscreteVariable, StringVariable, TimeVariable\nfrom Orange.data.sql.backend.base import Backend, ToSql, BackendError\n\nlog = logging.getLogger(__name__)\n\nEXTENSIONS = ('tsm_system_time', 'quantile')\n\n\nclass Psycopg2Backend(Backend):\n    \"\"\"Backend for accessing data stored in a Postgres database\n    \"\"\"\n\n    display_name = \"PostgreSQL\"\n    connection_pool = None\n    auto_create_extensions = True\n\n    def __init__(self, connection_params):\n        super().__init__(connection_params)\n\n        if self.connection_pool is None:\n            self._create_connection_pool()\n\n        if self.auto_create_extensions:\n            self._create_extensions()\n\n    def _create_connection_pool(self):\n        try:\n            self.connection_pool = ThreadedConnectionPool(\n                1, 16, **self.connection_params)\n        except Error as ex:\n            raise BackendError(str(ex)) from ex\n\n    def _create_extensions(self):\n        for ext in EXTENSIONS:\n            try:\n                query = \"CREATE EXTENSION IF NOT EXISTS {}\".format(ext)\n                with self.execute_sql_query(query):\n                    pass\n            except OperationalError:\n                warnings.warn(\"Database is missing extension {}\".format(ext))\n\n    def create_sql_query(self, table_name, fields, filters=(),\n                         group_by=None, order_by=None,\n                         offset=None, limit=None,\n                         use_time_sample=None):\n        sql = [\"SELECT\", ', '.join(fields),\n               \"FROM\", table_name]\n        if use_time_sample is not None:\n            sql.append(\"TABLESAMPLE system_time(%i)\" % use_time_sample)\n        if filters:\n            sql.extend([\"WHERE\", \" AND \".join(filters)])\n        if group_by is not None:\n            sql.extend([\"GROUP BY\", \", \".join(group_by)])\n        if order_by is not None:\n            sql.extend([\"ORDER BY\", \",\".join(order_by)])\n        if offset is not None:\n            sql.extend([\"OFFSET\", str(offset)])\n        if limit is not None:\n            sql.extend([\"LIMIT\", str(limit)])\n        return \" \".join(sql)\n\n    @contextmanager\n    def execute_sql_query(self, query, params=None):\n        connection = self.connection_pool.getconn()\n        cur = connection.cursor()\n        try:\n            utfquery = cur.mogrify(query, params).decode('utf-8')\n            log.debug(\"Executing: %s\", utfquery)\n            t = time()\n            cur.execute(query, params)\n            yield cur\n            log.info(\"%.2f ms: %s\", 1000 * (time() - t), utfquery)\n        except Error as ex:\n            raise BackendError(str(ex)) from ex\n        finally:\n            connection.commit()\n            self.connection_pool.putconn(connection)\n\n    def quote_identifier(self, name):\n        return '\"%s\"' % name\n\n    def unquote_identifier(self, quoted_name):\n        if quoted_name.startswith('\"'):\n            return quoted_name[1:len(quoted_name) - 1]\n        else:\n            return quoted_name\n\n    def list_tables_query(self, schema=None):\n        if schema:\n            schema_clause = \"AND n.nspname = '{}'\".format(schema)\n        else:\n            schema_clause = \"AND pg_catalog.pg_table_is_visible(c.oid)\"\n        return \"\"\"SELECT n.nspname as \"Schema\",\n                          c.relname AS \"Name\"\n                       FROM pg_catalog.pg_class c\n                  LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n                      WHERE c.relkind IN ('r','v','m','S','f','')\n                        AND n.nspname <> 'pg_catalog'\n                        AND n.nspname <> 'information_schema'\n                        AND n.nspname !~ '^pg_toast'\n                        {}\n                        AND NOT c.relname LIKE '\\\\_\\\\_%'\n                   ORDER BY 1;\"\"\".format(schema_clause)\n\n    def create_variable(self, field_name, field_metadata,\n                        type_hints, inspect_table=None):\n        if field_name in type_hints:\n            var = type_hints[field_name]\n        else:\n            var = self._guess_variable(field_name, field_metadata,\n                                       inspect_table)\n\n        field_name_q = self.quote_identifier(field_name)\n        if var.is_continuous:\n            if isinstance(var, TimeVariable):\n                var.to_sql = ToSql(\"extract(epoch from {})\"\n                                   .format(field_name_q))\n            else:\n                var.to_sql = ToSql(\"({})::double precision\"\n                                   .format(field_name_q))\n        else:  # discrete or string\n            var.to_sql = ToSql(\"({})::text\"\n                               .format(field_name_q))\n        return var\n\n    def _guess_variable(self, field_name, field_metadata, inspect_table):\n        type_code = field_metadata[0]\n\n        FLOATISH_TYPES = (700, 701, 1700)  # real, float8, numeric\n        INT_TYPES = (20, 21, 23)  # bigint, int, smallint\n        CHAR_TYPES = (25, 1042, 1043,)  # text, char, varchar\n        BOOLEAN_TYPES = (16,)  # bool\n        DATE_TYPES = (1082, 1114, 1184, )  # date, timestamp, timestamptz\n        # time, timestamp, timestamptz, timetz\n        TIME_TYPES = (1083, 1114, 1184, 1266,)\n\n        if type_code in FLOATISH_TYPES:\n            return ContinuousVariable.make(field_name)\n\n        if type_code in TIME_TYPES + DATE_TYPES:\n            tv = TimeVariable.make(field_name)\n            tv.have_date |= type_code in DATE_TYPES\n            tv.have_time |= type_code in TIME_TYPES\n            return tv\n\n        if type_code in INT_TYPES:  # bigint, int, smallint\n            if inspect_table:\n                values = self.get_distinct_values(field_name, inspect_table)\n                if values:\n                    return DiscreteVariable.make(field_name, values)\n            return ContinuousVariable.make(field_name)\n\n        if type_code in BOOLEAN_TYPES:\n            return DiscreteVariable.make(field_name, ['false', 'true'])\n\n        if type_code in CHAR_TYPES:\n            if inspect_table:\n                values = self.get_distinct_values(field_name, inspect_table)\n                # remove trailing spaces\n                values = [v.rstrip() for v in values]\n                if values:\n                    return DiscreteVariable.make(field_name, values)\n\n        return StringVariable.make(field_name)\n\n    def count_approx(self, query):\n        sql = \"EXPLAIN \" + query\n        with self.execute_sql_query(sql) as cur:\n            s = ''.join(row[0] for row in cur.fetchall())\n        return int(re.findall(r'rows=(\\d*)', s)[0])\n\n    def __getstate__(self):\n        # Drop connection_pool from state as it cannot be pickled\n        state = dict(self.__dict__)\n        state.pop('connection_pool', None)\n        return state\n\n    def __setstate__(self, state):\n        # Create a new connection pool if none exists\n        self.__dict__.update(state)\n        if self.connection_pool is None:\n            self._create_connection_pool()\n", "path": "Orange/data/sql/backend/postgres.py"}]}