/** * This constructor is used if the result set is later populated with addRow. */ public SimpleResultSet() { rows = Utils.newSmallArrayList(); }
@Override public void reset() { if (sort != null) { for (ResultDiskTape tape : tapes) { tape.pos = tape.start; tape.buffer = Utils.newSmallArrayList(); } } else { mainTape.pos = FileStorage.HEADER_LENGTH; mainTape.buffer = Utils.newSmallArrayList(); } }
/** * Add a column to the natural join key column list. * * @param c the column to add */ public void addNaturalJoinColumn(Column c) { if (naturalJoinColumns == null) { naturalJoinColumns = Utils.newSmallArrayList(); } naturalJoinColumns.add(c); }
public ClientCommand(ClientSession session, Transfer transfer, String sql, int fetchSize) { this.transfer = transfer; parameters = Utils.newSmallArrayList(); trace = session.getTrace(); this.sql = sql; this.fetchSize = fetchSize; this.session = session; }
private String[] parseColumnList() { ArrayList<String> columns = Utils.newSmallArrayList(); do { String columnName = readColumnIdentifier(); columns.add(columnName); } while (readIfMore()); return columns.toArray(new String[columns.size()]); }
private Query parseSelect() { int paramIndex = parameters.size(); Query command = parseSelectUnion(); ArrayList<Parameter> params = Utils.newSmallArrayList(); for (int i = paramIndex, size = parameters.size(); i < size; i++) { params.add(parameters.get(i)); } command.setParameterList(params); command.init(); return command; }
private StatementBase parse(String sql, boolean withExpectedList) { initialize(sql); if (withExpectedList) { expectedList = Utils.newSmallArrayList(); } else { expectedList = null; } parameters = Utils.newSmallArrayList(); currentSelect = null; currentStatement = null; createView = null; recompileAlways = false; indexedParameterList = null; read(); return parseStatement(); }
private StatementBase parseHelp() { StringBuilder buff = new StringBuilder("SELECT * FROM INFORMATION_SCHEMA.HELP"); int i = 0; ArrayList<Value> paramValues = Utils.newSmallArrayList(); while (currentTokenType != END) { String s = currentToken; read(); if (i == 0) { buff.append(" WHERE "); } else { buff.append(" AND "); } i++; buff.append("UPPER(TOPIC) LIKE ?"); paramValues.add(ValueString.get("%" + s + "%")); } return prepare(session, buff.toString(), paramValues); }
private Column[] parseColumnList(Table table) { ArrayList<Column> columns = Utils.newSmallArrayList(); HashSet<Column> set = new HashSet<>(); if (!readIf(")")) { do { Column column = parseColumn(table); if (!set.add(column)) { throw DbException.get(ErrorCode.DUPLICATE_COLUMN_NAME_1, column.getSQL()); } columns.add(column); } while (readIfMore()); } return columns.toArray(new Column[columns.size()]); }
private JavaAggregate readJavaAggregate(UserAggregate aggregate) { ArrayList<Expression> params = Utils.newSmallArrayList(); do { params.add(readExpression()); } while (readIf(",")); read(")"); Expression[] list = new Expression[params.size()]; params.toArray(list); JavaAggregate agg = new JavaAggregate(aggregate, list, currentSelect); currentSelect.setGroupQuery(); return agg; }
/** * Construct a local result object. * * @param session the session * @param expressions the expression array * @param visibleColumnCount the number of visible columns */ public LocalResult(ServerSession session, IExpression[] expressions, int visibleColumnCount) { this.session = session; if (session == null) { this.maxMemoryRows = Integer.MAX_VALUE; } else { this.maxMemoryRows = session.getDatabase().getMaxMemoryRows(); } rows = Utils.newSmallArrayList(); this.visibleColumnCount = visibleColumnCount; rowId = -1; this.expressions = expressions; }
@Override public void add(ServerSession session, Row row) { Value key = row.getValue(indexColumn); ArrayList<Long> positions = rows.get(key); if (positions == null) { positions = Utils.newSmallArrayList(); rows.put(key, positions); } positions.add(row.getKey()); rowCount++; }
/** * Parse a SQL code snippet that represents a table name. * * @param sql the code snippet * @return the table object */ public Table parseTableName(String sql) { parameters = Utils.newSmallArrayList(); initialize(sql); read(); return readTableOrView(); }
/** * Parse a SQL code snippet that represents an expression. * * @param sql the code snippet * @return the expression object */ @Override public Expression parseExpression(String sql) { parameters = Utils.newSmallArrayList(); initialize(sql); read(); return readExpression(); }
public ClientResult(ClientSession session, Transfer transfer, int id, int columnCount, int rowCount, int fetchSize) throws IOException { this.session = session; trace = session.getTrace(); this.transfer = transfer; this.id = id; this.columns = new ClientResultColumn[columnCount]; this.rowCount = rowCount; for (int i = 0; i < columnCount; i++) { columns[i] = new ClientResultColumn(transfer); } rowId = -1; result = Utils.newSmallArrayList(); this.fetchSize = fetchSize; fetchRows(false); }
/** * Adds a statement to the batch. * * @param sql the SQL statement */ @Override public void addBatch(String sql) throws SQLException { try { debugCodeCall("addBatch", sql); checkClosed(); sql = JdbcConnection.translateSQL(sql, escapeProcessing); if (batchCommands == null) { batchCommands = Utils.newSmallArrayList(); } batchCommands.add(sql); } catch (Exception e) { throw logAndConvert(e); } }
private ArrayList<SelectOrderBy> parseSimpleOrderList() { ArrayList<SelectOrderBy> orderList = Utils.newSmallArrayList(); do { SelectOrderBy order = new SelectOrderBy(); Expression expr = readExpression(); order.expression = expr; if (readIf("DESC")) { order.descending = true; } else { readIf("ASC"); } orderList.add(order); } while (readIf(",")); return orderList; }
private Select parseValues() { Select command = new Select(session); currentSelect = command; TableFilter filter = parseValuesTable(); ArrayList<Expression> list = Utils.newSmallArrayList(); list.add(new Wildcard(null, null)); command.setExpressions(list); command.addTableFilter(filter, true); command.init(); return command; }
private IndexColumn[] parseIndexColumnList() { ArrayList<IndexColumn> columns = Utils.newSmallArrayList(); do { IndexColumn column = new IndexColumn(); column.columnName = readColumnIdentifier(); columns.add(column); if (readIf("ASC")) { // ignore } else if (readIf("DESC")) { column.sortType = SortOrder.DESCENDING; } if (readIf("NULLS")) { if (readIf("FIRST")) { column.sortType |= SortOrder.NULLS_FIRST; } else { read("LAST"); column.sortType |= SortOrder.NULLS_LAST; } } } while (readIf(",")); read(")"); return columns.toArray(new IndexColumn[columns.size()]); }
ResultDiskBuffer(ServerSession session, SortOrder sort, int columnCount) { this.parent = null; this.sort = sort; this.columnCount = columnCount; Database db = session.getDatabase(); rowBuff = DataBuffer.create(db, Constants.DEFAULT_PAGE_SIZE); String fileName = db.createTempFile(); file = db.openFile(fileName, "rw", false); file.setCheckedWriting(false); file.seek(FileStorage.HEADER_LENGTH); if (sort != null) { tapes = Utils.newSmallArrayList(); mainTape = null; } else { tapes = null; mainTape = new ResultDiskTape(); mainTape.pos = FileStorage.HEADER_LENGTH; } this.maxBufferSize = db.getSettings().largeResultBufferSize; }