EMMA Coverage Report (generated Sun Mar 01 22:06:14 CET 2015)
[all classes][org.h2.command]

COVERAGE SUMMARY FOR SOURCE FILE [CommandRemote.java]

nameclass, %method, %block, %line, %
CommandRemote.java100% (1/1)100% (14/14)92%  (557/607)91%  (131.9/145)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class CommandRemote100% (1/1)100% (14/14)92%  (557/607)91%  (131.9/145)
getMetaData (): ResultInterface 100% (1/1)78%  (71/91)77%  (14.6/19)
close (): void 100% (1/1)80%  (69/86)79%  (17.4/22)
executeQuery (int, boolean): ResultInterface 100% (1/1)89%  (107/120)86%  (25/29)
CommandRemote (SessionRemote, ArrayList, String, int): void 100% (1/1)100% (30/30)100% (10/10)
cancel (): void 100% (1/1)100% (6/6)100% (2/2)
checkParameters (): void 100% (1/1)100% (15/15)100% (4/4)
executeUpdate (): int 100% (1/1)100% (85/85)100% (21/21)
getCommandType (): int 100% (1/1)100% (2/2)100% (1/1)
getParameters (): ArrayList 100% (1/1)100% (3/3)100% (1/1)
isQuery (): boolean 100% (1/1)100% (3/3)100% (1/1)
prepare (SessionRemote, boolean): void 100% (1/1)100% (103/103)100% (22/22)
prepareIfRequired (): void 100% (1/1)100% (26/26)100% (6/6)
sendParameters (Transfer): void 100% (1/1)100% (25/25)100% (6/6)
toString (): String 100% (1/1)100% (12/12)100% (1/1)

1/*
2 * Copyright 2004-2014 H2 Group. Multiple-Licensed under the MPL 2.0,
3 * and the EPL 1.0 (http://h2database.com/html/license.html).
4 * Initial Developer: H2 Group
5 */
6package org.h2.command;
7 
8import java.io.IOException;
9import java.util.ArrayList;
10import org.h2.engine.SessionRemote;
11import org.h2.engine.SysProperties;
12import org.h2.expression.ParameterInterface;
13import org.h2.expression.ParameterRemote;
14import org.h2.message.DbException;
15import org.h2.message.Trace;
16import org.h2.result.ResultInterface;
17import org.h2.result.ResultRemote;
18import org.h2.util.New;
19import org.h2.value.Transfer;
20import org.h2.value.Value;
21 
22/**
23 * Represents the client-side part of a SQL statement.
24 * This class is not used in embedded mode.
25 */
26public class CommandRemote implements CommandInterface {
27 
28    private final ArrayList<Transfer> transferList;
29    private final ArrayList<ParameterInterface> parameters;
30    private final Trace trace;
31    private final String sql;
32    private final int fetchSize;
33    private SessionRemote session;
34    private int id;
35    private boolean isQuery;
36    private boolean readonly;
37    private final int created;
38 
39    public CommandRemote(SessionRemote session,
40            ArrayList<Transfer> transferList, String sql, int fetchSize) {
41        this.transferList = transferList;
42        trace = session.getTrace();
43        this.sql = sql;
44        parameters = New.arrayList();
45        prepare(session, true);
46        // set session late because prepare might fail - in this case we don't
47        // need to close the object
48        this.session = session;
49        this.fetchSize = fetchSize;
50        created = session.getLastReconnect();
51    }
52 
53    private void prepare(SessionRemote s, boolean createParams) {
54        id = s.getNextId();
55        for (int i = 0, count = 0; i < transferList.size(); i++) {
56            try {
57                Transfer transfer = transferList.get(i);
58                if (createParams) {
59                    s.traceOperation("SESSION_PREPARE_READ_PARAMS", id);
60                    transfer.
61                        writeInt(SessionRemote.SESSION_PREPARE_READ_PARAMS).
62                        writeInt(id).writeString(sql);
63                } else {
64                    s.traceOperation("SESSION_PREPARE", id);
65                    transfer.writeInt(SessionRemote.SESSION_PREPARE).
66                        writeInt(id).writeString(sql);
67                }
68                s.done(transfer);
69                isQuery = transfer.readBoolean();
70                readonly = transfer.readBoolean();
71                int paramCount = transfer.readInt();
72                if (createParams) {
73                    parameters.clear();
74                    for (int j = 0; j < paramCount; j++) {
75                        ParameterRemote p = new ParameterRemote(j);
76                        p.readMetaData(transfer);
77                        parameters.add(p);
78                    }
79                }
80            } catch (IOException e) {
81                s.removeServer(e, i--, ++count);
82            }
83        }
84    }
85 
86    @Override
87    public boolean isQuery() {
88        return isQuery;
89    }
90 
91    @Override
92    public ArrayList<ParameterInterface> getParameters() {
93        return parameters;
94    }
95 
96    private void prepareIfRequired() {
97        if (session.getLastReconnect() != created) {
98            // in this case we need to prepare again in every case
99            id = Integer.MIN_VALUE;
100        }
101        session.checkClosed();
102        if (id <= session.getCurrentId() - SysProperties.SERVER_CACHED_OBJECTS) {
103            // object is too old - we need to prepare again
104            prepare(session, false);
105        }
106    }
107 
108    @Override
109    public ResultInterface getMetaData() {
110        synchronized (session) {
111            if (!isQuery) {
112                return null;
113            }
114            int objectId = session.getNextId();
115            ResultRemote result = null;
116            for (int i = 0, count = 0; i < transferList.size(); i++) {
117                prepareIfRequired();
118                Transfer transfer = transferList.get(i);
119                try {
120                    session.traceOperation("COMMAND_GET_META_DATA", id);
121                    transfer.writeInt(SessionRemote.COMMAND_GET_META_DATA).
122                            writeInt(id).writeInt(objectId);
123                    session.done(transfer);
124                    int columnCount = transfer.readInt();
125                    result = new ResultRemote(session, transfer, objectId,
126                            columnCount, Integer.MAX_VALUE);
127                    break;
128                } catch (IOException e) {
129                    session.removeServer(e, i--, ++count);
130                }
131            }
132            session.autoCommitIfCluster();
133            return result;
134        }
135    }
136 
137    @Override
138    public ResultInterface executeQuery(int maxRows, boolean scrollable) {
139        checkParameters();
140        synchronized (session) {
141            int objectId = session.getNextId();
142            ResultRemote result = null;
143            for (int i = 0, count = 0; i < transferList.size(); i++) {
144                prepareIfRequired();
145                Transfer transfer = transferList.get(i);
146                try {
147                    session.traceOperation("COMMAND_EXECUTE_QUERY", id);
148                    transfer.writeInt(SessionRemote.COMMAND_EXECUTE_QUERY).
149                        writeInt(id).writeInt(objectId).writeInt(maxRows);
150                    int fetch;
151                    if (session.isClustered() || scrollable) {
152                        fetch = Integer.MAX_VALUE;
153                    } else {
154                        fetch = fetchSize;
155                    }
156                    transfer.writeInt(fetch);
157                    sendParameters(transfer);
158                    session.done(transfer);
159                    int columnCount = transfer.readInt();
160                    if (result != null) {
161                        result.close();
162                        result = null;
163                    }
164                    result = new ResultRemote(session, transfer, objectId, columnCount, fetch);
165                    if (readonly) {
166                        break;
167                    }
168                } catch (IOException e) {
169                    session.removeServer(e, i--, ++count);
170                }
171            }
172            session.autoCommitIfCluster();
173            session.readSessionState();
174            return result;
175        }
176    }
177 
178    @Override
179    public int executeUpdate() {
180        checkParameters();
181        synchronized (session) {
182            int updateCount = 0;
183            boolean autoCommit = false;
184            for (int i = 0, count = 0; i < transferList.size(); i++) {
185                prepareIfRequired();
186                Transfer transfer = transferList.get(i);
187                try {
188                    session.traceOperation("COMMAND_EXECUTE_UPDATE", id);
189                    transfer.writeInt(SessionRemote.COMMAND_EXECUTE_UPDATE).writeInt(id);
190                    sendParameters(transfer);
191                    session.done(transfer);
192                    updateCount = transfer.readInt();
193                    autoCommit = transfer.readBoolean();
194                } catch (IOException e) {
195                    session.removeServer(e, i--, ++count);
196                }
197            }
198            session.setAutoCommitFromServer(autoCommit);
199            session.autoCommitIfCluster();
200            session.readSessionState();
201            return updateCount;
202        }
203    }
204 
205    private void checkParameters() {
206        for (ParameterInterface p : parameters) {
207            p.checkSet();
208        }
209    }
210 
211    private void sendParameters(Transfer transfer) throws IOException {
212        int len = parameters.size();
213        transfer.writeInt(len);
214        for (ParameterInterface p : parameters) {
215            transfer.writeValue(p.getParamValue());
216        }
217    }
218 
219    @Override
220    public void close() {
221        if (session == null || session.isClosed()) {
222            return;
223        }
224        synchronized (session) {
225            session.traceOperation("COMMAND_CLOSE", id);
226            for (Transfer transfer : transferList) {
227                try {
228                    transfer.writeInt(SessionRemote.COMMAND_CLOSE).writeInt(id);
229                } catch (IOException e) {
230                    trace.error(e, "close");
231                }
232            }
233        }
234        session = null;
235        try {
236            for (ParameterInterface p : parameters) {
237                Value v = p.getParamValue();
238                if (v != null) {
239                    v.close();
240                }
241            }
242        } catch (DbException e) {
243            trace.error(e, "close");
244        }
245        parameters.clear();
246    }
247 
248    /**
249     * Cancel this current statement.
250     */
251    @Override
252    public void cancel() {
253        session.cancelStatement(id);
254    }
255 
256    @Override
257    public String toString() {
258        return sql + Trace.formatParams(getParameters());
259    }
260 
261    @Override
262    public int getCommandType() {
263        return UNKNOWN;
264    }
265 
266}

[all classes][org.h2.command]
EMMA 2.0.5312 (C) Vladimir Roubtsov