buildz 0.6.33__tar.gz → 0.6.35__tar.gz

{buildz-0.6.33/buildz.egg-info → buildz-0.6.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.6.33
+Version: 0.6.35
 Summary: 配置读写（基于json格式进行简化）、ioc、以及其他工具代码。a json-base file format's read and write code by python, and codes to read and product object from configure file in such format(ioc), and other tool codes
 Home-page: https://github.com/buildCodeZ/buildz
 Author: Zzz
@@ -34,6 +34,8 @@ License-File: LICENSE
 运行python -m buildz查看帮助
 
 持续更新中。。。
+2024/12/18:
+增加数据映射xz，数据库db增加类似orm功能以及表和索引结构查询功能（目前只写了mysql,oracle,sqlite3的查询），配置文件读写xf的输出增加对ListMap的支持(dumpx, dumpxf)
 2024/11/11:
 新增buildz.tz.xfind，对json做查询用的，功能类似jsonpath，自己实现的原因是好玩，以及不想为了用jsonpath去学对应的语法
 2024/10/08:

{buildz-0.6.33 → buildz-0.6.35}/README.md

@@ -21,6 +21,8 @@
 运行python -m buildz查看帮助
 
 持续更新中。。。
+2024/12/18:
+增加数据映射xz，数据库db增加类似orm功能以及表和索引结构查询功能（目前只写了mysql,oracle,sqlite3的查询），配置文件读写xf的输出增加对ListMap的支持(dumpx, dumpxf)
 2024/11/11:
 新增buildz.tz.xfind，对json做查询用的，功能类似jsonpath，自己实现的原因是好玩，以及不想为了用jsonpath去学对应的语法
 2024/10/08:

{buildz-0.6.33 → buildz-0.6.35}/buildz/__init__.py

@@ -1,6 +1,6 @@
 #coding=utf-8
 
-__version__="0.6.31"
+__version__="0.6.34"
 
 # 小号多
 __author__ = "Zzz, emails: 1174534295@qq.com, 1309458652@qq.com"

buildz-0.6.35/buildz/db/__init__.py

@@ -0,0 +1,4 @@
+
+from .tls import *
+from .dv import orm
+from .runz import cmd, make

{buildz-0.6.33 → buildz-0.6.35}/buildz/db/dv/basez.py

@@ -1,6 +1,7 @@
 import sys
 from .structz import ItDv
 from buildz.db import tls
+from buildz import xf
 def sp(obj):
     return super(obj.__class__, obj)
 
@@ -9,21 +10,71 @@ class SimpleDv(ItDv):
     # func to impl:
     def to_list(self, query_result):
         return []
-    def sql_tables(self):
-        return "select TABLE_NAME tableName,TABLE_COMMENT comemnt,TABLE_ROWS dataNums from information_schema.tables where table_schema='"+self.db+"'"
+    def sql_tables(self, table = None):
+        """
+            if not note, use name instead
+            require:
+                table_name, table_note
+        """
+        raise Exception("unimplement")
+        return None
+    def sql_columns(self, table):
+        """
+            require:
+                table_name, column_name, column_type, column_default, nullable, column_offset, column_note
+        """
+        raise Exception("unimplement")
+        return None
+    def sql_indexes(self, table=None):
+        """
+            require:
+                table_name, index_name, is_unique, index_type, index_note
+        """
+        raise Exception("unimplement")
+        return None
+    def sql_index_keys(self, table, index):
+        """
+            require:
+                table_name, index_name, column_name, index_offset, column_note
+        """
+        raise Exception("unimplement")
+        return None
     def new_con(self):
         return None
     def new_cursor(self):
         return None
     def init(self, *argv, **maps):
         pass
+    def tables(self, table=None, as_map=None):
+        sql = self.sql_tables(table)
+        return self.query(sql, as_map=as_map)
+    def columns(self, table, as_map=None):
+        sql = self.sql_columns(table)
+        return self.query(sql, as_map=as_map)
+    def indexes(self, table=None, index=None, as_map=None):
+        sql = self.sql_indexes(table, index)
+        return self.query(sql, as_map=as_map)
+    def index_keys(self, table, index, as_map=None):
+        sql = self.sql_index_keys(table, index)
+        return self.query(sql, as_map=as_map)
     # func already impl
     def check_query(self, s):
         arr = s.split(" ")
         k = arr[0].strip().lower()
-        rst = k not in "delete,insert,update,create,drop,commit".split(",")
+        rst = k not in "delete,insert,update,create,drop,commit,alter".split(",")
+        return rst
+    def out_list(self, query_result, as_map=None):
+        if as_map is None:
+            as_map = self.as_map
+        rst = self.to_list(query_result)
+        if as_map and len(rst)>0:
+            if len(rst)==1:
+                return []
+            keys = rst[0]
+            rst = rst[1:]
+            rst = [{k:v for k,v in zip(keys, dt)} for dt in rst]
         return rst
-    def __init__(self, host, port, user, pwd, db, *argv, **maps):
+    def __init__(self, host, port, user, pwd, db, as_map=False, *argv, **maps):
         self.host = host
         self.port = port
         self.user = user
@@ -31,10 +82,13 @@ class SimpleDv(ItDv):
         self.db = db
         self.con = None
         self.cursor = None
+        self.as_map = as_map
         self.init(*argv, **maps)
     def begin(self):
         self.con = self.new_con()
         self.cursor = self.new_cursor()
+    def open(self):
+        self.begin()
     def close(self):
         self.cursor.close()
         self.con.close()
@@ -49,14 +103,23 @@ class SimpleDv(ItDv):
     def refresh(self):
         self.cursor.close()
         self.cursor = self.new_cursor()
-    def query(self, sql, vals=()):
+    def query(self, sql, vals=(), as_map = None):
         # return list, first row is key
         tmp = self.cursor.execute(sql, vals)
         #print("[TESTZ] exe:",tmp)
         rst = self.cursor.fetchall()
-        return self.to_list(rst)
-    def execute(self, sql, vals=()):
+        return self.out_list(rst, as_map)
+    def executes(self, sqls, commit=False):
+        if type(sqls)==str:
+            sqls = sqls.split(";")
+        sqls = [sql.strip() for sql in sqls if sql.strip()!=""]
+        _ = [self.execute(sql) for sql in sqls]
+        if commit:
+            self.execute("commit;")
+    def execute(self, sql, vals=(), commit=False):
         tmp = self.cursor.execute(sql, vals)
+        if commit:
+            self.cursor.execute("commit;")
         return tmp
     def insert_or_update(self, maps, table, keys = None):
         if type(maps)!=dict:
@@ -77,7 +140,7 @@ class SimpleDv(ItDv):
                 v = maps[k]
                 if type(v)==str:
                     v = f"'{v}'"
-                if v not is None:
+                if v is not None:
                     cond = f"{k} = {v}"
                 else:
                     cond = f"{k} is null"
@@ -85,25 +148,25 @@ class SimpleDv(ItDv):
             if need_query:
                 conds = " and ".join(conds)
                 sql_search = f"select count(*) from {table} where {conds}"
-                rst = self.query(sql_search)[1][0]
+                rst = self.query(sql_search, as_map = False)[1][0]
                 update = rst>0
         if update:
             keys = set(keys)
             kvs = [[k,tls.py2sql(v)] for k,v in maps.items() if k not in keys]
-            sets = [f"{k}={v}"]
+            sets = [f"{k}={v}" for k,v in kvs]
             sets = ",".join(sets)
             sql = f"update {table} set {sets} where {conds}"
         else:
-            kvs = [k, tls.py2sql(v) for k,v in maps.items()]
+            kvs = [[k, tls.py2sql(v)] for k,v in maps.items()]
             ks = ",".join([kv[0] for kv in kvs])
-            vs = ",".join([kv[1] for kv in kvs])
+            vs = ",".join([str(kv[1]) for kv in kvs])
             sql = f"insert into {table}({ks}) values({vs});"
         return self.execute(sql)
 
 pass
 
 # user|pwd@host:port/db
-def fetch(args):
+def fetch(args, conf={}):
     """
         host[:port][/db][ user][ pwd]
         host:port/db user pwd
@@ -133,6 +196,7 @@ def fetch(args):
         pwd = args[2]
         if pwd is not None:
             pwd = pwd.strip()
-    return host, port, user, pwd, db
+    as_map = xf.g(conf, as_map=False)
+    return host, port, user, pwd, db, as_map
 
 pass

buildz-0.6.35/buildz/db/dv/mysqlz.py

@@ -0,0 +1,73 @@
+try:
+    import pymysql
+except ModuleNotFoundError:
+    raise Exception("module not found, try: pip install pymysql")
+import sys
+from .basez import SimpleDv, fetch
+from .structz import CMD
+class Db(SimpleDv):
+    # func to impl:
+    def to_list(self, rst):
+        result = []
+        if rst is None or len(rst)==0:
+            return result
+        a = rst[0]
+        keys = list(a.keys())
+        result.append(keys)
+        for obj in rst:
+            v = [obj[k] for k in keys]
+            result.append(v)
+        return result
+    def new_con(self):
+        return pymysql.connect(host=self.host, 
+            port = self.port, user =self.user, 
+            password =self.pwd, database = self.db,
+            charset='utf8',init_command="SET SESSION time_zone='+08:00'")
+    def new_cursor(self):
+        return self.con.cursor(pymysql.cursors.DictCursor)
+    def init(self, *argv, **maps):
+        if self.port is None:
+            self.port = 3306
+        pass
+    def sql_tables(self, table = None):
+        """
+            if not note, use name instead
+            require:
+                table_name, table_note
+        """
+        query_table = ""
+        if table is not None:
+            query_table =  f" and table_name = '{table}'"
+        return f"select table_name, table_comment as table_note from information_schema.tables where table_schema='{self.db}' {query_table};"
+    def sql_columns(self, table):
+        """
+            require:
+                table_name, column_name, column_type, column_default, nullable, column_offset, column_note
+        """
+        return f"select table_name, column_name, column_type, column_default, is_nullable as nullable, ordinal_position as column_offset, column_comment as column_note from information_schema.columns where table_schema='{self.db}' and table_name = '{table}' order by ordinal_position asc;"
+    def sql_indexes(self, table=None, index=None):
+        """
+            require:
+                table_name, index_name, is_unique, index_type, index_note
+        """
+        query_table = ""
+        if table is not None:
+            query_table =  f" and table_name = '{table}'"
+            if index is not None:
+                query_table+= f" and index_name='{index}'"
+        return f"select table_name, index_name, 1-any_value(non_unique) as is_unique, any_value(index_type) as index_type, any_value(index_comment) as index_note from information_schema.statistics where table_schema='{self.db}' {query_table} group by index_name;"
+    def sql_index_keys(self, table, index):
+        """
+            require:
+                table_name, index_name, column_name, index_offset, column_note
+        """
+        return f"select table_name, index_name, column_name, seq_in_index as index_offset, comment as column_note from information_schema.statistics where table_name='{table}' and table_schema='{self.db}' and index_name = '{index}' order by seq_in_index asc;"
+
+pass
+def build(argv, conf):
+    dv = Db(*fetch(argv))
+    return dv
+def buildbk(argv, conf):
+    return CMD(make(argv, conf))
+
+pass

buildz-0.6.35/buildz/db/dv/oraclez.py

@@ -0,0 +1,94 @@
+
+import os
+import sys
+dp = os.path.dirname(__file__)
+gdp = os.path.join(dp, "lib")
+
+def init_path(dp):
+    path = os.environ["PATH"] 
+    if sys.platform.lower().find("win")>=0:
+        cb = ";"
+    else:
+        cb = ":"
+    path = path +cb+dp
+    os.environ["PATH"] = path
+
+pass
+
+#init_path(dp)
+import sys
+from .basez import SimpleDv, fetch
+from .structz import CMD
+class Db(SimpleDv):
+    # func to impl:
+    def to_list(self, rst):
+        rows = self.cursor.description
+        keys = [k[0].lower() for k in rows]
+        result = []
+        result.append(keys)
+        if rst is None or len(rst)==0:
+            return result
+        result += rst
+        return result
+    def new_con(self):
+        if self.port is not None:
+            add = ":"+str(self.port)
+        else:
+            add = ""
+        try:
+            import cx_Oracle as pymysql
+        except ModuleNotFoundError:
+            raise Exception("module not found, try: pip install cx-Oracle")
+        return pymysql.connect(self.user, self.pwd, self.host+add+"/"+self.db)
+    def new_cursor(self):
+        return self.con.cursor()
+    def init(self, *argv, **maps):
+        pass
+    def sql_tables(self, table = None):
+        """
+            if not note, use name instead
+            require:
+                table_name, table_note
+        """
+        query_table = ""
+        if table is not None:
+            query_table =  f" and t.table_name = '{table.upper()}'"
+        return f"select t.table_name as table_name, tc.comments as table_note from all_tables t inner join all_tab_comments tc on t.table_name=tc.table_name where t.owner='{self.user.upper()}' {query_table}"
+    def sql_columns(self, table):
+        """
+            require:
+                table_name, column_name, column_type, column_default, nullable, column_offset, column_note
+        """
+        return f"select c.table_name as table_name, c.column_name as column_name, c.data_type|| '(' ||c.data_length||','||c.data_precision||','||c.data_scale||')' as column_type, c.data_default as column_default, c.nullable as nullable, c.column_id as column_offset, cc.comments as column_note from all_tab_columns c inner join all_col_comments cc on c.column_name=cc.column_name and c.table_name=cc.table_name where c.table_name='{table.upper()}' order by c.column_id asc"
+    def sql_indexes(self, table=None, index=None):
+        """
+            require:
+                table_name, index_name, is_unique, index_type, index_note
+        """
+        query_table = ""
+        if table is not None:
+            query_table =  f" and table_name = '{table.upper()}'"
+            if index is not None:
+                query_table+= f" and index_name='{index.upper()}'"
+        return f"select table_name, index_name,  case uniqueness when 'UNIQUE' then 1 else 0 end as is_unique, index_type, '' as index_note from all_indexes where owner = '{self.user.upper()}'{query_table}"
+    def sql_index_keys(self, table, index):
+        """
+            require:
+                table_name, index_name, column_name, index_offset, column_note
+        """
+        return f"select table_name, index_name, column_name, column_position as index_offset, '' as note from all_ind_columns where index_name='{index.upper()}' and table_name='{table.upper()}' order by column_position asc"
+
+pass
+def build(argv, conf):
+    k = 'oracle_lib'
+    dp = gdp
+    if k in conf:
+        dp = conf[k]
+    init_path(dp)
+    #print(f"oracle lib: {dp}")
+    dv = Db(*fetch(argv))
+    return dv
+def buildbk(argv, conf):
+    return CMD(make(argv, conf))
+
+pass

buildz-0.6.35/buildz/db/dv/orm.py

@@ -0,0 +1,194 @@
+#coding=utf-8
+
+from buildz import Base
+from buildz.db import tls
+from buildz import xf
+def dict2list(data):
+    rst = []
+    for k,v in data.items():
+        if type(v) not in (list, tuple):
+            v = [v]
+        tmp = [k]+list(v)
+        rst.append(tmp)
+    return rst
+def deal_item(item, conf):
+    key = item[0]
+    if key in "sql_before,sql_after,sql_delete_before,sql_delete_after".split(","):
+        conf[key].append(item[1])
+    else:
+        conf[key] = item[1]
+def deal_key(it, conf):
+    data_keys = xf.g(conf, data_keys=[])
+    tmp = {}
+    for i in range(min(len(it), len(data_keys))):
+        tmp[data_keys[i]] = it[i]
+    sql_key = tmp['sql_key']
+    sql_def = tmp['sql_def']
+    py_key = xf.g(tmp, py_key=None)
+    if py_key is not None:
+        xf.g(conf, py2sqls={})[py_key] = sql_key
+    xf.g(conf, keys=[]).append(sql_key)
+    xf.g(conf, vars=[]).append(sql_key+" "+sql_def)
+def makes(datas, data_keys = "sql_key,sql_def,py_key".split(",")):
+    if type(datas)==dict:
+        rst = [make(v, k) for k,v in datas.items()]
+    else:
+        rst = [make(it) for it in datas]
+    return rst
+def make(data, table=None, data_keys = "sql_key,sql_def,py_key".split(",")):
+    """
+        从配置中生成建表语句，删表语句和orm对象
+        输入:
+            data: dict or list
+                dict: {
+                    (其他配置)
+                    (其他配置)
+                    表字段: [sql字段定义, 转py后字段名]
+                    表字段: sql字段定义
+                }
+                list: [
+                    ((其他配置))
+                    ((其他配置))
+                    [表字段, sql字段定义, 转py后字段名]
+                    [表字段, sql字段定义]
+                ]
+                其他配置:
+                    格式: key, val
+                    key:
+                        table: 表名
+                        query_keys: 默认null，orm做插入/更新时，判断数据是插入还是更新的查询方式
+                        auto_translate: 默认true，如果没有配置“转py后字段名”，是否自动转(a_b=>aB)
+                        sql_before: 新增一条建表前sql语句
+                        sql_after: 新增一条建表后sql语句
+                        sql_delete_before: 新增一条删表前sql语句
+                        sql_delete_after: 新增一条删表后sql语句
+                        data_keys: 默认[sql_key, sql_def, py_key]，非配置项怎么解析，不建议改
+            table: 表名
+        输出:
+            [[sql_create, sql_delete], orm_obj]
+    """
+    if xf.is_args(data):
+        confs = data.lists
+        confs =[[it] for it in confs]
+        data = dict2list(data.maps)
+        data = confs+data
+    elif type(data) == dict:
+        data = dict2list(data)
+    conf = {}
+    xf.s(conf, sql_before = [], sql_after = [], sql_delete_before=[], sql_delete_after=[],auto_translate=True,table=table,keys=[],py2sqls={},query_keys=None, data_keys = data_keys, vars=[])
+    for it in data:
+        if len(it)==1 and type(it[0]) in (list, tuple):
+            deal_item(it[0], conf)
+        else:
+            deal_key(it, conf)
+    table = xf.g(conf, table=table)
+    vars =  xf.g(conf, vars = [])
+    vars = ",".join(vars)
+    assert table is not None
+    sql = f"create table if not exists {table}({vars})"
+    sql_del = f"drop table if exists {table}"
+    sqls = xf.g(conf, sql_before=[], sql_after=[], sql_delete_before=[], sql_delete_after=[])
+    #sqls = [";".join(k) for k in sqls]
+    sqls_crt = sqls[0]+[sql]+sqls[1]
+    sqls_del = sqls[2]+[sql_del]+sqls[3]
+    sqls = [sqls_crt, sqls_del]
+    sqls = [(";\n".join(k)+";").replace(";;",";") for k in sqls]
+    obj = TableObject(*xf.g(conf, keys=[], table=table, py2sqls = None, query_keys=None,auto_translate=True), sql_create = sqls[0], sql_delete = sqls[1])
+    return sqls, obj
+
+pass
+
+class TableObject(Base):
+    """
+        字段映射
+        keys: 表字段
+        table: 表名
+        py2sqls: 自定义映射
+        query_keys: 唯一索引（判断数据重复）
+        auto_translate:
+            对于没有在py2sqls自定义映射的表字段，是否自动转换(py|autoTran<=>auto_tran|sql)
+    """
+    def init(self, keys, table=None, py2sqls=None, query_keys=None, auto_translate=True, dv = None, sql_create=None, sql_delete=None):
+        if table is None:
+            table = tls.lower(self.__class__.__name__)
+        self.table = table
+        if py2sqls is None:
+            py2sqls = {}
+        if type(py2sqls) in (list, tuple):
+            py2sqls = {k[0]:k[1] for k in py2sqls}
+        sql2pys = {}
+        for k_py, k_sql in py2sqls.items():
+            sql2pys[k_sql] = k_py
+        for key in keys:
+            if key not in sql2pys:
+                k_py, k_sql = key,key
+                if auto_translate:
+                    k_py,k_sql = tls.upper(key), tls.lower(key)
+                py2sqls[k_py] = k_sql
+                sql2pys[k_sql] = k_py
+        self.py2sqls = py2sqls
+        self.sql2pys = sql2pys
+        self.keys = keys
+        if query_keys is None:
+            query_keys = []
+        self.query_keys = query_keys
+        self.dv = dv
+        self.py2sql=self.toSql
+        self.sql2py = self.toPy
+        self.sql_create = sql_create
+        self.sql_delete = sql_delete
+    def create(self, dv=None):
+        assert self.sql_create is not None
+        dv = self.rdv(dv)
+        dv.executes(self.sql_create)
+    def delete(self, dv=None):
+        assert self.sql_delete is not None
+        self.rdv(dv).execute(self.sql_delete)
+    def bind(self, dv):
+        self.dv = dv
+    def toSql(self, obj):
+        if type(obj)!=dict:
+            tmp = {}
+            for k in self.py2sqls:
+                if hasattr(obj, k):
+                    tmp[k] = getattr(obj, k)
+            obj = tmp
+        obj = {self.py2sqls[k]:v for k,v in obj.items()}
+        return obj
+    def toPy(self, obj):
+        if type(obj)!=dict:
+            tmp = {}
+            for k in self.sql2pys:
+                if hasattr(obj, k):
+                    tmp[k] = getattr(obj, k)
+            obj = tmp
+        obj = {self.sql2pys[k]:v for k,v in obj.items()}
+        return obj
+    def rdv(self, dv):
+        if dv is None:
+            dv = self.dv
+        assert dv is not None
+        return dv
+    def query(self, sql, dv=None, sql2py=True):
+        dv=self.rdv(dv)
+        rst = dv.query(sql, as_map=1)
+        if sql2py:
+            rst = [self.sql2py(it) for it in rst]
+        return rst
+    def queryAll(self, dv=None, sql2py=True):
+        sql = f"select * from {self.table};"
+        return self.query(sql, dv, sql2py)
+    def save(self, obj, dv=None, py2sql = True, commit=False, check = True):
+        dv = self.rdv(dv)
+        if type(obj) not in [list, tuple]:
+            obj = [obj]
+        if py2sql:
+            obj = [self.toSql(k) for k in obj]
+        query_keys = self.query_keys
+        if not check:
+            query_keys = None
+        _ = [dv.insert_or_update(k, self.table, query_keys) for k in obj]
+        if commit:
+            dv.execute("commit;")
+        return _
+

buildz-0.6.35/buildz/db/dv/sqlite3z.py

@@ -0,0 +1,105 @@
+
+import sqlite3
+import sys,os
+from .basez import SimpleDv, fetch
+from .structz import CMD
+from buildz import xf,fz
+class Db(SimpleDv):
+    # func to impl:
+    def to_list(self, rst):
+        rows = self.cursor.description
+        keys = [k[0].lower() for k in rows]
+        result = []
+        result.append(keys)
+        if rst is None or len(rst)==0:
+            return result
+        result += rst
+        return result
+    def new_con(self):
+        return sqlite3.connect(self.fp)
+    def new_cursor(self):
+        return self.con.cursor()
+    def __init__(self, fp, as_map=False, *argv, **maps):
+        #def __init__(self, fp):
+        self.con = None
+        self.cursor = None
+        self.as_map = as_map
+        self.init(fp)
+    def init(self, fp):
+        fz.makefdir(fp)
+        self.fp = fp
+    def sql_tables(self, table = None):
+        """
+            if not note, use name instead
+            require:
+                table_name, table_note
+        """
+        query_table = ""
+        if table is not None:
+            query_table =  f" and name = '{table}'"
+        return f"select name as table_name, '' as table_note from sqlite_master where type='table' {query_table};"
+    def sql_indexes(self, table=None, index=None):
+        """
+            require:
+                table_name, index_name, is_unique, index_type, index_note
+        """
+        query_table = ""
+        if table is not None:
+            query_table =  f" and tbl_name = '{table}'"
+            if index is not None:
+                query_table+= f" and name='{index}'"
+        return f"select tbl_name as table_name, name as index_name, -1 as is_unique, '?' as index_type, '' as index_note from sqlite_master where type='index' {query_table};"
+    def columns(self, table, as_map=None):
+        """
+            require:
+                table_name, column_name, column_type, column_default, nullable, column_offset, column_note
+        """
+        rst = self.query(f"PRAGMA table_info({table})", as_map=0)
+        dts = rst[1:]
+        keys = "table_name, column_name, column_type, column_default, nullable, column_offset, column_note".split(", ")
+        rst = [keys]
+        for dt in dts:
+            cid, name, _type, notnull, dflt_value, pk = dt
+            tmp = [table, name, _type, dflt_value, notnull, cid, '']
+            rst.append(tmp)
+        rst = self.out_list_sqlite3(rst, as_map)
+        return rst
+    def index_keys(self, table, index, as_map=None):
+        """
+            require:
+                table_name, index_name, column_name, index_offset, column_note
+        """
+        rst = self.query(f"PRAGMA index_info({index})", as_map=0)
+        dts = rst[1:]
+        keys = "table_name, index_name, column_name, index_offset, column_note".split(", ")
+        rst = [keys]
+        for dt in dts:
+            seqno, cid, name = dt
+            tmp = [table, index, name, seqno, '']
+            rst.append(tmp)
+        return self.out_list_sqlite3(rst, as_map)
+    def out_list_sqlite3(self, query_result, as_map=None):
+        if as_map is None:
+            as_map = self.as_map
+        rst = query_result
+        if as_map and len(rst)>0:
+            if len(rst)==1:
+                return []
+            keys = rst[0]
+            rst = rst[1:]
+            rst = [{k:v for k,v in zip(keys, dt)} for dt in rst]
+        return rst
+
+pass
+def build(argv, conf):
+    root = xf.g(conf, root=None)
+    fp = argv[0]
+    if root is not None:
+        fp = os.path.join(root, fp)
+    as_map = xf.g(conf, as_map=False)
+    dv = Db(fp, as_map)
+    return dv
+def buildbk(argv, conf):
+    return CMD(make(argv, conf))
+
+pass