Skip to content

database

几何数据库（DmDbDatabase / DmDbLayer）封装

将原本散落在 lib.types.entity 中的数据库相关业务类迁移至此， 以厘清 types 与 db 模块边界：types 仅承载基础几何与实体类型， db 承载数据库/数据表等业务封装。

DmDbDatabase

几何数据库

Source code in dimine_python_sdk\lib\db\database.py 
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
class DmDbDatabase:
    """
    几何数据库
    """

    def __init__(self, file_path):
        # 初始化源扩展的核心对象，作为底层操作入口
        self._db = Dm.dmDbDatabase()
        self.load(file_path)

    def load(self, file_path: str) -> bool | int:
        """
        加载本地数据库文件（底层调用源Load接口）
        :param file_path: 数据库文件路径（UTF-8编码，底层已处理编码转换）
        :return: 加载结果，成功返回True/0，失败返回False/错误码

        example:
        ```python
        dmf = DmDbDatabase()
        db = dmf.load('E:/dassistant/tests/123.dmf')
        print(db)
        ```
        """
        if not isinstance(file_path, str) or not file_path.strip():
            raise ValueError("文件路径不能为空字符串")
        return self._db.Load(file_path)

    def get_layers_count(self) -> int:
        """
        获取数据库图层总数（底层调用源GetLayersCount接口）
        :return: 非负整数，图层总数量

        example:
        ```python
        dmf = DmDbDatabase()
        db = dmf.load('E:/dassistant/tests/123.dmf')
        print("获取图层数量:",dmf.get_layers_count())
        ```
        """
        return self._db.GetLayersCount()

    def get_layer_by_index(self, layer_index: int) -> DmDbLayer | None:
        """
        通过索引获取图层对象（底层调用源GetLayerFromIndex接口）
        :param layer_index: 图层索引，从0开始
        :return: 图层对象，索引无效时返回None
        """
        if not isinstance(layer_index, int) or layer_index < 0:
            raise ValueError("图层索引必须为非负整数")
        cpp_result = self._db.GetLayerFromIndex(layer_index)
        return DmDbLayer._from_obj(cpp_result)

    def set_file_name(self, file_path: str) -> None:
        """
        设置数据库文件路径（底层调用源SetFileName接口）
        :param file_path: 数据库文件路径（UTF-8编码）
        """
        if not isinstance(file_path, str) or not file_path.strip():
            raise ValueError("文件路径不能为空字符串")
        self._db.SetFileName(file_path)

    def insert_layer(self, layer_name: str) -> DmDbLayer:
        """
        插入新图层（底层调用源InsertLayer接口）
        :param layer_name: 图层名称（UTF-8编码）
        :return: 新创建的图层对象

        example:
        ```python
        dmf = DmDbDatabase()
        db = dmf.load('E:/dassistant/tests/123.dmf')
        layer = dmf.insert_layer("新图层")
        print("插入新图层:",layer)
        ```
        """
        if not isinstance(layer_name, str) or not layer_name.strip():
            raise ValueError("图层名称不能为空字符串")
        cpp_result = self._db.InsertLayer(layer_name.strip())
        return DmDbLayer._from_obj(cpp_result)

    def save(self, file_path: str | None = None) -> bool | int:
        """
        保存数据库（底层调用源Save重载接口，自动适配无参/有参）
        :param file_path: 可选保存路径，为None时保存到当前路径
        :return: 保存结果，成功返回True/0，失败返回False/错误码

        example:
        ```python
        dmf = DmDbDatabase()
        db = dmf.load('E:/dassistant/tests/123.dmf')
        layer = dmf.insert_layer("新图层")
        print("插入新图层:",layer)
        dmf.save("E:/dassistant/tests/123_1.dmf")
        ```
        """
        if file_path is None:
            return self._db.Save()
        if not isinstance(file_path, str) or not file_path.strip():
            raise ValueError("保存路径不能为空字符串")
        return self._db.Save(file_path)

    def switch_to_local_storage(self) -> None:
        """切换到本地存储模式（底层调用源SetToLocalStorage接口）"""
        self._db.SetToLocalStorage()

    def get_active_layer(self) -> DmDbLayer | None:
        """
        获取当前激活图层（底层调用源GetActiveLayer接口）
        :return: 激活图层对象，无激活图层时返回None

        example:
        ```python
        dmf = DmDbDatabase()
        db = dmf.load('E:/dassistant/tests/123.dmf')
        layer = dmf.get_active_layer()
        print("当前活动图层:",layer)
        ```
        """
        cpp_result = self._db.GetActiveLayer()
        return DmDbLayer._from_obj(cpp_result)

    @staticmethod
    def create_local_db() -> "DmDbDatabase":
        """
        创建本地数据库（底层调用源CreateLocalDB静态接口）
        :return: 新创建的数据库对象
        """
        cpp_db = Dm.dmDbDatabase.CreateLocalDB()
        return DmDbDatabase._from_obj(cpp_db)

    def close_polyline(self) -> bool | int:
        """
        闭合多段线（底层调用源ClosePolyline接口）
        :return: 操作结果
        """
        return self._db.ClosePolyline()

    def set_color(self, red: int, green: int, blue: int) -> None:
        """
        设置颜色（底层调用源SetColor接口）
        :param red: 红色通道值（0-255）
        :param green: 绿色通道值（0-255）
        :param blue: 蓝色通道值（0-255）
        """
        if not (0 <= red <= 255) or not (0 <= green <= 255) or not (0 <= blue <= 255):
            raise ValueError("颜色值必须在0-255之间")
        self._db.SetColor(red, green, blue)

    def add_property(self, property_name: str, property_type: str) -> tuple[bool, str]:
        """
        添加属性（底层调用源AddProperty接口）
        :param property_name: 属性名称（UTF-8编码）
        :param property_type: 属性类型（UTF-8编码）
        :return: 操作结果（是否成功，提示信息）
        """
        if not isinstance(property_name, str) or not property_name.strip():
            raise ValueError("属性名称不能为空")
        if not isinstance(property_type, str):
            raise ValueError("属性类型必须为字符串")
        return self._db.AddProperty(property_name, property_type)

    @classmethod
    def _from_obj(cls, obj):
        """
        原生dmDbDatabase对象创建封装实例
        :param obj: 原生dmDbDatabase对象（bind11封装后）
        :return: DmDbDatabase实例
        """
        instance = cls.__new__(cls)
        instance._obj = obj
        return instance

add_property(property_name, property_type)

添加属性（底层调用源AddProperty接口） :param property_name: 属性名称（UTF-8编码） :param property_type: 属性类型（UTF-8编码） :return: 操作结果（是否成功，提示信息）

Source code in dimine_python_sdk\lib\db\database.py 
255
256
257
258
259
260
261
262
263
264
265
266
def add_property(self, property_name: str, property_type: str) -> tuple[bool, str]:
    """
    添加属性（底层调用源AddProperty接口）
    :param property_name: 属性名称（UTF-8编码）
    :param property_type: 属性类型（UTF-8编码）
    :return: 操作结果（是否成功，提示信息）
    """
    if not isinstance(property_name, str) or not property_name.strip():
        raise ValueError("属性名称不能为空")
    if not isinstance(property_type, str):
        raise ValueError("属性类型必须为字符串")
    return self._db.AddProperty(property_name, property_type)

close_polyline()

闭合多段线（底层调用源ClosePolyline接口） :return: 操作结果

Source code in dimine_python_sdk\lib\db\database.py 
237
238
239
240
241
242
def close_polyline(self) -> bool | int:
    """
    闭合多段线（底层调用源ClosePolyline接口）
    :return: 操作结果
    """
    return self._db.ClosePolyline()

create_local_db() staticmethod

创建本地数据库（底层调用源CreateLocalDB静态接口） :return: 新创建的数据库对象

Source code in dimine_python_sdk\lib\db\database.py 
228
229
230
231
232
233
234
235
@staticmethod
def create_local_db() -> "DmDbDatabase":
    """
    创建本地数据库（底层调用源CreateLocalDB静态接口）
    :return: 新创建的数据库对象
    """
    cpp_db = Dm.dmDbDatabase.CreateLocalDB()
    return DmDbDatabase._from_obj(cpp_db)

get_active_layer()

获取当前激活图层（底层调用源GetActiveLayer接口） :return: 激活图层对象，无激活图层时返回None

example:

dmf = DmDbDatabase()
db = dmf.load('E:/dassistant/tests/123.dmf')
layer = dmf.get_active_layer()
print("当前活动图层:",layer)
Source code in dimine_python_sdk\lib\db\database.py 
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
def get_active_layer(self) -> DmDbLayer | None:
    """
    获取当前激活图层（底层调用源GetActiveLayer接口）
    :return: 激活图层对象，无激活图层时返回None

    example:
    ```python
    dmf = DmDbDatabase()
    db = dmf.load('E:/dassistant/tests/123.dmf')
    layer = dmf.get_active_layer()
    print("当前活动图层:",layer)
    ```
    """
    cpp_result = self._db.GetActiveLayer()
    return DmDbLayer._from_obj(cpp_result)

get_layer_by_index(layer_index)

通过索引获取图层对象（底层调用源GetLayerFromIndex接口） :param layer_index: 图层索引，从0开始 :return: 图层对象，索引无效时返回None

Source code in dimine_python_sdk\lib\db\database.py 
148
149
150
151
152
153
154
155
156
157
def get_layer_by_index(self, layer_index: int) -> DmDbLayer | None:
    """
    通过索引获取图层对象（底层调用源GetLayerFromIndex接口）
    :param layer_index: 图层索引，从0开始
    :return: 图层对象，索引无效时返回None
    """
    if not isinstance(layer_index, int) or layer_index < 0:
        raise ValueError("图层索引必须为非负整数")
    cpp_result = self._db.GetLayerFromIndex(layer_index)
    return DmDbLayer._from_obj(cpp_result)

get_layers_count()

获取数据库图层总数（底层调用源GetLayersCount接口） :return: 非负整数，图层总数量

example:

dmf = DmDbDatabase()
db = dmf.load('E:/dassistant/tests/123.dmf')
print("获取图层数量:",dmf.get_layers_count())
Source code in dimine_python_sdk\lib\db\database.py 
134
135
136
137
138
139
140
141
142
143
144
145
146
def get_layers_count(self) -> int:
    """
    获取数据库图层总数（底层调用源GetLayersCount接口）
    :return: 非负整数，图层总数量

    example:
    ```python
    dmf = DmDbDatabase()
    db = dmf.load('E:/dassistant/tests/123.dmf')
    print("获取图层数量:",dmf.get_layers_count())
    ```
    """
    return self._db.GetLayersCount()

insert_layer(layer_name)

插入新图层（底层调用源InsertLayer接口） :param layer_name: 图层名称（UTF-8编码） :return: 新创建的图层对象

example:

dmf = DmDbDatabase()
db = dmf.load('E:/dassistant/tests/123.dmf')
layer = dmf.insert_layer("新图层")
print("插入新图层:",layer)
Source code in dimine_python_sdk\lib\db\database.py 
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
def insert_layer(self, layer_name: str) -> DmDbLayer:
    """
    插入新图层（底层调用源InsertLayer接口）
    :param layer_name: 图层名称（UTF-8编码）
    :return: 新创建的图层对象

    example:
    ```python
    dmf = DmDbDatabase()
    db = dmf.load('E:/dassistant/tests/123.dmf')
    layer = dmf.insert_layer("新图层")
    print("插入新图层:",layer)
    ```
    """
    if not isinstance(layer_name, str) or not layer_name.strip():
        raise ValueError("图层名称不能为空字符串")
    cpp_result = self._db.InsertLayer(layer_name.strip())
    return DmDbLayer._from_obj(cpp_result)

load(file_path)

加载本地数据库文件（底层调用源Load接口） :param file_path: 数据库文件路径（UTF-8编码，底层已处理编码转换） :return: 加载结果，成功返回True/0，失败返回False/错误码

example:

dmf = DmDbDatabase()
db = dmf.load('E:/dassistant/tests/123.dmf')
print(db)
Source code in dimine_python_sdk\lib\db\database.py 
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
def load(self, file_path: str) -> bool | int:
    """
    加载本地数据库文件（底层调用源Load接口）
    :param file_path: 数据库文件路径（UTF-8编码，底层已处理编码转换）
    :return: 加载结果，成功返回True/0，失败返回False/错误码

    example:
    ```python
    dmf = DmDbDatabase()
    db = dmf.load('E:/dassistant/tests/123.dmf')
    print(db)
    ```
    """
    if not isinstance(file_path, str) or not file_path.strip():
        raise ValueError("文件路径不能为空字符串")
    return self._db.Load(file_path)

save(file_path=None)

保存数据库（底层调用源Save重载接口，自动适配无参/有参） :param file_path: 可选保存路径，为None时保存到当前路径 :return: 保存结果，成功返回True/0，失败返回False/错误码

example:

dmf = DmDbDatabase()
db = dmf.load('E:/dassistant/tests/123.dmf')
layer = dmf.insert_layer("新图层")
print("插入新图层:",layer)
dmf.save("E:/dassistant/tests/123_1.dmf")
Source code in dimine_python_sdk\lib\db\database.py 
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
def save(self, file_path: str | None = None) -> bool | int:
    """
    保存数据库（底层调用源Save重载接口，自动适配无参/有参）
    :param file_path: 可选保存路径，为None时保存到当前路径
    :return: 保存结果，成功返回True/0，失败返回False/错误码

    example:
    ```python
    dmf = DmDbDatabase()
    db = dmf.load('E:/dassistant/tests/123.dmf')
    layer = dmf.insert_layer("新图层")
    print("插入新图层:",layer)
    dmf.save("E:/dassistant/tests/123_1.dmf")
    ```
    """
    if file_path is None:
        return self._db.Save()
    if not isinstance(file_path, str) or not file_path.strip():
        raise ValueError("保存路径不能为空字符串")
    return self._db.Save(file_path)

set_color(red, green, blue)

设置颜色（底层调用源SetColor接口） :param red: 红色通道值（0-255） :param green: 绿色通道值（0-255） :param blue: 蓝色通道值（0-255）

Source code in dimine_python_sdk\lib\db\database.py 
244
245
246
247
248
249
250
251
252
253
def set_color(self, red: int, green: int, blue: int) -> None:
    """
    设置颜色（底层调用源SetColor接口）
    :param red: 红色通道值（0-255）
    :param green: 绿色通道值（0-255）
    :param blue: 蓝色通道值（0-255）
    """
    if not (0 <= red <= 255) or not (0 <= green <= 255) or not (0 <= blue <= 255):
        raise ValueError("颜色值必须在0-255之间")
    self._db.SetColor(red, green, blue)

set_file_name(file_path)

设置数据库文件路径（底层调用源SetFileName接口） :param file_path: 数据库文件路径（UTF-8编码）

Source code in dimine_python_sdk\lib\db\database.py 
159
160
161
162
163
164
165
166
def set_file_name(self, file_path: str) -> None:
    """
    设置数据库文件路径（底层调用源SetFileName接口）
    :param file_path: 数据库文件路径（UTF-8编码）
    """
    if not isinstance(file_path, str) or not file_path.strip():
        raise ValueError("文件路径不能为空字符串")
    self._db.SetFileName(file_path)

switch_to_local_storage()

切换到本地存储模式（底层调用源SetToLocalStorage接口）

Source code in dimine_python_sdk\lib\db\database.py 
208
209
210
def switch_to_local_storage(self) -> None:
    """切换到本地存储模式（底层调用源SetToLocalStorage接口）"""
    self._db.SetToLocalStorage()

DmDbLayer

Source code in dimine_python_sdk\lib\db\database.py 
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
class DmDbLayer:
    def __init__(self):
        self._obj = Dm.dmDbLayer()

    def start_query_entity(self) -> None:
        """
        开始查询实体

        example:
        ```python
        dmf = DmDbDatabase()
        db = dmf.load('E:/dassistant/tests/123.dmf')
        print("获取图层数量:",dmf.get_layers_count())
        act_layer = dmf.get_active_layer()

        layerCount = dmf.get_layers_count()
        for i in range(layerCount):
            layer = dmf.get_layer_by_index(i)
            if layer is None:
                continue

            print("图层实体数量:",layer.get_entities_count())

            layer.start_query_entity()
            entity = layer.open_next_entity()
            while entity is not None:
                nType = entity.get_type()
                #print("实体类型:",nType)
                if nType == EntityType.ETT_POLYLINE:
                    ···
                entity = layer.open_next_entity()
        ```
        """
        self._obj.StartQueryEntity()

    def get_entities_count(self) -> int:
        """获取实体数量"""
        return self._obj.GetEntitiesCount()

    def open_next_entity(self) -> Optional[DmDbEntity]:
        """打开下一个实体，返回封装后的实体对象，无实体时返回 None"""
        raw_entity = self._obj.OpenNextEntity()
        if raw_entity:
            return DmDbEntity._from_obj(raw_entity)
        return None

    def insert_entity(self, entity: Union[DmDbEntity, DmDbPolyline]) -> None:
        """插入实体，支持 DmDbEntity 和 dmDbPolyline 类型"""
        self._obj.InsertEntity(entity._obj)

    def insert_polyline(self, points: List[DmDPoint]) -> DmDbEntity:
        """插入多段线，返回封装后的实体对象"""
        cpp_points = [p._obj for p in points]
        raw_entity = self._obj.InsertPolyline(cpp_points)
        return DmDbEntity._from_obj(raw_entity)

    def insert_shell(self,polyline: DmPolyData)->DmDbShell:
        polyline = self._obj.InsertShell(polyline)
        return DmDbShell._from_obj(polyline)

    def insert_line(self, start: DmDPoint, end: DmDPoint) -> DmDbEntity:
        """插入直线，返回封装后的实体对象"""
        raw_entity = self._obj.InsertLine(start._obj, end._obj)
        return DmDbEntity._from_obj(raw_entity)

    def set_work_plane_entity(self, work_plane: DmDbWorkPlane) -> None:
        """设置工作平面实体"""
        self._obj.SetWorkPlaneEntity(work_plane._obj)

    @classmethod
    def _from_obj(cls, obj):
        """
        原生dmDbLayer对象创建封装实例
        :param obj: 原生dmDbLayer对象（bind11封装后）
        :return: DmDbLayer实例
        """
        instance = cls.__new__(cls)
        instance._obj = obj
        return instance

get_entities_count()

获取实体数量

Source code in dimine_python_sdk\lib\db\database.py 
61
62
63
def get_entities_count(self) -> int:
    """获取实体数量"""
    return self._obj.GetEntitiesCount()

insert_entity(entity)

插入实体，支持 DmDbEntity 和 dmDbPolyline 类型

Source code in dimine_python_sdk\lib\db\database.py 
72
73
74
def insert_entity(self, entity: Union[DmDbEntity, DmDbPolyline]) -> None:
    """插入实体，支持 DmDbEntity 和 dmDbPolyline 类型"""
    self._obj.InsertEntity(entity._obj)

insert_line(start, end)

插入直线，返回封装后的实体对象

Source code in dimine_python_sdk\lib\db\database.py 
86
87
88
89
def insert_line(self, start: DmDPoint, end: DmDPoint) -> DmDbEntity:
    """插入直线，返回封装后的实体对象"""
    raw_entity = self._obj.InsertLine(start._obj, end._obj)
    return DmDbEntity._from_obj(raw_entity)

insert_polyline(points)

插入多段线，返回封装后的实体对象

Source code in dimine_python_sdk\lib\db\database.py 
76
77
78
79
80
def insert_polyline(self, points: List[DmDPoint]) -> DmDbEntity:
    """插入多段线，返回封装后的实体对象"""
    cpp_points = [p._obj for p in points]
    raw_entity = self._obj.InsertPolyline(cpp_points)
    return DmDbEntity._from_obj(raw_entity)

open_next_entity()

打开下一个实体，返回封装后的实体对象，无实体时返回 None

Source code in dimine_python_sdk\lib\db\database.py 
65
66
67
68
69
70
def open_next_entity(self) -> Optional[DmDbEntity]:
    """打开下一个实体，返回封装后的实体对象，无实体时返回 None"""
    raw_entity = self._obj.OpenNextEntity()
    if raw_entity:
        return DmDbEntity._from_obj(raw_entity)
    return None

set_work_plane_entity(work_plane)

设置工作平面实体

Source code in dimine_python_sdk\lib\db\database.py 
91
92
93
def set_work_plane_entity(self, work_plane: DmDbWorkPlane) -> None:
    """设置工作平面实体"""
    self._obj.SetWorkPlaneEntity(work_plane._obj)

start_query_entity()

开始查询实体

example:

dmf = DmDbDatabase()
db = dmf.load('E:/dassistant/tests/123.dmf')
print("获取图层数量:",dmf.get_layers_count())
act_layer = dmf.get_active_layer()

layerCount = dmf.get_layers_count()
for i in range(layerCount):
    layer = dmf.get_layer_by_index(i)
    if layer is None:
        continue

    print("图层实体数量:",layer.get_entities_count())

    layer.start_query_entity()
    entity = layer.open_next_entity()
    while entity is not None:
        nType = entity.get_type()
        #print("实体类型:",nType)
        if nType == EntityType.ETT_POLYLINE:
            ···
        entity = layer.open_next_entity()
Source code in dimine_python_sdk\lib\db\database.py 
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
def start_query_entity(self) -> None:
    """
    开始查询实体

    example:
    ```python
    dmf = DmDbDatabase()
    db = dmf.load('E:/dassistant/tests/123.dmf')
    print("获取图层数量:",dmf.get_layers_count())
    act_layer = dmf.get_active_layer()

    layerCount = dmf.get_layers_count()
    for i in range(layerCount):
        layer = dmf.get_layer_by_index(i)
        if layer is None:
            continue

        print("图层实体数量:",layer.get_entities_count())

        layer.start_query_entity()
        entity = layer.open_next_entity()
        while entity is not None:
            nType = entity.get_type()
            #print("实体类型:",nType)
            if nType == EntityType.ETT_POLYLINE:
                ···
            entity = layer.open_next_entity()
    ```
    """
    self._obj.StartQueryEntity()

data_database_conn(file_path)

几何数据库连接上下文管理器

Source code in dimine_python_sdk\lib\db\database.py 
280
281
282
283
284
285
286
287
288
289
@contextmanager
def data_database_conn(file_path: str) -> Generator[DmDbDatabase, None, None]:
    """
    几何数据库连接上下文管理器
    """
    db = DmDbDatabase(file_path)
    try:
        yield db
    finally:
        pass