django-gbase8s 2.2.0__py3-none-any.whl

django_gbase8s/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.2.0"

django_gbase8s/base.py

@@ -0,0 +1,288 @@
+import decimal
+import copy
+import re
+from collections import Mapping
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+from django.db.backends.base.base import BaseDatabaseWrapper
+from django.db.backends.base.base import NO_DB_ALIAS
+from django.utils.functional import cached_property
+
+try:
+    import gbase8sdb as Database
+    Database.defaults.fetch_decimals = True
+    Database.defaults.fetch_lobs = False
+except ImportError as e:
+    raise ImproperlyConfigured("Error loading gbase8sdb module: %s" % e)
+
+from .client import DatabaseClient
+from .creation import DatabaseCreation
+from .features import DatabaseFeatures
+from .introspection import DatabaseIntrospection
+from .operations import DatabaseOperations
+from .schema import DatabaseSchemaEditor
+from .validation import DatabaseValidation
+from .utils import dsn
+from .utils import GBase8sParam
+
+
+FORMAT_QMARK_REGEX = re.compile(r"(?<!%)%s")
+
+
+
+class CursorWrapper(object):
+    def __init__(self, cursor):
+        self.cursor = cursor
+
+    def _format_params(self, params):
+        if isinstance(params, (list, tuple)):
+            return tuple(GBase8sParam(p) for p in params)
+        elif isinstance(params, dict):
+            return {k: GBase8sParam(v) for k, v in params.items()}
+        else:
+            raise TypeError("params must be tuple or dict")
+
+
+    def _param_generator(self, gbase8sparams):
+        if isinstance(gbase8sparams, (list, tuple)):
+            return tuple(p.param for p in gbase8sparams)
+        elif isinstance(gbase8sparams, dict):
+            return {k: v.param for k, v in gbase8sparams.items()}
+        else:
+            raise TypeError("params must be tuple or dict")
+
+    def _param_inputsize(self, gbase8sparams_list):
+        if hasattr(gbase8sparams_list[0], 'keys'): # [{k: gbase8sparams}, {}...]
+            sizes = {}
+            for params in gbase8sparams_list:
+                for k, value in params.items():
+                    if value.input_size:
+                        sizes[k] = value.input_size
+        else:
+            sizes = [None] * len(gbase8sparams_list[0])
+            for params in gbase8sparams_list:
+                for i, value in enumerate(params):
+                    if value.input_size:
+                        sizes[i] = value.input_size
+            return sizes
+        
+    def _format_sql(self, sql, params):
+        """replace %s to ? on sql,if mapping then replace to :named """
+        if not params:
+            return FORMAT_QMARK_REGEX.sub("?", sql).replace("%%", "%")
+        elif isinstance(params, (tuple, list)):
+            sql = sql % tuple('?' * len(params))
+        elif isinstance(params, Mapping):
+            sql = sql % {name: ":{name}".format(name=name) for name in params}
+        else:
+            raise TypeError("params must be tuple or dict")
+        return sql
+    
+    def execute(self, sql, params=None):
+        
+        if params is None:
+            return self.cursor.execute(sql)
+        sql = self._format_sql(sql, params)
+        gbase8sparams = self._format_params(params)
+        params = self._param_generator(gbase8sparams)
+        input_sizes = self._param_inputsize([gbase8sparams])
+        if isinstance(input_sizes, (list, tuple)):         
+            self.cursor.setinputsizes(*input_sizes)
+        elif isinstance(input_sizes, dict):
+            self.cursor.setinputsizes(**input_sizes)
+        cursor = self.cursor.execute(sql, params)
+        return cursor
+
+
+    def executemany(self, sql, params_list=()):
+        if not params_list:
+            return None
+        params_list = list(params_list)
+        sql = self._format_sql(sql, params_list[0])
+        
+        new_params_list = []
+        gbase8sparams_list = []
+        for params in params_list:            
+            gbase8sparams = self._format_params(params)
+            gbase8sparams_list.append(gbase8sparams)
+            params = self._param_generator(gbase8sparams)
+            new_params_list.append(params)
+        input_sizes = self._param_inputsize(gbase8sparams_list)      
+        if isinstance(input_sizes, (list, tuple)):
+            self.cursor.setinputsizes(*input_sizes)
+        elif isinstance(input_sizes, dict):
+            self.cursor.setinputsizes(**input_sizes)
+        return self.cursor.executemany(sql, new_params_list)
+    
+    @property
+    def lastrowid(self):
+        return self.cursor.lastrowid
+
+    def __getattr__(self, attr):
+        return getattr(self.cursor, attr)
+    
+    def __iter__(self):
+        return iter(self.cursor)
+
+    def close(self):
+        try:
+            self.cursor.close()
+        except Database.InterfaceError:
+            pass
+
+
+
+class DatabaseWrapper(BaseDatabaseWrapper):
+    vendor = 'gbase8s'
+    display_name = 'GBase 8s'
+    Database = Database
+    SchemaEditorClass = DatabaseSchemaEditor
+    client_class = DatabaseClient
+    creation_class = DatabaseCreation
+    features_class = DatabaseFeatures
+    introspection_class = DatabaseIntrospection
+    ops_class = DatabaseOperations
+    isolation_levels = [
+            "DIRTY READ", 
+            "COMMITTED READ LAST COMMITTED", 
+            "COMMITTED READ", 
+            "CURSOR STABILITY",
+            "REPEATABLE READ",             
+            ]
+    _limited_data_types = ("clob", "nclob", "blob")
+    data_types = {
+        'AutoField': 'SERIAL',
+        'SmallAutoField': 'SERIAL',
+        'BigAutoField': 'BIGSERIAL',
+        'BinaryField': 'BLOB',
+        'BooleanField': 'NUMBER(1)',
+        'NullBooleanField': 'NUMBER(1)',
+        'CharField': 'VARCHAR(%(max_length)s)',
+        'CommaSeparatedIntegerField': 'VARCHAR(%(max_length)s)',
+        'DateField': 'TIMESTAMP(0)',
+        'DateTimeField': 'TIMESTAMP',
+        'DecimalField': 'NUMBER(%(max_digits)s, %(decimal_places)s)',
+        'DurationField': 'INTERVAL DAY(9) TO SECOND(5)',
+        'FileField': 'VARCHAR(%(max_length)s)',
+        'FilePathField': 'VARCHAR(%(max_length)s)',
+        'FloatField': 'FLOAT',
+        'IntegerField': 'INTEGER',
+        'BigIntegerField': 'BIGINT',
+        'IPAddressField': 'VARCHAR(15)',
+        'GenericIPAddressField': 'VARCHAR(39)',
+        'OneToOneField': 'INTEGER',
+        'PositiveIntegerField': 'INTEGER',
+        'PositiveSmallIntegerField': 'INTEGER',
+        'SlugField': 'VARCHAR(%(max_length)s)',
+        'SmallIntegerField': 'INTEGER',
+        'TextField': 'NCLOB',
+        'TimeField': 'TIMESTAMP',
+        "URLField": "VARCHAR(%(max_length)s)",
+        'UUIDField': 'VARCHAR(32)',
+    }
+    data_type_check_constraints = {
+        "BooleanField": "%(qn_column)s IN (0,1)",
+        'NullBooleanField': '(%(qn_column)s IN (0,1)) OR (%(qn_column)s IS NULL)',
+        "PositiveIntegerField": "%(qn_column)s >= 0",
+        "PositiveSmallIntegerField": "%(qn_column)s >= 0",
+    }
+    operators = {
+        "exact": "= %s",
+        "iexact": "= UPPER(%s)",
+        "contains": "LIKE %s ESCAPE '\\'",
+        "icontains": "LIKE UPPER(%s) ESCAPE '\\'",
+        "gt": "> %s",
+        "gte": ">= %s",
+        "lt": "< %s",
+        "lte": "<= %s",
+        "startswith": "LIKE %s ESCAPE '\\'",
+        "endswith": "LIKE %s ESCAPE '\\'",
+        "istartswith": "LIKE UPPER(%s) ESCAPE '\\'",
+        "iendswith": "LIKE UPPER(%s) ESCAPE '\\'",
+    }
+    pattern_esc = r"REPLACE(REPLACE(REPLACE({}, '\', '\\'), '%%', '\%%'), '_', '\_')"
+    pattern_ops = {
+        "contains": r"LIKE '%%' || {} || '%%' ESCAPE '\'",
+        "icontains": r"LIKE '%%' || UPPER({}) || '%%' ESCAPE '\'",
+        "startswith": r"LIKE {} || '%%' ESCAPE '\'",
+        "istartswith": r"LIKE UPPER({}) || '%%' ESCAPE '\'",
+        "endswith": r"LIKE '%%' || {} ESCAPE '\'",
+        "iendswith": r"LIKE '%%' || UPPER({}) ESCAPE '\'",
+    }
+    
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.features = DatabaseFeatures(self)
+        self.ops = DatabaseOperations(self)
+        self.client = DatabaseClient(self)
+        self.creation = DatabaseCreation(self)
+        self.introspection = DatabaseIntrospection(self)
+        self.validation = DatabaseValidation(self)
+        self.isolation_level = 'COMMITTED READ LAST COMMITTED'
+    
+    def get_database_version(self):
+        return (8, 8)
+    
+    def get_connection_params(self):
+        conn_params = {
+            "user": self.settings_dict["USER"],
+            "password": self.settings_dict["PASSWORD"],
+            "dsn": dsn(self.settings_dict)            
+        }
+        if 'ISOLATION_LEVEL' in self.settings_dict['OPTIONS']:
+            if self.settings_dict['OPTIONS']['ISOLATION_LEVEL'].upper() in self.isolation_levels:
+                self.isolation_level = self.settings_dict['OPTIONS']['ISOLATION_LEVEL']
+            else:
+                raise ImproperlyConfigured("Invalid isolation level, need {}".format(self.isolation_levels))
+            
+        return conn_params
+    
+    def get_new_connection(self, conn_params):
+        return Database.connect(**conn_params)
+    
+    def init_connection_state(self):
+        if self.isolation_level:
+            with self.cursor() as cursor:
+                cursor.execute("SET ISOLATION TO {}".format(self.isolation_level))
+                
+    def create_cursor(self, name=None):
+        return CursorWrapper(self.connection.cursor())
+    
+    def _set_autocommit(self, autocommit):
+        with self.wrap_database_errors:
+            self.connection.autocommit = autocommit
+            
+    def check_constraints(self, table_names=None):
+        with self.cursor() as cursor:
+            cursor.execute('SET CONSTRAINTS ALL IMMEDIATE')
+            cursor.execute('SET CONSTRAINTS ALL DEFERRED')
+
+    def enable_constraint_checking(self):
+        pass
+
+    def disable_constraint_checking(self):
+        with self.cursor() as cursor:
+            cursor.execute('SET CONSTRAINTS ALL DEFERRED')
+        return True
+    
+    def is_usable(self):
+        try:
+            self.connection.ping()
+        except Database.Error:
+            return False
+        else:
+            return True
+
+    @property
+    def _nodb_connection(self):
+        settings_dict = self.settings_dict.copy()
+        settings_dict['NAME'] = 'sysmaster'
+        nodb_connection = self.__class__(
+            settings_dict,
+            alias=NO_DB_ALIAS,
+            )
+        return nodb_connection
+
+            

django_gbase8s/client.py

@@ -0,0 +1,18 @@
+# coding: utf-8
+import shutil
+from django.db.backends.base.client import BaseDatabaseClient
+
+class DatabaseClient(BaseDatabaseClient):
+    executable_name = "dbaccess"
+    wrapper_name = "rlwrap"
+    
+    @classmethod
+    def settings_to_cmd_args_env(cls, settings_dict, parameters):
+        server_name = settings_dict.get("SERVER_NAME")
+        db_name = settings_dict.get("NAME")
+        args = [cls.executable_name, db_name, '-']
+        wrapper_path = shutil.which(cls.wrapper_name)
+        if wrapper_path:
+            args = [wrapper_path] + args
+        args.extend(parameters)
+        return args, {'GBASEDBTSERVER': server_name}

django_gbase8s/compiler.py

@@ -0,0 +1,275 @@
+import warnings
+from django.db.models.sql import compiler
+from django.db.transaction import TransactionManagementError
+from django.db.utils import DatabaseError, NotSupportedError
+from django.core.exceptions import EmptyResultSet
+from django.db.models.expressions import (
+    Ref,
+    Exists
+)
+from django.utils.deprecation import (
+    RemovedInDjango30Warning, RemovedInDjango31Warning,
+)
+
+def as_gbase8s_for_exists(self, compiler, connection, template=None, **extra_context):
+    sql, params = self.as_sql(compiler, connection, template, **extra_context)
+    sql = 'CASE WHEN {} THEN 1 ELSE 0 END'.format(sql)
+    return sql, params
+
+setattr(Exists, 'as_gbase8s', as_gbase8s_for_exists)
+
+class SQLCompiler(compiler.SQLCompiler):
+
+    def get_group_by(self, select, order_by):
+        """
+        Returns a list of 2-tuples of form (sql, params).
+
+        The logic of what exactly the GROUP BY clause contains is hard
+        to describe in other words than "if it passes the test suite,
+        then it is correct".
+        """
+        
+        if self.query.group_by is None:
+            return []
+        expressions = []
+        group_by_refs = set()
+        if self.query.group_by is not True:
+            for expr in self.query.group_by:
+                if not hasattr(expr, 'as_sql'):
+                    expressions.append(self.query.resolve_ref(expr))
+                if isinstance(expr, Ref):
+                    if expr.refs not in group_by_refs:
+                        group_by_refs.add(expr.name)
+                        expressions.append(expr.source)
+                else:
+                    expressions.append(expr)
+        # Note that even if the group_by is set, it is only the minimal
+        # set to group by. So, we need to add cols in select, order_by, and
+        # having into the select in any case.
+        selected_expr_positions = {}
+        for ordinal, (expr, _, alias) in enumerate(select, start=1):
+            if alias:
+                selected_expr_positions[expr] = ordinal
+            if alias in group_by_refs:
+                continue
+            expressions.extend(expr.get_group_by_cols())
+            # cols = expr.get_group_by_cols()
+            # for col in cols:
+            #     expressions.append(col)
+        for expr, (sql, params, is_ref) in order_by:
+            if expr.contains_aggregate:
+                continue
+            # We can skip References to select clause, as all expressions in
+            # the select clause are already part of the group by.
+            if is_ref:
+                continue
+            expressions.extend(expr.get_source_expressions())
+        having_group_by = self.having.get_group_by_cols() if self.having else ()
+        for expr in having_group_by:
+            expressions.append(expr)
+        result = []
+        seen = set()
+        expressions = self.collapse_group_by(expressions, having_group_by)
+
+        allows_group_by_select_index = (
+            self.connection.features.allows_group_by_select_index
+        )
+
+        for expr in expressions:
+            sql, params = self.compile(expr)
+            if (
+                allows_group_by_select_index
+                and selected_expr_positions.get(expr)
+            ):
+                sql, params = str(selected_expr_positions.get(expr)), ()
+            if (sql, tuple(params)) not in seen:
+                result.append((sql, params))
+                seen.add((sql, tuple(params)))
+        return result
+    def as_sql(self, with_limits=True, with_col_aliases=False):
+        """
+        Creates the SQL for this query. Returns the SQL string and list of
+        parameters.
+
+        If 'with_limits' is False, any limit/offset information is not included
+        in the query.
+        """
+        refcounts_before = self.query.alias_refcount.copy()
+        try:
+            extra_select, order_by, group_by = self.pre_sql_setup()
+            for_update_part = None
+            # Is a LIMIT/OFFSET clause needed?
+            with_limit_offset = with_limits and (self.query.high_mark is not None or self.query.low_mark)
+            combinator = self.query.combinator
+            features = self.connection.features
+            if combinator:
+                if not getattr(features, 'supports_select_{}'.format(combinator)):
+                    raise NotSupportedError('{} is not supported on this database backend.'.format(combinator))
+                result, params = self.get_combinator_sql(combinator, self.query.combinator_all)
+            else:
+                distinct_fields, distinct_params = self.get_distinct()
+                # This must come after 'select', 'ordering', and 'distinct'
+                # (see docstring of get_from_clause() for details).
+                from_, f_params = self.get_from_clause()
+                where, w_params = self.compile(self.where) if self.where is not None else ("", [])
+                having, h_params = self.compile(self.having) if self.having is not None else ("", [])
+                result = ['SELECT']
+                params = []
+
+                if self.query.distinct:
+                    distinct_result, distinct_params = self.connection.ops.distinct_sql(
+                        distinct_fields,
+                        distinct_params,
+                    )
+                    result += distinct_result
+                    params += distinct_params
+
+                out_cols = []
+                col_idx = 1
+                for _, (s_sql, s_params), alias in self.select + extra_select:
+                    if alias:
+                        s_sql = '%s AS %s' % (s_sql, self.connection.ops.quote_name(alias))
+                    elif with_col_aliases:
+                        s_sql = '%s AS %s' % (s_sql, 'Col%d' % col_idx)
+                        col_idx += 1
+                    params.extend(s_params)
+                    out_cols.append(s_sql)
+
+                # result.append(', '.join(out_cols))
+                # result.append('FROM')
+                # result.extend(from_)
+                result += [', '.join(out_cols), 'FROM', *from_]
+                params.extend(f_params)
+
+                if self.query.select_for_update and self.connection.features.has_select_for_update:
+                    if self.connection.get_autocommit():
+                        raise TransactionManagementError('select_for_update cannot be used outside of a transaction.')
+
+                    if with_limit_offset and not self.connection.features.supports_select_for_update_with_limit:
+                        raise NotSupportedError(
+                            'LIMIT/OFFSET is not supported with '
+                            'select_for_update on this database backend.'
+                        )
+                    nowait = self.query.select_for_update_nowait
+                    skip_locked = self.query.select_for_update_skip_locked
+                    of = self.query.select_for_update_of
+                    # If it's a NOWAIT/SKIP LOCKED/OF query but the backend
+                    # doesn't support it, raise NotSupportedError to prevent a
+                    # possible deadlock.
+                    if nowait and not self.connection.features.has_select_for_update_nowait:
+                        raise NotSupportedError('NOWAIT is not supported on this database backend.')
+                    elif skip_locked and not self.connection.features.has_select_for_update_skip_locked:
+                        raise NotSupportedError('SKIP LOCKED is not supported on this database backend.')
+                    elif of and not self.connection.features.has_select_for_update_of:
+                        raise NotSupportedError('FOR UPDATE OF is not supported on this database backend.')
+                    for_update_part = self.connection.ops.for_update_sql(
+                        nowait=nowait, 
+                        skip_locked=skip_locked,
+                        of=self.get_select_for_update_of_arguments(),
+                    )
+
+                if for_update_part and self.connection.features.for_update_after_from:
+                    result.append(for_update_part)
+
+                if where:
+                    result.append('WHERE %s' % where)
+                    params.extend(w_params)
+
+                grouping = []
+                for g_sql, g_params in group_by:
+                    grouping.append(g_sql)
+                    params.extend(g_params)
+                if grouping:
+                    if distinct_fields:
+                        raise NotImplementedError('annotate() + distinct(fields) is not implemented.')
+                    order_by = order_by or self.connection.ops.force_no_ordering()
+                    result.append('GROUP BY %s' % ', '.join(grouping))
+                    if self._meta_ordering:
+                        # When the deprecation ends, replace with:
+                        # order_by = None
+                        warnings.warn(
+                            "%s QuerySet won't use Meta.ordering in Django 3.1. "
+                            "Add .order_by(%s) to retain the current query." % (
+                                self.query.model.__name__,
+                                ', '.join(repr(f) for f in self._meta_ordering),
+                            ),
+                            RemovedInDjango31Warning,
+                            stacklevel=4,
+                        )
+
+                if having:
+                    result.append('HAVING %s' % having)
+                    params.extend(h_params)
+
+            if self.query.explain_query:
+                result.insert(0, self.connection.ops.explain_query_prefix(
+                    self.query.explain_format,
+                    **self.query.explain_options
+                ))
+
+            if order_by:
+                ordering = []
+                for _, (o_sql, o_params, _) in order_by:
+                    ordering.append(o_sql)
+                    params.extend(o_params)
+                result.append('ORDER BY %s' % ', '.join(ordering))
+
+            if with_limit_offset:
+                if len(result) == 1:
+                    result = ["SELECT","* FROM (", result[0], ")"]
+                result.insert(1, 
+                    self.connection.ops.limit_offset_sql(
+                        self.query.low_mark, 
+                        self.query.high_mark
+                    )
+                )                
+
+            if for_update_part and not self.connection.features.for_update_after_from:
+                result.append(for_update_part)
+            if self.query.subquery and extra_select:
+                # If the query is used as a subquery, the extra selects would
+                # result in more columns than the left-hand side expression is
+                # expecting. This can happen when a subquery uses a combination
+                # of order_by() and distinct(), forcing the ordering expressions
+                # to be selected as well. Wrap the query in another subquery
+                # to exclude extraneous selects.
+                sub_selects = []
+                sub_params = []
+                for index, (select, _, alias) in enumerate(self.select, start=1):
+                    if not alias and with_col_aliases:
+                        alias = 'col%d' % index
+                    if alias:
+                        sub_selects.append("%s.%s" % (
+                            self.connection.ops.quote_name('subquery'),
+                            self.connection.ops.quote_name(alias),
+                        ))
+                    else:
+                        select_clone = select.relabeled_clone({select.alias: 'subquery'})
+                        subselect, subparams = select_clone.as_sql(self, self.connection)
+                        sub_selects.append(subselect)
+                        sub_params.extend(subparams)
+                return 'SELECT %s FROM (%s) subquery' % (
+                    ', '.join(sub_selects),
+                    ' '.join(result),
+                ), tuple(sub_params + params)
+
+            return ' '.join(result), tuple(params)
+        finally:
+            # Finally do cleanup - get rid of the joins we created above.
+            self.query.reset_refcounts(refcounts_before)
+
+
+class SQLInsertCompiler(compiler.SQLInsertCompiler, SQLCompiler):
+    pass
+
+
+class SQLDeleteCompiler(compiler.SQLDeleteCompiler, SQLCompiler):
+    pass
+
+
+class SQLUpdateCompiler(compiler.SQLUpdateCompiler, SQLCompiler):
+    pass
+
+
+class SQLAggregateCompiler(compiler.SQLAggregateCompiler, SQLCompiler):
+    pass

django_gbase8s/creation.py

@@ -0,0 +1,15 @@
+from django.db.backends.base.creation import BaseDatabaseCreation
+
+class DatabaseCreation(BaseDatabaseCreation):
+    
+    def sql_table_creation_suffix(self):
+        """
+        SQL to append to the end of the test table creation statements.
+        """
+        return "WITH LOG"
+
+    def _destroy_test_db(self, test_database_name, verbosity):
+        with self.connection._nodb_connection.cursor() as cursor:
+            cursor.execute("CLOSE DATABASE")
+            cursor.execute("DROP DATABASE %s"
+                           % self.connection.ops.quote_name(test_database_name))