sqlalchemy-iris 0.5.0b3__py3-none-any.whl → 0.6.0b1__py3-none-any.whl

intersystems_iris/_SharedMemorySocket.py

@@ -0,0 +1,87 @@
+import ctypes
+import os
+
+class IOBUFFER_STRUCT(ctypes.Structure):
+    _fields_ = [("send_buffer", ctypes.POINTER(ctypes.c_char)),
+                ("send_length", ctypes.c_int),
+                ("receive_buffer", ctypes.POINTER(ctypes.c_char)),
+                ("receive_length", ctypes.c_int),
+                ("status", ctypes.c_short)]
+
+class _SharedMemorySocket(object):
+
+    def __init__(self, iris_installation_dir, pid, filename):
+        if os.name != "nt":
+            self._module = ctypes.cdll.LoadLibrary(os.path.join(iris_installation_dir + "bin", "libxdevshm.so"))
+            pointer_type = ctypes.c_int64
+        elif ctypes.sizeof(ctypes.c_voidp) > 4:
+            self._module = ctypes.cdll.LoadLibrary(os.path.join(iris_installation_dir + "bin", "XDEVshm.dll"))
+            pointer_type = ctypes.c_int64
+        else:
+            self._module = ctypes.cdll.LoadLibrary(os.path.join(iris_installation_dir + "bin", "XDEVshm32.dll"))
+            pointer_type = ctypes.c_int32
+        self._module.SharedMemory_InitializeWithName.argtypes = tuple([ctypes.c_void_p, ctypes.c_uint, ctypes.c_char_p])
+        self._module.SharedMemory_Connect.argtypes = tuple([pointer_type, ctypes.c_uint, ctypes.c_int, ctypes.c_void_p])
+        self._module.SharedMemory_IOBuffer_Initialize.argtypes = tuple([pointer_type, ctypes.POINTER(IOBUFFER_STRUCT)])
+        self._module.SharedMemory_IOBuffer_Read.argtypes = tuple([pointer_type])
+        self._module.SharedMemory_IOBuffer_Write.argtypes = tuple([pointer_type])
+        self._module.SharedMemory_Close.argtypes = tuple([pointer_type])
+        shm_pointer = ctypes.c_void_p(0)
+        self._iobuffer = None
+        if self._module.SharedMemory_InitializeWithName(ctypes.byref(shm_pointer), int(pid), ctypes.c_char_p(filename)) != 0:
+            raise Exception("Could not initialize shared memory")
+        self._shm_pointer = shm_pointer.value
+        if self._shm_pointer==0:
+            raise Exception("Could not create shared memory")
+        return
+
+    def connect(self):
+        # flag harcoded to 0. change to 1 to generate shared memory log.
+        # timeout hardcoded to 10. user specified timeout was used to TCP/IP and not used here.
+        if self._module.SharedMemory_Connect(self._shm_pointer, 0, 10, ctypes.byref(ctypes.c_int(0))) != 0:
+            raise Exception("Could not connect shared memory")
+        initial_allocation_size = 256
+        self._send_buffer = ctypes.create_string_buffer(initial_allocation_size)
+        self._receive_buffer = ctypes.create_string_buffer(initial_allocation_size)
+        self._iobuffer = IOBUFFER_STRUCT(self._send_buffer,0,self._receive_buffer,0,0)
+        if self._module.SharedMemory_IOBuffer_Initialize(self._shm_pointer, ctypes.byref(self._iobuffer)):
+            raise Exception("Could not initialize iobuffer for shared memory")
+        return
+
+    def close(self):
+        if self._module.SharedMemory_Close(self._shm_pointer) != 0:
+            raise Exception("Could not close shared memory")
+        self._shm_pointer=0
+        return
+
+    def sendall(self, buffer):
+        if len(buffer) > len(self._send_buffer):
+            self._send_buffer = ctypes.create_string_buffer(len(buffer))
+            self._iobuffer.send_buffer = self._send_buffer
+        self._send_buffer[0:len(buffer)] = buffer
+        self._iobuffer.send_length = len(buffer)
+        self._iobuffer.status = -1
+        self._module.SharedMemory_IOBuffer_Write(self._shm_pointer)
+        if self._iobuffer.status != 0:
+            raise Exception("Could not send data via shared memory")
+        return
+
+    def recv(self, length_requesting):
+        if length_requesting > len(self._receive_buffer):
+            self._receive_buffer = ctypes.create_string_buffer(length_requesting)
+            self._iobuffer.receive_buffer = self._receive_buffer
+        self._iobuffer.receive_length = length_requesting
+        self._iobuffer.status = -1
+        self._module.SharedMemory_IOBuffer_Read(self._shm_pointer)
+        if self._iobuffer.status != 0:
+            raise Exception("Could not read data via shared memory")
+        return self._receive_buffer[0:self._iobuffer.receive_length]
+
+    def settimeout(self, timeout):
+        return
+
+    def gethostname(self):
+        return ""
+
+    def gethostbyname(self, hostname):
+        return ""

intersystems_iris/__init__.py

@@ -0,0 +1,79 @@
+'''
+IRIS Native API for Python.
+
+This module provides highly efficient and lightweight access to IRIS,
+including the Global Module and object oriented programming environment.
+'''
+from . import _BufferReader
+from . import _BufferWriter
+from . import _ConnectionInformation
+from . import _ConnectionParameters
+from . import _Constant
+from . import _Device
+from . import _DBList
+from . import _GatewayContext
+from . import _GatewayException
+from . import _GatewayUtility
+from . import _InStream
+from . import _IRIS
+from . import _IRISConnection
+from . import _IRISGlobalNode
+from . import _IRISGlobalNodeView
+from . import _IRISIterator
+from . import _IRISList
+from . import _IRISObject
+from . import _IRISOREF
+from . import _IRISReference
+from . import _LegacyIterator
+from . import _ListItem
+from . import _ListReader
+from . import _ListWriter
+from . import _LogFileStream
+from . import _MessageHeader
+from . import _OutStream
+from . import _PrintStream
+from . import _PythonGateway
+
+from intersystems_iris._IRISNative import connect  # noqa
+from intersystems_iris._IRISNative import createConnection  # noqa
+from intersystems_iris._IRISNative import createIRIS  # noqa
+
+
+class GatewayContext(_GatewayContext._GatewayContext):
+    pass
+
+
+class IRIS(_IRIS._IRIS):
+    pass
+
+
+class IRISConnection(_IRISConnection._IRISConnection):
+    pass
+
+
+class IRISGlobalNode(_IRISGlobalNode._IRISGlobalNode):
+    pass
+
+
+class IRISGlobalNodeView(_IRISGlobalNodeView._IRISGlobalNodeView):
+    pass
+
+
+class IRISIterator(_IRISIterator._IRISIterator):
+    pass
+
+
+class IRISList(_IRISList._IRISList):
+    pass
+
+
+class IRISObject(_IRISObject._IRISObject):
+    pass
+
+
+class IRISReference(_IRISReference._IRISReference):
+    pass
+
+
+class LegacyIterator(_LegacyIterator._LegacyIterator):
+    pass

intersystems_iris/__main__.py

@@ -0,0 +1,7 @@
+import sys
+import intersystems_iris._PythonGateway
+
+if len(sys.argv) >= 2 and sys.argv[1] == "PythonGateway":
+    intersystems_iris._PythonGateway._PythonGateway._main(sys.argv[2:])
+else:
+    print("Invalid Parameter")

intersystems_iris/dbapi/_Column.py

@@ -0,0 +1,56 @@
+import intersystems_iris.dbapi._Descriptor
+
+class _Column(intersystems_iris.dbapi._Descriptor._Descriptor):
+    def __init__(self, name, type, precision, scale, nullable, label, tableName, schema, catalog, additionalData, slotPosition):
+        name = str(name)
+        label = str(label)
+        tableName = str(tableName)
+        schema = str(schema)
+        if catalog is not None:
+            catalog = str(catalog)
+        try:
+            slotPosition = int(slotPosition)
+        except (TypeError, ValueError):
+            raise TypeError("slotPosition must be an integer")
+        if slotPosition < 0:
+            raise ValueError("slotPosition must be positive")
+        
+        super().__init__(type, precision, scale, nullable)
+        self.name = name
+        self.slotPosition = slotPosition
+        self.label = label
+        self.tableName = tableName
+        self.schema = schema
+        self.catalog = catalog
+        additionalDataFlags = []
+        for v in additionalData:
+            additionalDataFlags.append(bool(v))
+        for i in range(12 - len(additionalDataFlags)):
+            additionalDataFlags.append(False)
+        self.isAutoIncrement = bool(additionalDataFlags[0])
+        self.isCaseSensitive = bool(additionalDataFlags[1])
+        self.isCurrency = bool(additionalDataFlags[2])
+        self.isReadOnly = bool(additionalDataFlags[3])
+        self.isRowVersion = bool(additionalDataFlags[4])
+        self.isUnique = bool(additionalDataFlags[5])
+        self.isAliased = bool(additionalDataFlags[6])
+        self.isExpression = bool(additionalDataFlags[7])
+        self.isHidden = bool(additionalDataFlags[8])
+        self.isIdentity = bool(additionalDataFlags[9])
+        self.isKeyColumn = bool(additionalDataFlags[10])
+        self.isRowId = bool(additionalDataFlags[11])
+
+    def Clone(self):
+        additionalData = [self.isAutoIncrement,
+                          self.isCaseSensitive,
+                          self.isCurrency,
+                          self.isReadOnly,
+                          self.isRowVersion,
+                          self.isUnique,
+                          self.isAliased,
+                          self.isExpression,
+                          self.isHidden,
+                          self.isIdentity,
+                          self.isKeyColumn,
+                          self.isRowId]
+        return _Column(self.name, self.type, self.precision, self.scale, self.nullable, self.label, self.tableName, self.schema, self.catalog, additionalData, self.slotPosition)