Merge branch 'main' of github.com:grongierisc/django-iris

Author: grongierisc

.github/workflows/python-publish.yml

@@ -20,13 +20,13 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - run: git fetch --depth=1 origin +refs/tags/*:refs/tags/*
       if: github.event_name == 'push'
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v3
       with:
-        python-version: '3.x'
+        python-version: '3.10'
     - name: Install dependencies
       id: set-version
       run: |
@@ -35,38 +35,27 @@ jobs:
         [ $GITHUB_EVENT_NAME == 'push' ] && VERSION+=b && VERSION+=$(($(git tag -l "*$VERSION*" | cut -db -f2 | sort -n | tail -1)+1)) 
         sed -ie "s/version = .*/version = $VERSION/" setup.cfg
         python -m pip install --upgrade pip
-        pip install build
-        echo ::set-output name=version::$VERSION
+        pip install -U pip setuptools
+        pip install -r requirements-dev.txt
+        pip install -r requirements.txt
+        echo version=$VERSION >> $GITHUB_OUTPUT
         NAME="django_iris"-${VERSION}-py3-none-any
-        echo ::set-output name=name::$NAME
+        echo name=$NAME >> $GITHUB_OUTPUT
     - name: Build package
-      run: python -m build
+      run: ./scripts/build-dist.sh
     - name: Publish package
-      uses: pypa/gh-action-pypi-publish@release/v1.5
+      uses: pypa/gh-action-pypi-publish@release/v1
       with:
         user: __token__
         password: ${{ secrets.PYPI_API_TOKEN }}
     - name: Create Beta Release
       id: create_release
-      if: github.event_name == 'push'
-      uses: actions/create-release@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      uses: softprops/action-gh-release@v1
       with:
-        tag_name: ${{ steps.set-version.outputs.version }}
-        release_name: ${{ steps.set-version.outputs.version }}
+        tag_name: v${{ steps.set-version.outputs.version }}
         prerelease: ${{ github.event_name != 'release' }}
-    - name: Upload Release Asset
-      id: upload-release-asset
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ github.event_name == 'release' && github.event.release.upload_url || steps.create_release.outputs.upload_url }}
-        asset_path: dist/${{ steps.set-version.outputs.name }}.whl
-        asset_name: ${{ steps.set-version.outputs.name }}.whl
-        asset_content_type: application/zip
-    - uses: actions/checkout@v2
+        files: dist/${{ steps.set-version.outputs.name }}.whl
+    - uses: actions/checkout@v3
       if: github.event_name == 'release'
       with:
         ref: main

django_iris/__init__.py

@@ -1,8 +1,133 @@
-from django.db.models.expressions import Exists
+from django.db.models.functions.math import Random, Ln, Log
+from django.db.models.functions.datetime import Now
+from django.db.models.expressions import Exists, Func, Value, Col, OrderBy
+from django.db.models.functions.text import Chr, ConcatPair, StrIndex
+from django.db.models.fields import TextField, CharField
 
+fn_template = "{fn %(function)s(%(expressions)s)}"
+
+as_fn = [
+    "ACOS",
+    "ASIN",
+    "ATAN",
+    "ATAN2",
+    "COS",
+    "COT",
+    "EXP",
+    "LN",
+    "LOG",
+    "LOG10",
+    "PI",
+    "SIN",
+    "TAN",
+]
+
+def as_intersystems(cls):
+    def inner(func):
+        cls.as_intersystems = func
+    return inner
+
+class Log10(Func):
+    function = "LOG10"
+    arity = 1
+    lookup_name = "log10"
+
+class Convert(Func):
+    function = "CONVERT"
+    lookup_name = "convert"
+
+    template = "%(function)s(%(db_type)s, %(expressions)s)"
+
+    def __init__(self, expression, output_field):
+        super().__init__(expression, output_field=output_field)
+
+    def as_sql(self, compiler, connection, **extra_context):
+        extra_context["db_type"] = self.output_field.cast_db_type(connection)
+        return super().as_sql(compiler, connection, **extra_context)
+
+def convert_streams(expressions):
+    return [
+        Convert(expression, CharField()) if isinstance(expression, Col) and isinstance(expression.target, TextField) else expression
+        for expression in expressions
+    ]
+
+@as_intersystems(Exists)
 def exists_as_intersystems(self, compiler, connection, template=None, **extra_context):
     template = "(SELECT COUNT(*) FROM (%(subquery)s))"
     return self.as_sql(compiler, connection, template, **extra_context)
 
-Exists.as_intersystems = exists_as_intersystems
+@as_intersystems(Chr)
+def chr_as_intersystems(self, compiler, connection, **extra_context):
+    return self.as_sql(compiler, connection, function="CHAR", **extra_context)
+
+@as_intersystems(ConcatPair)
+def concat_as_intersystems(self, compiler, connection, **extra_context):
+    copy = self.copy()
+    expressions = convert_streams(copy.get_source_expressions())
+    """
+    STRING in IRIS retuns NULL if all NULL arguments, so, just add empty string, to make it always non NULL
+    """
+    copy.set_source_expressions([Value("")]+ expressions)
+    return super(ConcatPair, copy).as_sql(
+        compiler,
+        connection,
+        function="STRING",
+        **extra_context,
+    )
+
+@as_intersystems(StrIndex)
+def instr_as_intersystems(self, compiler, connection, **extra_context):
+    copy = self.copy()
+    expressions = convert_streams(copy.get_source_expressions())
+    copy.set_source_expressions(expressions)
+    return super(StrIndex, copy).as_sql(
+        compiler,
+        connection,
+        **extra_context,
+    )
+
+@as_intersystems(Random)
+def random_as_intersystems(self, compiler, connection, **extra_context):
+    return self.as_sql(compiler, connection, template="%%TSQL.ZRAND(1e10)", **extra_context)
+
+@as_intersystems(Ln)
+def ln_as_intersystems(self, compiler, connection, **extra_context):
+    return self.as_sql(compiler, connection, function="LOG", template=fn_template, **extra_context)
+
+
+@as_intersystems(Log)
+def log_as_intersystems(self, compiler, connection, **extra_context):
+    copy = self.copy()
+    copy.set_source_expressions(
+        [
+            Log10(expression)
+            for expression in copy.get_source_expressions()[::-1]
+        ]
+    )
+    return super(Log, copy).as_sql(
+        compiler,
+        connection,
+        arg_joiner=" / ",
+        template="%(expressions)s",
+        **extra_context,
+    )
+
+@as_intersystems(Func)
+def func_as_intersystems(self, compiler, connection, **extra_context):
+    if self.function in as_fn:        
+        return self.as_sql(compiler, connection, template=fn_template, **extra_context)
+    return self.as_sql(compiler, connection, **extra_context)
+
+@as_intersystems(Now)
+def now_as_intersystems(self, compiler, connection, **extra_context):
+    return self.as_sql(
+        compiler, connection, template="CURRENT_TIMESTAMP(6)", **extra_context
+    )
+
+@as_intersystems(OrderBy)
+def orderby_as_intersystems(self, compiler, connection, **extra_context):
+    copy = self.copy()
+    # IRIS does not support order NULL
+    copy.nulls_first =  copy.nulls_last = False
+    return copy.as_sql(compiler, connection, **extra_context)
 

django_iris/base.py

@@ -3,6 +3,8 @@
 from django.db.backends.base.creation import BaseDatabaseCreation
 from django.core.exceptions import ImproperlyConfigured
 from django.utils.asyncio import async_unsafe
+from django.utils.functional import cached_property
+from django.db.utils import DatabaseErrorWrapper
 
 from .introspection import DatabaseIntrospection
 from .features import DatabaseFeatures
@@ -12,21 +14,7 @@
 from .creation import DatabaseCreation
 from .validation import DatabaseValidation
 
-import intersystems_iris as Database
-
-
-Database.Warning = type("StandardError", (object,), {})
-Database.Error = type("StandardError", (object,), {})
-
-Database.InterfaceError = type("Error", (object,), {})
-
-Database.DatabaseError = type("Error", (object,), {})
-Database.DataError = type("DatabaseError", (object,), {})
-Database.OperationalError = type("DatabaseError", (object,), {})
-Database.IntegrityError = type("DatabaseError", (object,), {})
-Database.InternalError = type("DatabaseError", (object,), {})
-Database.ProgrammingError = type("DatabaseError", (object,), {})
-Database.NotSupportedError = type("DatabaseError", (object,), {})
+import intersystems_iris.dbapi._DBAPI as Database
 
 
 def ignore(*args, **kwargs):
@@ -41,8 +29,8 @@ class DatabaseWrapper(BaseDatabaseWrapper):
     display_name = 'InterSystems IRIS'
 
     data_types = {
-        'AutoField': 'INTEGER AUTO_INCREMENT',
-        'BigAutoField': 'BIGINT AUTO_INCREMENT',
+        'AutoField': 'IDENTITY',
+        'BigAutoField': 'IDENTITY',
         'BinaryField': 'LONG BINARY',
         'BooleanField': 'BIT',
         'CharField': 'VARCHAR(%(max_length)s)',
@@ -63,7 +51,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         'PositiveIntegerField': 'INTEGER',
         'PositiveSmallIntegerField': 'SMALLINT',
         'SlugField': 'VARCHAR(%(max_length)s)',
-        'SmallAutoField': 'SMALLINT AUTO_INCREMENT',
+        'SmallAutoField': 'IDENTITY',
         'SmallIntegerField': 'SMALLINT',
         'TextField': 'TEXT',
         'TimeField': 'TIME(6)',
@@ -81,20 +69,31 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         'gte': '>= %s',
         'lt': '< %s',
         'lte': '<= %s',
-        'startswith': "%%%%STARTSWITH %s",
+        'startswith': "LIKE %s ESCAPE '\\'",
         'endswith': "LIKE %s ESCAPE '\\'",
-        'istartswith': "%%%%STARTSWITH %s",
+        'istartswith': "LIKE %s ESCAPE '\\'",
         'iendswith': "LIKE %s ESCAPE '\\'",
+    }
+
+    pattern_esc = r"REPLACE(REPLACE(REPLACE({}, '\', '\\'), '%%', '\%%'), '_', '\_')"
+    pattern_ops = {
+        "contains": "LIKE '%%' || {} || '%%'",
+        "icontains": "LIKE '%%' || UPPER({}) || '%%'",
+        "startswith": "LIKE {} || '%%'",
+        "istartswith": "LIKE UPPER({}) || '%%'",
+        "endswith": "LIKE '%%' || {}",
+        "iendswith": "LIKE '%%' || UPPER({})",
 
     }
+
     Database = Database
 
-    _commit = ignore
-    _rollback = ignore
-    _savepoint = ignore
-    _savepoint_commit = ignore
-    _savepoint_rollback = ignore
-    _set_autocommit = ignore
+    # _commit = ignore
+    # _rollback = ignore
+    # _savepoint = ignore
+    # _savepoint_commit = ignore
+    # _savepoint_rollback = ignore
+    # _set_autocommit = ignore
 
     SchemaEditorClass = DatabaseSchemaEditor
 
@@ -105,6 +104,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
     ops_class = DatabaseOperations
     validation_class = DatabaseValidation
 
+    _disable_constraint_checking = False
 
     def get_connection_params(self):
         settings_dict = self.settings_dict
@@ -134,10 +134,10 @@ def get_connection_params(self):
                 conn_params['hostname'] = settings_dict['HOST']
             if settings_dict['PORT']:
                 conn_params['port'] = settings_dict['PORT']
-            if settings_dict['NAME']:
-                conn_params['namespace'] = settings_dict['NAME']
             if 'NAMESPACE' in settings_dict:
                 conn_params['namespace'] = settings_dict['NAMESPACE']
+            if settings_dict['NAME']:
+                conn_params['namespace'] = settings_dict['NAME']
 
             if (
                 not conn_params['hostname'] or
@@ -158,16 +158,24 @@ def get_connection_params(self):
                 "Please supply the USER and PASSWORD"
             )
 
+        conn_params['application_name'] = 'django'
+        conn_params["autoCommit"] = self.autocommit
         return conn_params
 
+    def init_connection_state(self):
+        pass
+    
     @async_unsafe
     def get_new_connection(self, conn_params):
         return Database.connect(**conn_params)
 
-    def init_connection_state(self):
-        cursor = self.connection.cursor()
-        # cursor.callproc('%SYSTEM_SQL.Util_SetOption', ['SELECTMODE', 1])
-        # cursor.callproc('%SYSTEM.SQL_SetSelectMode', [1])
+    def _close(self):
+        if self.connection is not None:
+            # Automatically rollbacks anyway
+            # self.in_atomic_block = False
+            # self.needs_rollback = False
+            with self.wrap_database_errors:
+                return self.connection.close()
 
     @async_unsafe
     def create_cursor(self, name=None):
@@ -182,3 +190,29 @@ def is_usable(self):
             return False
         else:
             return True
+
+    @cached_property
+    def wrap_database_errors(self):
+        """
+        Context manager and decorator that re-throws backend-specific database
+        exceptions using Django's common wrappers.
+        """
+        return DatabaseErrorWrapper(self)
+
+    def _set_autocommit(self, autocommit):
+        with self.wrap_database_errors:
+            self.connection.setAutoCommit(autocommit)
+
+    def disable_constraint_checking(self):
+        self._disable_constraint_checking = True
+        return True
+
+    def enable_constraint_checking(self):
+        self._disable_constraint_checking = False
+
+    @async_unsafe
+    def savepoint_commit(self, sid):
+        """
+        IRIS does not have `RELEASE SAVEPOINT`
+        so, just ignore it
+        """