Test: test eis short instruction

python/biopro/db/collection.py

@@ -20,44 +20,29 @@ class Collection(Base):
     updated_at = Column(TIMESTAMP(timezone=True), onupdate=func.now())
 
     @classmethod
-    def create_collection(cls, collection_name, parent, duplicate=False):
+    def create_collection(cls, collection_name, parent):
         with Session() as session:
-            name = cls.check_name_duplicate(collection_name, parent, 0, duplicate=duplicate)
-            if name == None:
-                return session.query(Collection).filter(Collection.name == collection_name, Collection.parent == parent).first()
-            else:
-                collection = Collection(
-                    name = name,
-                    parent = parent,
-                    type= "folder",
-                )
-                session.add(collection)
-                session.commit()
-                session.refresh(collection)
-                return collection
+            name = cls.check_name_duplicate(collection_name, parent, 0)
+            collection = Collection(
+                name = name,
+                parent = parent,
+                type= "folder",
+            )
+            session.add(collection)
+            session.commit()
+            print('a', collection.id)
+            return collection
 
     @classmethod
-    def check_name_duplicate(cls, collection_name, parent, n, _session = None, duplicate=False):
-        if _session == None:
-            with Session() as session:
-                result = session.query(Collection).filter(Collection.name == cls.generate_name(collection_name, n), Collection.parent == parent).first()
-                if result is None:
-                    return cls.generate_name(collection_name, n)
-                else:
-                    if duplicate == True:
-                        return None
-                    else:
-                        new_num = n + 1
-                        # new_name =  f"{collection_name}({new_num})" 
-                        return cls.check_name_duplicate(collection_name, parent, new_num, session)
-        else:
-            result = _session.query(Collection).filter(Collection.name == cls.generate_name(collection_name, n), Collection.parent == parent).first()
+    def check_name_duplicate(cls, collection_name, parent, n):
+        with Session() as session:
+            result = session.query(Collection).filter(Collection.name == cls.generate_name(collection_name, n), Collection.parent == parent).first()
             if result is None:
                 return cls.generate_name(collection_name, n)
             else:
                 new_num = n + 1
                 # new_name =  f"{collection_name}({new_num})" 
-                return cls.check_name_duplicate(collection_name, parent, new_num, _session)
+                return cls.check_name_duplicate(collection_name, parent, new_num)
 
     @classmethod
     def generate_name(cls, collection_name, n):

python/biopro/db/meta.py

@@ -1,24 +0,0 @@
-from sqlalchemy import Table, Column, String, MetaData, ForeignKey, JSON
-from sqlalchemy.sql import select, func
-from sqlalchemy.types import Integer, BigInteger, String, Boolean, TIMESTAMP, Numeric
-from sqlalchemy.dialects.postgresql import JSONB
-
-from .base import Base, Session
-
-class RecordingDataMeta(Base):
-    __tablename__ = "recording_data_metas"
-
-    id = Column(Integer, primary_key=True)
-    path = Column(String(255))
-    name = Column(String(255))
-    parent = Column(JSONB)
-    size = Column(String(255))
-    time_duration = (String(255))
-    raw_data = Column(JSONB)
-    project = Column(Integer)
-    deleted = Column(Boolean, default = False)
-    created_at = Column(TIMESTAMP(timezone=True), server_default=func.now())
-    updated_at = Column(TIMESTAMP(timezone=True), onupdate=func.now())
-
-    # def __repr__(self):
-    #     return f"User(id={self.id!r}, name={self.name!r}, fullname={self.task!r})"

python/biopro/db/recording_data.py

@@ -1,88 +0,0 @@
-from sqlalchemy import Table, Column, String, MetaData, ForeignKey, JSON
-from sqlalchemy.sql import select, func
-from sqlalchemy.types import Integer, BigInteger, String, Boolean, TIMESTAMP, Numeric, Text
-from sqlalchemy.dialects.postgresql import JSONB
-from biopro.db.base import Session
-
-from .base import Base
-
-# build a model class with a specific table name
-def get_raw_model(channel):
-    tablename = str(channel) + '_recording_data_raws'  # dynamic table name
-    class_name = 'RECORDING_DATA_RAWS' # dynamic class name
-    print('get_raw_model', tablename)
-
-    for mapper in Base.registry.mappers:
-        cls = mapper.class_
-        classname = cls.__name__
-        tblname = cls.__tablename__
-        print(cls, classname, tblname)
-        if (classname == class_name):
-            if tblname == tablename:
-                return cls
-
-    Model = type(class_name, (RECORDING_DATA_RAWS,), {
-        '__tablename__': tablename
-    })
-    return Model
-
-
-class RECORDING_DATA_RAWS(Base):
-    __abstract__ = True
-
-    id = Column(Integer, primary_key=True)
-    name = Column(String(255))
-    parent = Column(Integer)
-    size = Column(String(255))
-    path = Column(JSONB)
-    uuid = Column(String(255))
-    serial_number = Column(String(255))
-    data_format = Column(String(255))
-    channel = Column(Integer)
-    start_time = Column(String(255))
-    end_time = Column(String(255))
-    data = Column(Text)
-    compressed = Column(Boolean)
-    deleted = Column(Boolean)
-    created_at = Column(TIMESTAMP(timezone=True), server_default=func.now())
-    updated_at = Column(TIMESTAMP(timezone=True), onupdate=func.now())
-
-    # @classmethod
-    # def create_subject_data(cls, subject_id, project, meta, data):
-    #     with Session() as session:
-    #         subject = Subject(
-    #             subject_id = subject_id,
-    #             project = project,
-    #             meta= meta,
-    #             data = data
-    #         )
-    #         session.add(subject)
-    #         session.commit()
-    #         return subject
-        
-    # @classmethod
-    # def check_name_duplicate(cls, collection_name, parent, n):
-    #     with Session() as session:
-    #         result = session.query(Collection).filter(Collection.name == cls.generate_name(collection_name, n), Collection.parent == parent).first()
-    #         if result is None:
-    #             return cls.generate_name(collection_name, n)
-    #         else:
-    #             new_num = n + 1
-    #             # new_name =  f"{collection_name}({new_num})" 
-    #             return cls.check_name_duplicate(collection_name, parent, new_num)
-
-    # @classmethod
-    # def generate_name(cls, collection_name, n):
-    #     if n==0:
-    #         return collection_name
-    #     else:
-    #         return f"{collection_name}({n})" 
-    
-    # @classmethod
-    # def find_data(cls, id):
-    #     with Session() as session:
-
-    #         result = session.query(RECORDING_DATA_RAWS).first()
-    #         return result
-    
-        

python/biopro/db/subject_data.py

@@ -1,60 +0,0 @@
-from sqlalchemy import Table, Column, String, MetaData, ForeignKey, JSON
-from sqlalchemy.sql import select, func
-from sqlalchemy.types import Integer, BigInteger, String, Boolean, TIMESTAMP, Numeric
-from sqlalchemy.dialects.postgresql import JSONB
-from biopro.db.base import Session
-
-from .base import Base
-
-class SubjectData(Base):
-    __tablename__ = "subject_datas"
-
-    id = Column(Integer, primary_key=True)
-    subject_id = Column(Integer)
-    mode = Column(JSONB)
-    data = Column(JSONB)
-    user_auth = Column(JSONB)
-    meta = Column(String(255))
-    project = Column(String(255))
-    deleted = Column(Boolean)
-    created_at = Column(TIMESTAMP(timezone=True), server_default=func.now())
-    updated_at = Column(TIMESTAMP(timezone=True), onupdate=func.now())
-
-    @classmethod
-    def create_subject_data(cls, subject_id, project, meta, data):
-        with Session() as session:
-            subject = SubjectData(
-                subject_id = subject_id,
-                project = project,
-                meta= meta,
-                data = data
-            )
-            session.add(subject)
-            session.commit()
-            return subject
-        
-    # @classmethod
-    # def check_name_duplicate(cls, collection_name, parent, n):
-    #     with Session() as session:
-    #         result = session.query(Collection).filter(Collection.name == cls.generate_name(collection_name, n), Collection.parent == parent).first()
-    #         if result is None:
-    #             return cls.generate_name(collection_name, n)
-    #         else:
-    #             new_num = n + 1
-    #             # new_name =  f"{collection_name}({new_num})" 
-    #             return cls.check_name_duplicate(collection_name, parent, new_num)
-
-    # @classmethod
-    # def generate_name(cls, collection_name, n):
-    #     if n==0:
-    #         return collection_name
-    #     else:
-    #         return f"{collection_name}({n})" 
-    
-    # @classmethod
-    # def find_collection(cls, collection_name, parent):
-    #     with Session() as session:
-    #         result = session.query(Collection).filter(Collection.name == collection_name, Collection.parent == parent).first()
-    #         return result
-    
-        

python/biopro/device/device_cc2650.py

@@ -2034,32 +2034,22 @@ class CC2650SingleMasterCentralDevice(CC2650MasterDevice, Synchronized):
         ins.append(0xF1)
         self._interface.flush_input()
 
-        for _ in range(5):
+        try:
+            self.log_verbose('[CC2650]', 'scan_callback att_write','0x'+str.upper(ins.hex()))
+            self._cc2650.send("bytes", bytes(ins))
+
+        except SerialTimeoutException:
+            self.log_verbose('[CC2650]', 'scan_callback send fail')
+
+        else:
             try:
-                self.log_verbose('[CC2650]', 'scan_callback att_write','0x'+str.upper(ins.hex()))
-                self._cc2650.send("bytes", bytes(ins))
+                scan_response = self._cc2650.recv_uart(0.01)
 
-            except SerialTimeoutException:
-                self.log_verbose('[CC2650]', 'scan_callback send fail, rescan')
-                continue
-
-            else:
-                try:
-                    scan_response = self._cc2650.recv_uart(0.01)
-
-                except RecvTimeout:
-                    self.log_verbose('[CC2650]', 'scan_callback response timeout, no device, rescan')
-                    continue
-
-                else:
-                    if scan_response is None:
-                        self.log_verbose('[CC2650]', 'scan_callback response is None, rescan')
-                        continue
-                    else:
-                        break
+            except RecvTimeout:
+                self.log_verbose('[CC2650]', 'scan_callback response timeout, no device')
+                return False
 
         if scan_response is None:
-            self.log_verbose('[CC2650]', 'scan_callback response is None--2')
             return False
 
         scan_response_hex = ''.join(format(i, '02X') for i in scan_response)

python/biopro/devlib/library.py

@@ -1292,9 +1292,6 @@ class CompletedDevice(Device):
 
     def central_version_get(self) -> Optional[list]:
         return self._device.central_version_get()
-    
-    def save_data_to_subject(self, project, meta, device, subject_id):
-        self._master._handler.save_data_to_subject(project, meta, device, subject_id)
 
     # utility method
 

python/biopro/project/project.py

@@ -49,9 +49,6 @@ class Project(threading.Thread):
 
     self._count = 1 #流水號
 
-    self._project_meta_id = -1
-    self._subject = []
-
     self.log_verbose = log_verbose
     self._logger = logging.getLogger('project')
     self._logger.setLevel('DEBUG')
@@ -72,10 +69,7 @@ class Project(threading.Thread):
     collection = Collection.find_collection(default_name, default_parent)
     parent = {"folder": [collection.id]}
     # create project folder
-    folder_name_duplicate = False
-    if len(self._subject) > 0:
-      folder_name_duplicate = True
-    collection = Collection.create_collection(self.name, parent, folder_name_duplicate)
+    collection = Collection.create_collection(self.name, parent)
     self.setup_collection(collection)
     
   def setup_project(self, project):
@@ -107,22 +101,6 @@ class Project(threading.Thread):
   @id.setter
   def id(self, new_id):
     self._id = new_id
-
-  @property
-  def project_meta_id(self) -> int:
-    return self._project_meta_id
-  
-  @project_meta_id.setter
-  def project_meta_id(self, new_project_meta_id):
-    self._project_meta_id = new_project_meta_id
-
-  @property
-  def subject(self) -> object:
-    return self._subject
-  
-  @subject.setter
-  def subject(self, new_subject):
-    self._subject = new_subject
   
   @property
   def uuid(self) -> str:
@@ -300,9 +278,6 @@ class Project(threading.Thread):
                       args = list(map(lambda arg: task_info[arg], instruction['arguments']))
                       target=getattr(device, instruction['method'])(*args)
                       print('instruction 2', device, instruction, datetime.now())
-                    if (action.type == 'stop'):
-                      if (len(self._subject) > 0):
-                         target=getattr(device, "save_data_to_subject")(self.id, self.project_meta_id, device, self._subject[0])
                     if action.type == 'start':
                       self._count += 1
             

python/biopro/project/task_manager.py

@@ -175,7 +175,7 @@ class TaskManager():
       for index, task in enumerate(self._task_list):
         if self.check_task_in_cycle(index) == True:
           if task.type == '':
-            collection = Collection.create_collection(task.name, {"folder": [parent.id]}, False)
+            collection = Collection.create_collection(task.name, {"folder": [parent.id]})
             task.parent = {"folder": [collection.id]}
         else:
           task.parent = {"folder": [parent.id]}

python/biopro/server/main.py

@@ -35,11 +35,8 @@ from biopro.project.project_manager import ProjectManager
 from biopro.db.base import Base, Session, engine
 from biopro.db.project_report import ProjectReport
 from biopro.db.project_meta import MetaProjectInfo
-# from biopro.db.device import Device
-from biopro.db.recording_data import get_raw_model
-from biopro.db.subject_data import SubjectData
-from biopro.db.meta import RecordingDataMeta
-import random
+from biopro.db.device import Device
+
 
 _RUNTIME_COMPILE = False
 
@@ -332,18 +329,6 @@ class ControlServer(SocketServer, ControlServerAPI):
         finally:
             self.led_thread.set_state(LED.AVAILABLE)
 
-            # version_info = [0, 2, 1, 7, 23, 2]
-            # serial_number = DeviceSerialNumber(version_info[0],
-            #                             version_info[1],
-            #                             version_info[2],
-            #                             version_info[3],
-            #                             version_info[4],
-            #                             version_info[5])
-            # response = DeviceResponseInfo('Elite-EDC', serial_number, (164, 218, 50, 212, 231, 12), addr_type=0)
-            # print('setup done', response)
-            # ret = self.device_manager.connect(response)
-            # print('ret', ret)
-
     def _setup_get_available_channel(self) -> Optional[List[int]]:
         client = self.data_server.client()
 
@@ -573,15 +558,8 @@ class ControlServer(SocketServer, ControlServerAPI):
             response = content
         else:
             response = to_device_info(content)
+
         try:
-            # version_info = [0, 2, 1, 7, 23, 2]
-            # serial_number = DeviceSerialNumber(version_info[0],
-            #                             version_info[1],
-            #                             version_info[2],
-            #                             version_info[3],
-            #                             version_info[4],
-            #                             version_info[5])
-            # response = DeviceResponseInfo('Elite-EDC', serial_number, (164, 218, 50, 212, 231, 12))
             ret = self.device_manager.connect(response)
         except DeviceInstructionError as e:
             '''when device reset fail error'''
@@ -1129,7 +1107,7 @@ class ControlServer(SocketServer, ControlServerAPI):
 
         client = self.data_server.client()
         project = None
-        _project_meta_id = None
+        project_meta_id = None
         if client is not None:
             info = self.file_manager.use(device)
 
@@ -1143,12 +1121,10 @@ class ControlServer(SocketServer, ControlServerAPI):
             
             if device.occupied_by_project != None:
                 project = self.project_manager.get(device.occupied_by_project).info_pass_data_server()
-                _project_meta_id = MetaProjectInfo.create_project_meta(project)
-                new_project = self.project_manager.get(device.occupied_by_project)
-                new_project.project_meta_id = _project_meta_id
+                project_meta_id = MetaProjectInfo.create_project_meta(project)      
                 
             with client:
-                client.update_device_configuration(device, info.meta_file, value, _project_meta_id)
+                client.update_device_configuration(device, info.meta_file, value, project_meta_id)
 
     def _device_set_disable_cache(self, device: CompletedDevice, disable):
         if disable:
@@ -1378,57 +1354,6 @@ class ControlServer(SocketServer, ControlServerAPI):
                 } for pkg in PipPackage.list()]
 
             return ret
-        
-        def save_data_to_subject(self, project, meta, device, subject):
-            mode =  device.get_parameter('MODE')
-            library = device.library_name
-            device = {
-                "library": library,
-                "mode": mode
-            }
-
-                # "pattern": {
-                #     "id": number,
-                #     "name": string,
-                #     "parameter": object,
-                # },
-                # "data": {
-                #     "id": list[int],
-                #     "channel: list[int]
-                # }
-
-            with Session() as session:
-                meta_result = session.query(RecordingDataMeta).filter(RecordingDataMeta.project == meta).first()
-                self.mqtt_thread.publish('', json.dumps({
-                    "pattern": {
-                        "id": 4,
-                    },
-                    "data": {
-                        "id": [meta_result.id],
-                        "channel": ['Time', 6]
-                    },
-                    "others": {
-                        "subject": subject,
-                        "device": device,
-                        "project": project,
-                        "project_meta": meta,
-                    }
-                }), analysis= True)
-                # result = session.query(recording_raws).order_by(recording_raws.id.desc()).first()
-                # value = result.data.split(' ')[1:-1:2]
-                # _value = list(map(int, value))
-                # sum_value = sum(_value)
-                # average_value = sum_value / len(_value)
-                # subject_data = SubjectData(
-                #     subject_id= subject['id'],
-                #     project = project,
-                #     meta = meta,
-                #     mode= device,
-                #     data= average_value
-                # )
-                # # Execute the update query
-                # session.add(subject_data)
-                # session.commit()
 
         def _hardware_send_test_hardware(self, section: Optional[str] = None) -> Dict[str, Any]:
             if section is not None:
@@ -1473,6 +1398,7 @@ class ControlServer(SocketServer, ControlServerAPI):
             if client is not None:
                 with client:
                     client.show_data(device)
+
 class _RandomCrashThread(ServerThread):
     def __init__(self):
         super().__init__('Crash')

python/biopro/server/mqtt.py

@@ -170,11 +170,9 @@ class MqttThread(threading.Thread):
         self.sleep(3)
         self._mqtt_client_local.reconnect()
 
-    def publish(self, topic: str, payload: str, inter = False, analysis=False, qos = 2):
+    def publish(self, topic: str, payload: str, inter = False, qos = 2):
         if inter:
             _topic = self.__controller_ID + '_user'
-        elif analysis:
-            _topic = self.__controller_ID + '_data_analysis/get_analysis_data'
         else:
             _topic = self.__controller_ID + '/' + topic
         if self._mqtt_client_local is not None:

python/res/devlib/json/Elite_EIS_1.0.devlib.json

@@ -222,7 +222,8 @@
       "initial": 26,
       "domain": [
         2048
-      ]
+      ],
+      "on_change": "set_para_CF_AC_AMP"
     },
     "CF_FREQ": {
       "description": "frequency of cf",
@@ -327,7 +328,8 @@
       ],
       "value": {
         "expression": "VALUE"
-      }
+      },
+      "on_change": "set_ca_volt"
     },
     "VT_MEASURE_VIN_RANGE": {
       "description": "measure range of Vin",
@@ -628,6 +630,18 @@
         "XE2;X01;2B>RT_VOLT_SET"
       ]
     },
+    "set_para_CF_AC_AMP": {
+      "type": "RIS",
+      "data": [
+        "XE2;X02;2B>CF_AC_AMP"
+      ]
+    },
+    "set_ca_volt": {
+      "type": "RIS",
+      "data": [
+        "XFF;X74;2B>CA_VOLT"
+      ]
+    },
     "ble_instru_send": [
       "ble_write",
       "_cdr('20X>ADC_VALUE_I')"

python/res/devlib/json/Elite_EIS_1.1.devlib.json

@@ -222,7 +222,8 @@
       "initial": 26,
       "domain": [
         2048
-      ]
+      ],
+      "on_change": "set_para_CF_AC_AMP"
     },
     "CF_FREQ": {
       "description": "frequency of cf",
@@ -327,7 +328,8 @@
       ],
       "value": {
         "expression": "VALUE"
-      }
+      },
+      "on_change": "set_ca_volt"
     },
     "VT_MEASURE_VIN_RANGE": {
       "description": "measure range of Vin",
@@ -628,6 +630,18 @@
         "XE2;X01;2B>RT_VOLT_SET"
       ]
     },
+    "set_para_CF_AC_AMP": {
+      "type": "RIS",
+      "data": [
+        "XE2;X02;2B>CF_AC_AMP"
+      ]
+    },
+    "set_ca_volt": {
+      "type": "RIS",
+      "data": [
+        "XFF;X74;2B>CA_VOLT"
+      ]
+    },
     "ble_instru_send": [
       "ble_write",
       "_cdr('20X>ADC_VALUE_I')"

python/res/devlib/json/Elite_EIS_MINI_1.0.devlib.json

@@ -222,7 +222,8 @@
       "initial": 26,
       "domain": [
         2048
-      ]
+      ],
+      "on_change": "set_para_CF_AC_AMP"
     },
     "CF_FREQ": {
       "description": "frequency of cf",
@@ -327,7 +328,8 @@
       ],
       "value": {
         "expression": "VALUE"
-      }
+      },
+      "on_change": "set_ca_volt"
     },
     "VT_MEASURE_VIN_RANGE": {
       "description": "measure range of Vin",
@@ -628,6 +630,18 @@
         "XE2;X01;2B>RT_VOLT_SET"
       ]
     },
+    "set_para_CF_AC_AMP": {
+      "type": "RIS",
+      "data": [
+        "XE2;X02;2B>CF_AC_AMP"
+      ]
+    },
+    "set_ca_volt": {
+      "type": "RIS",
+      "data": [
+        "XFF;X74;2B>CA_VOLT"
+      ]
+    },
     "ble_instru_send": [
       "ble_write",
       "_cdr('20X>ADC_VALUE_I')"

python/res/devlib/json/Elite_TRIG_0.1.devlib.json

@@ -9,28 +9,9 @@
     "minor_version_number": 0
   },
   "constant": {
-    "TIME_MAX": 100000,
-    "BLE_WRITE_MAX": 255
+    "TIME_MAX": 100000
   },
   "parameters": {
-    "ADC_VALUE_I": {
-      "description": "ADC value current value",
-      "domain": "int"
-    },
-    "BLE_WRITE": {
-      "description": "send msg to elite",
-      "domain": {
-        "list": [
-          "BLE_WRITE_MAX"
-        ]
-      },
-      "initial": "[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]",
-      "value": "VALUE"
-    },
-    "BLE_READ": {
-      "description": "receive msg from elite",
-      "domain": "int"
-    },
     "TIME_DURATION": {
       "description": "timer",
       "record_meta": true,
@@ -173,10 +154,14 @@
       "record_meta": true,
       "value": [
         "Analog Current Control (ACC)",
-        "Idle",
-        "Dev Mode"
+        "Idle"
       ]
     },
+
+
+
+
+
     "CHANNEL": {
       "description": "delete it",
       "record_meta": true,
@@ -260,21 +245,6 @@
       "CIS_VOLT",
       "_cdr('20X>ADC_VALUE_I')"
     ],
-    "ble_instru_send": [
-      "ble_write",
-      "_cdr('20X>ADC_VALUE_I')"
-    ],
-    "ble_write": {
-      "type": "RIS",
-      "data": [
-        "XFF;",
-        "1B>BLE_WRITE[0];1B>BLE_WRITE[1];1B>BLE_WRITE[2];1B>BLE_WRITE[3];",
-        "1B>BLE_WRITE[4];1B>BLE_WRITE[5];1B>BLE_WRITE[6];1B>BLE_WRITE[7];",
-        "1B>BLE_WRITE[8];1B>BLE_WRITE[9];1B>BLE_WRITE[10];1B>BLE_WRITE[11];",
-        "1B>BLE_WRITE[12];1B>BLE_WRITE[13];1B>BLE_WRITE[14];1B>BLE_WRITE[15];",
-        "1B>BLE_WRITE[16];"
-      ]
-    },
     "curve_acc": {
       "type": "RIS",
       "parameter": {

update_db_package.sh

@@ -35,7 +35,4 @@ sudo su -c "psql -d postgres -c \"ALTER TABLE devices ALTER COLUMN calibration D
 sudo su -c "psql -d postgres -c \"ALTER TABLE devices ALTER COLUMN calibration TYPE bytea USING calibration::bytea;\"" postgres
 
 # add column project in recording_data_metas
-sudo su -c "psql -d postgres -c \"ALTER TABLE devices ADD COLUMN IF NOT EXISTS calibration_version Int4 DEFAULT -1;\"" postgres
-
-# add column subject in project
-sudo su -c "psql -d postgres -c \"ALTER TABLE projects ADD COLUMN IF NOT EXISTS subject JSONB;\"" postgres
+sudo su -c "psql -d postgres -c \"ALTER TABLE devices ADD COLUMN IF NOT EXISTS calibration_version Int4 DEFAULT -1;\"" postgres