computed columns support

Author: daimor

sqlalchemy_iris/base.py

@@ -1,3 +1,4 @@
+import re
 import intersystems_iris.dbapi._DBAPI as dbapi
 from . import information_schema as ischema
 from . import types
@@ -461,6 +462,19 @@ def visit_drop_schema(self, drop, **kw):
     def visit_check_constraint(self, constraint, **kw):
         raise exc.CompileError("Check CONSTRAINT not supported")
 
+    def visit_computed_column(self, generated, **kwargs):
+        text = self.sql_compiler.process(
+            generated.sqltext, include_table=True, literal_binds=True
+        )
+        text = re.sub(r"(?<!')(\b[^\d]\w+\b)", r'{\g<1>}', text)
+        # text = text.replace("'", '"')
+        text = 'COMPUTECODE {Set {*} = %s}' % (text,)
+        if generated.persisted is False:
+            text += ' CALCULATED'
+        else:
+            text += ' COMPUTEONCHANGE ("%%UPDATE")'
+        return text
+
     def get_column_specification(self, column, **kwargs):
 
         colspec = [
@@ -487,6 +501,9 @@ def get_column_specification(self, column, **kwargs):
         if default is not None:
             colspec.append("DEFAULT " + default)
 
+        if column.computed is not None:
+            colspec.append(self.process(column.computed))
+
         if not column.nullable:
             colspec.append("NOT NULL")
 
@@ -583,7 +600,6 @@ class IRISDialect(default.DefaultDialect):
 
     def __init__(self, **kwargs):
         default.DefaultDialect.__init__(self, **kwargs)
-        self._auto_parallel = 1
 
     _isolation_lookup = set(
         [
@@ -920,7 +936,9 @@ def fkey_rec():
 
     def get_columns(self, connection, table_name, schema=None, **kw):
         schema_name = self.get_schema(schema)
+        tables = ischema.tables
         columns = ischema.columns
+        property = ischema.property
 
         whereclause = sql.and_(
             columns.c.table_name == str(table_name),
@@ -938,9 +956,24 @@ def get_columns(self, connection, table_name, schema=None, **kw):
                 columns.c.column_default,
                 columns.c.collation_name,
                 columns.c.auto_increment,
+                property.c.SqlComputeCode,
+                property.c.Calculated,
+                property.c.Transient,
                 # columns.c.description,
             )
             .select_from(columns)
+            .outerjoin(
+                property,
+                sql.and_(
+                    property.c.SqlFieldName == columns.c.column_name,
+                    property.c.parent ==
+                    sql.select(tables.c.classname)
+                    .where(
+                        columns.c.table_name == tables.c.table_name,
+                        columns.c.table_schema == tables.c.table_schema,
+                    ).scalar_subquery()
+                ),
+            )
             .where(whereclause)
             .order_by(columns.c.ordinal_position)
         )
@@ -958,6 +991,9 @@ def get_columns(self, connection, table_name, schema=None, **kw):
             default = row[columns.c.column_default]
             collation = row[columns.c.collation_name]
             autoincrement = row[columns.c.auto_increment]
+            sqlComputeCode = row[property.c.SqlComputeCode]
+            calculated = row[property.c.Calculated]
+            transient = row[property.c.Transient]
             # description = row[columns.c.description]
 
             coltype = self.ischema_names.get(type_, None)
@@ -997,6 +1033,15 @@ def get_columns(self, connection, table_name, schema=None, **kw):
                 "autoincrement": autoincrement,
                 # "comment": description,
             }
+            if sqlComputeCode and 'set {*} = ' in sqlComputeCode.lower():
+                sqltext = sqlComputeCode
+                sqltext = sqltext.split(' = ')[1]
+                sqltext = re.sub(r"{(\b\w+\b)}", r"\g<1>", sqltext)
+                persisted = not calculated and not transient
+                cdict['computed'] = {
+                    "sqltext": sqltext,
+                    "persisted": persisted,
+                }
             cols.append(cdict)
 
         if cols:

sqlalchemy_iris/information_schema.py

@@ -43,6 +43,7 @@ def process_result_value(self, value, dialect):
     Column("TABLE_SCHEMA", String, key="table_schema"),
     Column("TABLE_NAME", String, key="table_name"),
     Column("TABLE_TYPE", String, key="table_type"),
+    Column("CLASSNAME", String, key="classname"),
     schema="INFORMATION_SCHEMA",
 )
 
@@ -56,6 +57,8 @@ def process_result_value(self, value, dialect):
     Column("ORDINAL_POSITION", Integer, key="ordinal_position"),
     Column("COLUMN_DEFAULT", Integer, key="column_default"),
     Column("IS_NULLABLE", YESNO, key="is_nullable"),
+    Column("IS_IDENTITY", YESNO, key="is_identity"),
+    Column("IS_GENERATED", YESNO, key="is_generated"),
     Column("DATA_TYPE", String, key="data_type"),
     Column(
         "CHARACTER_MAXIMUM_LENGTH", Integer, key="character_maximum_length"
@@ -69,6 +72,17 @@ def process_result_value(self, value, dialect):
     Column("DESCIPTION", String, key="desciption"),
     schema="INFORMATION_SCHEMA",
 )
+property = Table(
+    "PropertyDefinition",
+    ischema,
+    Column("parent", String),
+    Column("SqlFieldName", String),
+    Column("SqlComputeCode", String),
+    Column("SqlComputed", Boolean),
+    Column("Calculated", Boolean),
+    Column("Transient", Boolean),
+    schema="%Dictionary",
+)
 
 indexes = Table(
     "INDEXES",

sqlalchemy_iris/requirements.py

@@ -39,3 +39,29 @@ def datetime_historic(self):
 
         return exclusions.open()
 
+    @property
+    def computed_columns(self):
+        "Supports computed columns"
+        return exclusions.open()
+
+    @property
+    def computed_columns_stored(self):
+        "Supports computed columns with `persisted=True`"
+        return exclusions.open()
+
+    @property
+    def computed_columns_virtual(self):
+        "Supports computed columns with `persisted=False`"
+        return exclusions.open()
+
+    @property
+    def computed_columns_default_persisted(self):
+        """If the default persistence is virtual or stored when `persisted`
+        is omitted"""
+        return exclusions.open()
+
+    @property
+    def computed_columns_reflect_persisted(self):
+        """If persistence information is returned by the reflection of
+        computed columns"""
+        return exclusions.open()