fix: upgrade bug. completed by xuxiuxi

zhangzengfei

2020-03-31 0ce893695d32ab686f9e2309509e80c6feb0d380

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
105
106
107
108
109
110
111
112
113
114
115
package com.basic.security.manager.erlang;
 
import android.database.SQLException;
 
import com.basic.security.manager.DatabaseManager;
import com.basic.security.utils.Constants;
import com.basic.security.utils.DateUtil;
import com.ericsson.otp.erlang.OtpConnection;
import com.ericsson.otp.erlang.OtpErlangList;
import com.ericsson.otp.erlang.OtpErlangObject;
import com.ericsson.otp.erlang.OtpErlangString;
import com.ericsson.otp.erlang.OtpErlangTuple;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
 
public class SqliteManager {
 
    public static List<Map<String, String>> queryFromSync(OtpConnection connection, String sql) {
        return query(connection, sql, Constants.syncDatabasePath);
    }
 
    public static void executeInSync(OtpConnection connection, String sql) {
        execute(connection, sql, Constants.syncDatabasePath);
    }
 
    public static List<Map<String, String>> queryFromCache(OtpConnection connection, String sql) {
        return query(connection, sql, Constants.cacheDatabasePath);
    }
 
    public static void executeInCache(OtpConnection connection, String sql) {
        String sqlCacheInsertSql = "INSERT INTO SqlCache " +
                "(uuid, func, sql, create_by,create_time) " +
                "values (\"" + UUID.randomUUID().toString() + "\",\"test\" ,\"" +
                sql + "\",\"" + Constants.erlangLocalNode + "\",\"" + DateUtil.getDateTimeStrFull() + "\");";
        execute(connection, sqlCacheInsertSql, Constants.cacheDatabasePath);
    }
 
    public static void executeConfirmInCache(OtpConnection connection, String sql) {
        execute(connection, sql, Constants.cacheDatabasePath);
    }
 
    public static void execute(OtpConnection connection, String sql, String databaseName) {
        if (ErlangProcess.erlangProcessCanStart) {
            try {
                if (connection != null && connection.isConnected()) {
                    connection.sendRPC("sqlite", "execute", new OtpErlangObject[]{
                            new OtpErlangString(sql),
                            new OtpErlangString(databaseName),
                            new OtpErlangString(UUID.randomUUID().toString())
                    });
                    OtpErlangObject oeo = connection.receive();
//                System.out.println("SqliteManager execute " + oeo);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            try {
                DatabaseManager.getDatabase(databaseName).execSQL(sql);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
 
    private static List<Map<String, String>> query(OtpConnection connection, String sql, String databaseName) {
        List<Map<String, String>> dataRowList = new ArrayList<>();
        try {
            if (connection != null && connection.isConnected()) {
                connection.sendRPC("sqlite", "query", new OtpErlangObject[]{
                        new OtpErlangString(sql),
                        new OtpErlangString(databaseName)
                });
                OtpErlangObject oeo = connection.receive();
                if (oeo instanceof OtpErlangTuple) {
                    OtpErlangTuple oet = (OtpErlangTuple) oeo;
                    OtpErlangObject[] elems = oet.elements();
                    if (elems.length == 2 && elems[1] instanceof OtpErlangList) {
                        OtpErlangList oel = (OtpErlangList) elems[1];
                        OtpErlangObject[] rows = oel.elements();
                        for (OtpErlangObject row : rows) {
                            Map<String, String> dataRow = new HashMap<>();
                            if (row instanceof OtpErlangList) {
                                OtpErlangObject[] columns = ((OtpErlangList) row).elements();
                                for (OtpErlangObject column : columns) {
                                    if (column instanceof OtpErlangTuple) {
                                        OtpErlangObject[] theColumn = ((OtpErlangTuple) column).elements();
                                        if (theColumn.length == 2 && theColumn[0] instanceof OtpErlangString
                                                && theColumn[1] instanceof OtpErlangString) {
                                            String key = ((OtpErlangString) theColumn[0]).stringValue();
                                            String value = ((OtpErlangString) theColumn[1]).stringValue();
                                            dataRow.put(key, value);
                                        }
                                    }
                                }
                            }
                            if (dataRow.size() > 0) {
                                dataRowList.add(dataRow);
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return dataRowList;
    }
 
 
}