/** * Create a temporary view out of the given query. * * @param session the session * @param owner the owner of the query * @param name the view name * @param query the query * @param topQuery the top level query * @return the view table */ public static TableView createTempView(Session session, User owner, String name, Query query, Query topQuery) { Schema mainSchema = session.getDatabase().getSchema(Constants.SCHEMA_MAIN); String querySQL = query.getPlanSQL(); TableView v = new TableView(mainSchema, 0, name, querySQL, query.getParameters(), null /* column templates */, session, false/* allow recursive */, true /* literals have already been checked when parsing original query */, false /* is table expression */, false/* is persistent*/); if (v.createException != null) { throw v.createException; } v.setTopQuery(topQuery); v.setOwner(owner); v.setTemporary(true); return v; }
@Override public Index getScanIndex(Session session, int[] masks, TableFilter[] filters, int filter, SortOrder sortOrder, HashSet<Column> allColumnsSet) { if (createException != null) { String msg = createException.getMessage(); throw DbException.get(ErrorCode.VIEW_IS_INVALID_2, createException, getSQL(), msg); } PlanItem item = getBestPlanItem(session, masks, filters, filter, sortOrder, allColumnsSet); return item.getIndex(); }
private void initColumnsAndTables(Session session, boolean literalsChecked) { Column[] cols; removeCurrentViewFromOtherTables(); setTableExpression(isTableExpression); try { Query compiledQuery = compileViewQuery(session, querySQL, literalsChecked, getName()); this.querySQL = compiledQuery.getPlanSQL(); tables = new ArrayList<>(compiledQuery.getTables()); viewQuery = compiledQuery; } catch (DbException e) { e.addSQL(getCreateSQL()); createException = e; if (isRecursiveQueryExceptionDetected(createException)) { this.isRecursiveQueryDetected = true; setColumns(cols); if (getId() != 0) { addDependentViewToTables();
/** * Generate "CREATE" SQL statement for the view. * * @param orReplace if true, then include the OR REPLACE clause * @param force if true, then include the FORCE clause * @return the SQL statement */ public String getCreateSQL(boolean orReplace, boolean force) { return getCreateSQL(orReplace, force, getSQL()); }
/** * Try to replace the SQL statement of the view and re-compile this and all * dependent views. * * @param querySQL the SQL statement * @param newColumnTemplates the columns * @param session the session * @param recursive whether this is a recursive view * @param force if errors should be ignored * @param literalsChecked if literals have been checked */ public void replace(String querySQL, Column[] newColumnTemplates, Session session, boolean recursive, boolean force, boolean literalsChecked) { String oldQuerySQL = this.querySQL; Column[] oldColumnTemplates = this.columnTemplates; boolean oldRecursive = this.allowRecursive; init(querySQL, null, newColumnTemplates == null ? this.columnTemplates : newColumnTemplates, session, recursive, literalsChecked, isTableExpression, isPersistent); DbException e = recompile(session, force, true); if (e != null) { init(oldQuerySQL, null, oldColumnTemplates, session, oldRecursive, literalsChecked, isTableExpression, isPersistent); recompile(session, true, false); throw e; } }
@Override public void removeChildrenAndResources(Session session) { removeCurrentViewFromOtherTables(); super.removeChildrenAndResources(session); database.removeMeta(session, getId()); querySQL = null; index = null; clearIndexCaches(database); invalidate(); }
private void initColumnsAndTables(Session session) { Column[] cols; removeViewFromTables(); try { Query query = compileViewQuery(session, querySQL); this.querySQL = query.getPlanSQL(); tables = New.arrayList(query.getTables()); viewQuery = query; } catch (DbException e) { e.addSQL(getCreateSQL()); createException = e; setColumns(cols); if (getId() != 0) { addViewToTables();
boolean clearIndexCache) { try { compileViewQuery(session, querySQL, false, getName()); } catch (DbException e) { if (!force) { ArrayList<TableView> dependentViews = new ArrayList<>(getDependentViews()); initColumnsAndTables(session, false); for (TableView v : dependentViews) { DbException e = v.recompile(session, force, false); if (e != null && !force) { return e; clearIndexCaches(database);
view = TableView.createTableViewMaybeRecursive(getSchema(), id, viewName, querySQL, null, columnTemplatesAsStrings, session, false /* literalsChecked */, isTableExpression, true /* isPersistent */, db); } else { view = new TableView(getSchema(), id, viewName, querySQL, null, columnTemplatesAsUnknowns, session, false/* allow recursive */, false/* literalsChecked */, isTableExpression, true); view.replace(querySQL, columnTemplatesAsUnknowns, session, false, force, false); view.setModified(); view.setComment(comment);
if (!tv.isTableExpression()) { throw DbException.get(ErrorCode.TABLE_OR_VIEW_ALREADY_EXISTS_1, tempViewName); TableView view = new TableView(schema, id, tempViewName, querySQL, parameters, columnTemplates, session, true); view.setTableExpression(true); view.setTemporary(true); session.addLocalTempTable(view); view.setOnCommitDrop(true); Query q = parseSelectUnion(); q.setPrepareAlways(true);
boolean clearIndexCache) { try { compileViewQuery(session, querySQL); } catch (DbException e) { if (!force) { ArrayList<TableView> views = getViews(); if (views != null) { views = New.arrayList(views); initColumnsAndTables(session); if (views != null) { for (TableView v : views) { DbException e = v.recompile(session, force, false); if (e != null && !force) { return e; clearIndexCaches(database);
view = new TableView(schema, id, cteViewName, querySQL, parameters, columnTemplateArray, targetSession, allowRecursiveQueryDetection, false /* literalsChecked */, true /* isTableExpression */, isPersistent); if (!view.isRecursiveQueryDetected() && allowRecursiveQueryDetection) { if (isPersistent) { db.addSchemaObject(targetSession, view); view.lock(targetSession, true, true); targetSession.getDatabase().removeSchemaObject(targetSession, view); } else { session.removeLocalTempTable(view); view = new TableView(schema, id, cteViewName, querySQL, parameters, columnTemplateArray, targetSession, false/* assume recursive */, false /* literalsChecked */, true /* isTableExpression */, view.setTableExpression(true); view.setTemporary(!isPersistent); view.setHidden(true); view.setOnCommitDrop(false); if (addViewToSession) { if (isPersistent) { db.addSchemaObject(targetSession, view); view.unlock(targetSession); db.unlockMeta(targetSession); } else {
@Override public void removeChildrenAndResources(Session session) { removeViewFromTables(); super.removeChildrenAndResources(session); database.removeMeta(session, getId()); querySQL = null; index = null; clearIndexCaches(database); invalidate(); }
private void recompileInvalidViews(Session session) { boolean atLeastOneRecompiledSuccessfully; do { atLeastOneRecompiledSuccessfully = false; for (Table obj : getAllTablesAndViews(false)) { if (obj instanceof TableView) { TableView view = (TableView) obj; if (view.isInvalid()) { view.recompile(session, true, false); if (!view.isInvalid()) { atLeastOneRecompiledSuccessfully = true; } } } } } while (atLeastOneRecompiledSuccessfully); TableView.clearIndexCaches(session.getDatabase()); }
private void initColumnsAndTables(Session session) throws SQLException { Column[] cols; removeViewFromTables(); try { Query query = recompileQuery(session); tables = new ObjectArray(query.getTables()); ObjectArray expressions = query.getExpressions(); list.toArray(cols); createException = null; if (getId() != 0) { addViewToTables(); setColumns(cols);
public static TableView createTempView(Session s, User owner, Query query) throws SQLException { String tempViewName = s.getNextTempViewName(); Schema mainSchema = s.getDatabase().getSchema(Constants.SCHEMA_MAIN); String querySQL = query.getPlanSQL(); TableView v = new TableView(mainSchema, 0, tempViewName, querySQL, query.getParameters(), null, s, false); if (v.createException != null) { throw v.createException; } v.setOwner(owner); v.setTemporary(true); return v; }
Table recursiveTable = TableView.createShadowTableForRecursiveTableExpression(isPersistent, session, name, schema, Arrays.asList(columnTemplates), db); withQuery.setSession(session); columnTemplateList = TableView.createQueryColumnTemplateList(columnNames.toArray(new String[1]), (Query) withQuery, querySQLOutput); TableView.destroyShadowTableForRecursiveExpression(isPersistent, session, recursiveTable); TableView view = new TableView(schema, id, name, querySQL, parameters, columnTemplateList.toArray(columnTemplates), session, true/* try recursive */, literalsChecked, isTableExpression, isPersistent); if (!view.isRecursiveQueryDetected()) { if (isPersistent) { db.addSchemaObject(session, view); view.lock(session, true, true); session.getDatabase().removeSchemaObject(session, view); view.removeChildrenAndResources(session); } else { session.removeLocalTempTable(view); view = new TableView(schema, id, name, querySQL, parameters, columnTemplates, session, false/* detected not recursive */, literalsChecked, isTableExpression, isPersistent);
public void removeChildrenAndResources(Session session) throws SQLException { removeViewFromTables(); super.removeChildrenAndResources(session); database.removeMeta(session, getId()); querySQL = null; index = null; invalidate(); }
view.isInvalid() ? "INVALID" : "VALID", replaceNullWithEmpty(view.getComment()), "" + view.getId() );
private synchronized void init(String querySQL, ArrayList<Parameter> params, Column[] columnTemplates, Session session, boolean allowRecursive, boolean literalsChecked, boolean isTableExpression, boolean isPersistent) { this.querySQL = querySQL; this.columnTemplates = columnTemplates; this.allowRecursive = allowRecursive; this.isRecursiveQueryDetected = false; this.isTableExpression = isTableExpression; this.isPersistent = isPersistent; index = new ViewIndex(this, querySQL, params, allowRecursive); initColumnsAndTables(session, literalsChecked); }