Java tutorial
package com.tesora.dve.sql.parser; /* * #%L * Tesora Inc. * Database Virtualization Engine * %% * Copyright (C) 2011 - 2014 Tesora Inc. * %% * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License, version 3, * as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. * #L% */ import java.net.URL; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; import java.util.TreeMap; import com.tesora.dve.charset.*; import com.tesora.dve.db.DBNative; import com.tesora.dve.variables.VariableService; import com.tesora.dve.sql.infoschema.InformationSchemaService; import org.antlr.runtime.Lexer; import org.antlr.runtime.Token; import org.antlr.runtime.tree.CommonTree; import org.apache.commons.lang.StringUtils; import org.apache.log4j.Logger; import org.apache.log4j.PropertyConfigurator; import com.tesora.dve.common.PEStringUtils; import com.tesora.dve.common.catalog.CatalogEntity; import com.tesora.dve.common.catalog.ConstraintType; import com.tesora.dve.common.catalog.Container; import com.tesora.dve.common.catalog.DynamicPolicy; import com.tesora.dve.common.catalog.ExternalService; import com.tesora.dve.common.catalog.FKMode; import com.tesora.dve.common.catalog.IndexType; import com.tesora.dve.common.catalog.Key; import com.tesora.dve.common.catalog.KeyColumn; import com.tesora.dve.common.catalog.MultitenantMode; import com.tesora.dve.common.catalog.PersistentGroup; import com.tesora.dve.common.catalog.PersistentTemplate; import com.tesora.dve.common.catalog.Provider; import com.tesora.dve.common.catalog.TableState; import com.tesora.dve.common.catalog.TemplateMode; import com.tesora.dve.common.catalog.User; import com.tesora.dve.common.catalog.UserDatabase; import com.tesora.dve.common.catalog.UserTable; import com.tesora.dve.db.DBResultConsumer; import com.tesora.dve.db.ValueConverter; import com.tesora.dve.distribution.DistributionRange; import com.tesora.dve.errmap.AvailableErrors; import com.tesora.dve.errmap.ErrorInfo; import com.tesora.dve.exceptions.PEException; import com.tesora.dve.lockmanager.LockManager; import com.tesora.dve.queryplan.ExecutionState; import com.tesora.dve.queryplan.QueryStepGeneralOperation.AdhocOperation; import com.tesora.dve.resultset.ColumnInfo; import com.tesora.dve.resultset.ProjectionInfo; import com.tesora.dve.server.connectionmanager.UserXid; import com.tesora.dve.singleton.Singletons; import com.tesora.dve.siteprovider.SiteProviderPlugin; import com.tesora.dve.siteprovider.SiteProviderPlugin.SiteProviderFactory; import com.tesora.dve.sql.ParserException; import com.tesora.dve.sql.ParserException.Pass; import com.tesora.dve.sql.SchemaException; import com.tesora.dve.sql.expression.Scope; import com.tesora.dve.sql.expression.ScopeParsePhase; import com.tesora.dve.sql.expression.ScopeStack; import com.tesora.dve.sql.expression.SetQuantifier; import com.tesora.dve.sql.expression.TableKey; import com.tesora.dve.sql.infoschema.InformationSchemaTable; import com.tesora.dve.sql.infoschema.ShowOptions; import com.tesora.dve.sql.infoschema.ShowSchemaBehavior; import com.tesora.dve.sql.infoschema.direct.DirectShowStatusInformation; import com.tesora.dve.sql.infoschema.direct.DirectShowVariablesTable; import com.tesora.dve.sql.node.Edge; import com.tesora.dve.sql.node.EdgeName; import com.tesora.dve.sql.node.MigrationException; import com.tesora.dve.sql.node.expression.ActualLiteralExpression; import com.tesora.dve.sql.node.expression.Alias; import com.tesora.dve.sql.node.expression.CaseExpression; import com.tesora.dve.sql.node.expression.CastFunctionCall; import com.tesora.dve.sql.node.expression.CharFunctionCall; import com.tesora.dve.sql.node.expression.ColumnInstance; import com.tesora.dve.sql.node.expression.ConvertFunctionCall; import com.tesora.dve.sql.node.expression.Default; import com.tesora.dve.sql.node.expression.DelegatingLiteralExpression; import com.tesora.dve.sql.node.expression.ExpressionNode; import com.tesora.dve.sql.node.expression.ExpressionSet; import com.tesora.dve.sql.node.expression.FunctionCall; import com.tesora.dve.sql.node.expression.GroupConcatCall; import com.tesora.dve.sql.node.expression.IdentifierLiteralExpression; import com.tesora.dve.sql.node.expression.IndexHint; import com.tesora.dve.sql.node.expression.IndexHint.HintTarget; import com.tesora.dve.sql.node.expression.IndexHint.HintType; import com.tesora.dve.sql.node.expression.IntervalExpression; import com.tesora.dve.sql.node.expression.LiteralExpression; import com.tesora.dve.sql.node.expression.NameAlias; import com.tesora.dve.sql.node.expression.NameInstance; import com.tesora.dve.sql.node.expression.Parameter; import com.tesora.dve.sql.node.expression.RandFunctionCall; import com.tesora.dve.sql.node.expression.StringLiteralAlias; import com.tesora.dve.sql.node.expression.Subquery; import com.tesora.dve.sql.node.expression.TableInstance; import com.tesora.dve.sql.node.expression.TableJoin; import com.tesora.dve.sql.node.expression.TriggerTableInstance; import com.tesora.dve.sql.node.expression.TriggerTableInstance.EarlyTriggerTableCollector; import com.tesora.dve.sql.node.expression.ValueSource; import com.tesora.dve.sql.node.expression.VariableInstance; import com.tesora.dve.sql.node.expression.WhenClause; import com.tesora.dve.sql.node.expression.Wildcard; import com.tesora.dve.sql.node.structural.FromTableReference; import com.tesora.dve.sql.node.structural.JoinClauseType; import com.tesora.dve.sql.node.structural.JoinClauseType.ClauseType; import com.tesora.dve.sql.node.structural.JoinSpecification; import com.tesora.dve.sql.node.structural.JoinedTable; import com.tesora.dve.sql.node.structural.LimitSpecification; import com.tesora.dve.sql.node.structural.SortingSpecification; import com.tesora.dve.sql.node.test.EngineConstant; import com.tesora.dve.sql.parser.ParserOptions.Option; import com.tesora.dve.sql.schema.Capability; import com.tesora.dve.sql.schema.Comment; import com.tesora.dve.sql.schema.ComplexPETable; import com.tesora.dve.sql.schema.ContainerDistributionVector; import com.tesora.dve.sql.schema.ContainerPolicyContext; import com.tesora.dve.sql.schema.Database; import com.tesora.dve.sql.schema.DistributionVector; import com.tesora.dve.sql.schema.ExplainOptions; import com.tesora.dve.sql.schema.ExplainOptions.ExplainOption; import com.tesora.dve.sql.schema.FloatSizeTypeAttribute; import com.tesora.dve.sql.schema.ForeignKeyAction; import com.tesora.dve.sql.schema.FunctionName; import com.tesora.dve.sql.schema.GrantScope; import com.tesora.dve.sql.schema.LoadDataInfileColOption; import com.tesora.dve.sql.schema.LoadDataInfileLineOption; import com.tesora.dve.sql.schema.LoadDataInfileModifier; import com.tesora.dve.sql.schema.LockInfo; import com.tesora.dve.sql.schema.Name; import com.tesora.dve.sql.schema.PEAbstractTable; import com.tesora.dve.sql.schema.PEAbstractTable.TableCacheKey; import com.tesora.dve.sql.schema.PEColumn; import com.tesora.dve.sql.schema.PEContainer; import com.tesora.dve.sql.schema.PEDatabase; import com.tesora.dve.sql.schema.PEExternalService; import com.tesora.dve.sql.schema.PEForeignKey; import com.tesora.dve.sql.schema.PEForeignKeyColumn; import com.tesora.dve.sql.schema.PEForwardForeignKeyColumn; import com.tesora.dve.sql.schema.PEForwardKeyColumn; import com.tesora.dve.sql.schema.PEKey; import com.tesora.dve.sql.schema.PEKeyColumn; import com.tesora.dve.sql.schema.PEKeyColumnBase; import com.tesora.dve.sql.schema.PEPersistentGroup; import com.tesora.dve.sql.schema.PEPolicy; import com.tesora.dve.sql.schema.PEPolicyClassConfig; import com.tesora.dve.sql.schema.PEProvider; import com.tesora.dve.sql.schema.PERawPlan; import com.tesora.dve.sql.schema.PESiteInstance; import com.tesora.dve.sql.schema.PEStorageSite; import com.tesora.dve.sql.schema.PETable; import com.tesora.dve.sql.schema.PETemplate; import com.tesora.dve.sql.schema.PETrigger; import com.tesora.dve.sql.schema.PEUser; import com.tesora.dve.sql.schema.PEView; import com.tesora.dve.sql.schema.Persistable; import com.tesora.dve.sql.schema.PolicyClass; import com.tesora.dve.sql.schema.QualifiedName; import com.tesora.dve.sql.schema.RangeDistribution; import com.tesora.dve.sql.schema.SQLMode; import com.tesora.dve.sql.schema.SchemaContext; import com.tesora.dve.sql.schema.SizeTypeAttribute; import com.tesora.dve.sql.schema.SubqueryTable; import com.tesora.dve.sql.schema.Table; import com.tesora.dve.sql.schema.TableComponent; import com.tesora.dve.sql.schema.TableResolver; import com.tesora.dve.sql.schema.TriggerEvent; import com.tesora.dve.sql.schema.TriggerTime; import com.tesora.dve.sql.schema.UnqualifiedName; import com.tesora.dve.sql.schema.UnresolvedDistributionVector; import com.tesora.dve.sql.schema.UserScope; import com.tesora.dve.sql.schema.ValueManager; import com.tesora.dve.sql.schema.VariableScope; import com.tesora.dve.sql.schema.VariableScopeKind; import com.tesora.dve.sql.schema.cache.IAutoIncrementLiteralExpression; import com.tesora.dve.sql.schema.cache.IDelegatingLiteralExpression; import com.tesora.dve.sql.schema.cache.IParameter; import com.tesora.dve.sql.schema.modifiers.AutoincTableModifier; import com.tesora.dve.sql.schema.modifiers.CharsetCollationModifierBuilder; import com.tesora.dve.sql.schema.modifiers.ChecksumModifier; import com.tesora.dve.sql.schema.modifiers.ColumnKeyModifier; import com.tesora.dve.sql.schema.modifiers.ColumnModifier; import com.tesora.dve.sql.schema.modifiers.ColumnModifierKind; import com.tesora.dve.sql.schema.modifiers.CommentTableModifier; import com.tesora.dve.sql.schema.modifiers.DefaultValueModifier; import com.tesora.dve.sql.schema.modifiers.EngineTableModifier; import com.tesora.dve.sql.schema.modifiers.InsertModifier; import com.tesora.dve.sql.schema.modifiers.MaxRowsModifier; import com.tesora.dve.sql.schema.modifiers.RowFormatTableModifier; import com.tesora.dve.sql.schema.modifiers.StringTypeModifier; import com.tesora.dve.sql.schema.modifiers.TableModifier; import com.tesora.dve.sql.schema.modifiers.TypeModifier; import com.tesora.dve.sql.schema.modifiers.TypeModifierKind; import com.tesora.dve.sql.schema.modifiers.UnknownTableModifier; import com.tesora.dve.sql.schema.mt.PETenant; import com.tesora.dve.sql.schema.mt.TenantColumn; import com.tesora.dve.sql.schema.types.BasicType; import com.tesora.dve.sql.schema.types.DBEnumType; import com.tesora.dve.sql.schema.types.TempColumnType; import com.tesora.dve.sql.schema.types.Type; import com.tesora.dve.sql.statement.EmptyStatement; import com.tesora.dve.sql.statement.Statement; import com.tesora.dve.sql.statement.StatementTraits; import com.tesora.dve.sql.statement.StatementType; import com.tesora.dve.sql.statement.ddl.AddGlobalVariableStatement; import com.tesora.dve.sql.statement.ddl.AddStorageSiteStatement; import com.tesora.dve.sql.statement.ddl.AlterDatabaseStatement; import com.tesora.dve.sql.statement.ddl.AlterDatabaseTemplateStatement; import com.tesora.dve.sql.statement.ddl.GrantStatement; import com.tesora.dve.sql.statement.ddl.PEAlterExternalServiceStatement; import com.tesora.dve.sql.statement.ddl.PEAlterGroupProviderStatement; import com.tesora.dve.sql.statement.ddl.PEAlterPersistentSite; import com.tesora.dve.sql.statement.ddl.PEAlterPolicyStatement; import com.tesora.dve.sql.statement.ddl.PEAlterRawPlanStatement; import com.tesora.dve.sql.statement.ddl.PEAlterSiteInstanceStatement; import com.tesora.dve.sql.statement.ddl.PEAlterStatement; import com.tesora.dve.sql.statement.ddl.PEAlterTableStatement; import com.tesora.dve.sql.statement.ddl.PEAlterTemplateStatement; import com.tesora.dve.sql.statement.ddl.PECreateDatabaseStatement; import com.tesora.dve.sql.statement.ddl.PECreateExternalServiceStatement; import com.tesora.dve.sql.statement.ddl.PECreateGroupProviderStatement; import com.tesora.dve.sql.statement.ddl.PECreateRawPlanStatement; import com.tesora.dve.sql.statement.ddl.PECreateSiteInstanceStatement; import com.tesora.dve.sql.statement.ddl.PECreateStatement; import com.tesora.dve.sql.statement.ddl.PECreateStorageSiteStatement; import com.tesora.dve.sql.statement.ddl.PECreateTableAsSelectStatement; import com.tesora.dve.sql.statement.ddl.PECreateTableStatement; import com.tesora.dve.sql.statement.ddl.PECreateTriggerStatement; import com.tesora.dve.sql.statement.ddl.PECreateUserStatement; import com.tesora.dve.sql.statement.ddl.PECreateViewStatement; import com.tesora.dve.sql.statement.ddl.PEDropContainerStatement; import com.tesora.dve.sql.statement.ddl.PEDropExternalServiceStatement; import com.tesora.dve.sql.statement.ddl.PEDropGroupProviderStatement; import com.tesora.dve.sql.statement.ddl.PEDropRangeStatement; import com.tesora.dve.sql.statement.ddl.PEDropRawPlanStatement; import com.tesora.dve.sql.statement.ddl.PEDropStatement; import com.tesora.dve.sql.statement.ddl.PEDropStorageGroupStatement; import com.tesora.dve.sql.statement.ddl.PEDropStorageSiteStatement; import com.tesora.dve.sql.statement.ddl.PEDropTableStatement; import com.tesora.dve.sql.statement.ddl.PEDropTriggerStatement; import com.tesora.dve.sql.statement.ddl.PEDropUserStatement; import com.tesora.dve.sql.statement.ddl.PEDropViewStatement; import com.tesora.dve.sql.statement.ddl.PEGroupProviderDDLStatement; import com.tesora.dve.sql.statement.ddl.RenameTableStatement; import com.tesora.dve.sql.statement.ddl.SchemaQueryStatement; import com.tesora.dve.sql.statement.ddl.SetPasswordStatement; import com.tesora.dve.sql.statement.ddl.ShowPlanCacheStatement; import com.tesora.dve.sql.statement.ddl.alter.AddColumnAction; import com.tesora.dve.sql.statement.ddl.alter.AddIndexAction; import com.tesora.dve.sql.statement.ddl.alter.AlterColumnAction; import com.tesora.dve.sql.statement.ddl.alter.AlterTableAction; import com.tesora.dve.sql.statement.ddl.alter.ChangeColumnAction; import com.tesora.dve.sql.statement.ddl.alter.ChangeKeysStatusAction; import com.tesora.dve.sql.statement.ddl.alter.ChangeTableDistributionAction; import com.tesora.dve.sql.statement.ddl.alter.ChangeTableModifierAction; import com.tesora.dve.sql.statement.ddl.alter.ConvertToAction; import com.tesora.dve.sql.statement.ddl.alter.DropColumnAction; import com.tesora.dve.sql.statement.ddl.alter.DropIndexAction; import com.tesora.dve.sql.statement.ddl.alter.RenameTableAction; import com.tesora.dve.sql.statement.dml.AliasInformation; import com.tesora.dve.sql.statement.dml.DMLStatement; import com.tesora.dve.sql.statement.dml.DeleteStatement; import com.tesora.dve.sql.statement.dml.InsertIntoSelectStatement; import com.tesora.dve.sql.statement.dml.InsertIntoValuesStatement; import com.tesora.dve.sql.statement.dml.MysqlSelectOption; import com.tesora.dve.sql.statement.dml.ProjectingStatement; import com.tesora.dve.sql.statement.dml.ReplaceIntoSelectStatement; import com.tesora.dve.sql.statement.dml.ReplaceIntoValuesStatement; import com.tesora.dve.sql.statement.dml.SelectStatement; import com.tesora.dve.sql.statement.dml.TruncateStatement; import com.tesora.dve.sql.statement.dml.UnionStatement; import com.tesora.dve.sql.statement.dml.UpdateStatement; import com.tesora.dve.sql.statement.dml.compound.CaseStatement; import com.tesora.dve.sql.statement.dml.compound.CompoundStatementList; import com.tesora.dve.sql.statement.dml.compound.StatementWhenClause; import com.tesora.dve.sql.statement.session.AnalyzeKeysStatement; import com.tesora.dve.sql.statement.session.AnalyzeTablesStatement; import com.tesora.dve.sql.statement.session.DeallocatePStmtStatement; import com.tesora.dve.sql.statement.session.ExecutePStmtStatement; import com.tesora.dve.sql.statement.session.ExternalServiceControlStatement; import com.tesora.dve.sql.statement.session.FlushPrivilegesStatement; import com.tesora.dve.sql.statement.session.KillStatement; import com.tesora.dve.sql.statement.session.LoadDataInfileStatement; import com.tesora.dve.sql.statement.session.LockStatement; import com.tesora.dve.sql.statement.session.LockType; import com.tesora.dve.sql.statement.session.PreparePStmtStatement; import com.tesora.dve.sql.statement.session.RollbackTransactionStatement; import com.tesora.dve.sql.statement.session.SavepointStatement; import com.tesora.dve.sql.statement.session.SessionSetVariableStatement; import com.tesora.dve.sql.statement.session.SessionStatement; import com.tesora.dve.sql.statement.session.SetExpression; import com.tesora.dve.sql.statement.session.SetTransactionIsolationExpression; import com.tesora.dve.sql.statement.session.SetVariableExpression; import com.tesora.dve.sql.statement.session.ShowErrorsWarningsStatement; import com.tesora.dve.sql.statement.session.ShowPassthroughStatement; import com.tesora.dve.sql.statement.session.ShowPassthroughStatement.PassThroughCommandType; import com.tesora.dve.sql.statement.session.ShowProcesslistStatement; import com.tesora.dve.sql.statement.session.ShowSitesStatusStatement; import com.tesora.dve.sql.statement.session.StartTransactionStatement; import com.tesora.dve.sql.statement.session.TableMaintenanceStatement; import com.tesora.dve.sql.statement.session.TableMaintenanceStatement.MaintenanceCommandType; import com.tesora.dve.sql.statement.session.TableMaintenanceStatement.MaintenanceOptionType; import com.tesora.dve.sql.statement.session.TransactionStatement; import com.tesora.dve.sql.statement.session.UseContainerStatement; import com.tesora.dve.sql.statement.session.XABeginTransactionStatement; import com.tesora.dve.sql.statement.session.XACommitTransactionStatement; import com.tesora.dve.sql.statement.session.XAEndTransactionStatement; import com.tesora.dve.sql.statement.session.XAPrepareTransactionStatement; import com.tesora.dve.sql.statement.session.XARecoverTransactionStatement; import com.tesora.dve.sql.statement.session.XARollbackTransactionStatement; import com.tesora.dve.sql.template.TemplateManager; import com.tesora.dve.sql.transform.CopyVisitor; import com.tesora.dve.sql.transform.behaviors.BehaviorConfiguration; import com.tesora.dve.sql.transform.execution.ExecutionSequence; import com.tesora.dve.sql.transform.execution.PassThroughCommand.Command; import com.tesora.dve.sql.transform.execution.TransientSessionExecutionStep; import com.tesora.dve.sql.transform.strategy.NaturalJoinRewriter; import com.tesora.dve.sql.util.Functional; import com.tesora.dve.sql.util.ListOfPairs; import com.tesora.dve.sql.util.ListSet; import com.tesora.dve.sql.util.Pair; import com.tesora.dve.sql.util.UnaryFunction; import com.tesora.dve.sql.util.UnaryProcedure; import com.tesora.dve.variable.VariableConstants; import com.tesora.dve.variables.KnownVariables; import com.tesora.dve.variables.VariableHandler; import com.tesora.dve.worker.SiteManagerCommand; import com.tesora.dve.worker.WorkerGroup; // holds the bridge methods from antlr tree nodes to our nodes public class TranslatorUtils extends Utils implements ValueSource { static Logger logger = Logger.getLogger(TranslatorUtils.class); static public final String PERSISTENT_GROUP_TAG = "PERSISTENT GROUP"; static public final String PERSISTENT_SITE_TAG = "PERSISTENT SITE"; static public final String PERSISTENT_INSTANCE = "PERSISTENT INSTANCE"; static public final String DYNAMIC_SITE_PROVIDER = "DYNAMIC SITE PROVIDER"; static public final String DYNAMIC_SITE_PROVIDER_SITES = DYNAMIC_SITE_PROVIDER + " SITES"; static public final String DYNAMIC_SITE_POLICY_TAG = "DYNAMIC SITE POLICY"; private final String MISSING_UNQUALIFIED_IDENTIFIER_ERROR_MSG = "Command was not parsed correctly " + "(can occur if certain keywords are used as identifiers)"; private static final String UPDATABLE_VIEWS = "No support for updatable views"; SchemaContext pc; private ParserOptions opts; private boolean resolveColumnsAsIdentifiers; private ScopeStack scope; private ListOfPairs<DelegatingLiteralExpression, Object> literals; private List<Parameter> parameters; // as soon as we know the lock type, we register it private LockInfo lockInfo; // if there is a regular insert, this is the first part of it - everything except the values private InsertIntoValuesStatement insertSkeleton; // if this is a continuation, the initial offset private int initialOffset; // this is set if enough is bumped private int finalOffset; // for big inserts private final long continuationThreshold; private NativeCharSetCatalog supportedCharSets = null; private NativeCollationCatalog supportedCollations = null; private static final TableResolver basicResolver = new TableResolver().withMTChecks() .withQualifiedMissingDBFormat("No such database '%s'."); public static PEAbstractTable<?> getTable(final SchemaContext sc, final Name fullName, final LockInfo lockInfo) { TableInstance ti = basicResolver.lookupTable(sc, fullName, lockInfo); if (ti == null) return null; return ti.getAbstractTable(); } public static UnqualifiedName getDatabaseNameForObject(final SchemaContext sc, final Name objectName) { return getDatabaseForObject(sc, objectName).getName().getUnqualified(); } public static Database<?> getDatabaseForObject(final SchemaContext sc, final Name objectName) throws SchemaException { if (objectName.isQualified()) { final UnqualifiedName parentSchemaName = ((QualifiedName) objectName).getNamespace(); final Database<?> parentSchema = sc.findDatabase(parentSchemaName); if (parentSchema != null) { return parentSchema; } throw new SchemaException(new ErrorInfo(AvailableErrors.UNKNOWN_DATABASE, parentSchemaName.get())); } final Database<?> currentSchema = sc.getCurrentDatabase(); if (currentSchema != null) { return currentSchema; } throw new SchemaException(new ErrorInfo(AvailableErrors.NO_DATABASE_SELECTED)); } public TranslatorUtils(ParserOptions opts, SchemaContext pc, InputState state) { super(opts); this.pc = pc; if (this.pc == null) throw new SchemaException(Pass.FIRST, "TranslatorUtils no longer accepts null SchemaContext"); this.opts = opts; scope = new ScopeStack(); this.lockInfo = null; resolveColumnsAsIdentifiers = false; literals = new ListOfPairs<DelegatingLiteralExpression, Object>(); parameters = new ArrayList<Parameter>(); this.initialOffset = state.getCurrentPosition(); this.insertSkeleton = state.getInsertSkeleton(); finalOffset = -1; continuationThreshold = state.getThreshold(); if ((this.insertSkeleton != null) && (state instanceof ContinuationInputState)) { scope.pushScope(); scope.insertTable(this.insertSkeleton.getTableInstance()); } } public void setContext(SchemaContext sc) { pc = sc; } public String getInputSQL() { return pc.getOrigStmt(); } public void pushScope() { scope.pushScope(); } public void popScope() { scope.popScope(); } public void pushUnresolvingScope() { scope.pushUnresolvingScope(); } public void resolveProjection() { scope.resolveProjection(pc); } public void storeProjection(List<ExpressionNode> l) { scope.storeProjection(l); } public void setGroupByNamespace() { scope.setPhase(ScopeParsePhase.GROUPBY); } public void setHavingNamespace() { scope.setPhase(ScopeParsePhase.HAVING); } public void setTrailingNamespace() { scope.setPhase(ScopeParsePhase.TRAILING); } public int getLastPoppedScope() { return scope.getLastPoppedScopeID(); } public void repushScope(int id) { scope.pushScopeID(id); } public void pushUnresolving() { opts = opts.unsetResolve(); } public void popUnresolving() { opts = opts.setResolve(); } // call this during parsing to indicate that we are handling ddl public void ddl() { if (pc.getCapability() != Capability.PARSING_ONLY) pc.forceMutableSource(); if (opts == null || opts.getLockOverride() == null) lockInfo = new LockInfo(com.tesora.dve.lockmanager.LockType.EXCLUSIVE, "ddl"); else if (opts != null && opts.getLockOverride() != null) lockInfo = opts.getLockOverride(); } // call this during parsing to indicate that we are not handling ddl - used during temp table operations public void notddl() { if (pc.getCapability() != Capability.PARSING_ONLY) pc.forceImmutableSource(); if (opts == null || opts.getLockOverride() == null) lockInfo = new LockInfo(com.tesora.dve.lockmanager.LockType.EXCLUSIVE, "ddl"); else if (opts != null && opts.getLockOverride() != null) lockInfo = opts.getLockOverride(); } protected void forceUncacheable(ValueManager.CacheStatus status) { if (pc.getCapability() != Capability.PARSING_ONLY) pc.getValueManager().markUncacheable(status); } public void assignPositions() { if (pc.getCapability() == Capability.PARSING_ONLY) return; if (!parameters.isEmpty()) { TreeMap<SourceLocation, Parameter> map = new TreeMap<SourceLocation, Parameter>(); for (Parameter p : parameters) map.put(p.getSourceLocation(), p); if (map.size() != parameters.size()) throw new SchemaException(Pass.SECOND, "Lost parameters while doing position assignment"); int i = 0; for (Parameter p : map.values()) { p.setPosition(i); pc.getValueManager().registerParameter(pc, p); i++; } } if (literals.size() > KnownVariables.CACHED_PLAN_LITERALS_MAX .getValue(pc.getConnection().getVariableSource()).intValue()) { forceUncacheable(ValueManager.CacheStatus.NOCACHE_TOO_MANY_LITERALS); } else { TreeMap<SourceLocation, DelegatingLiteralExpression> map = new TreeMap<SourceLocation, DelegatingLiteralExpression>(); for (Pair<DelegatingLiteralExpression, Object> p : literals) { map.put(p.getFirst().getSourceLocation(), p.getFirst()); } if (map.size() != literals.size()) throw new SchemaException(Pass.SECOND, "Lost literals while doing position assignment"); int i = 0; for (DelegatingLiteralExpression dle : map.values()) { pc.getValueManager().addLiteralValue(pc, i, literals.get(dle.getPosition()).getSecond(), dle); dle.setPosition(i, true); i++; } } } @SuppressWarnings("unchecked") public ProjectingStatement buildSelectStatement(Map<String, Object> components, List<ExpressionNode> projection, List<Object> selectOptions, Object tree) { return buildSelectStatement((List<FromTableReference>) components.get(EdgeName.TABLES), projection, (ExpressionNode) components.get(EdgeName.WHERECLAUSE), (List<SortingSpecification>) components.get(EdgeName.ORDERBY), (LimitSpecification) components.get(EdgeName.LIMIT), selectOptions, (List<SortingSpecification>) components.get(EdgeName.GROUPBY), (ExpressionNode) components.get(EdgeName.HAVING), (Boolean) components.get(Statement.SELECT_LOCK_ATTRIBUTE), tree); } public ProjectingStatement buildSelectStatement(List<FromTableReference> tableRefs, List<ExpressionNode> projection, ExpressionNode whereClause, List<SortingSpecification> orderbys, LimitSpecification limit, List<Object> selectOptions, List<SortingSpecification> groupbys, ExpressionNode havingExpr, Boolean locking, Object tree) { // sort the set quantifier and select options SetQuantifier sq = null; List<MysqlSelectOption> options = new ArrayList<MysqlSelectOption>(); for (Object opt : selectOptions) { if (opt instanceof SetQuantifier) sq = (SetQuantifier) opt; else options.add((MysqlSelectOption) opt); } SelectStatement ss = new SelectStatement(tableRefs, projection, whereClause, orderbys, limit, sq, options, groupbys, havingExpr, locking, new AliasInformation(scope), SourceLocation.make(tree)); /* * The NATURAL [LEFT] JOIN are rewritten to an INNER JOIN or a LEFT JOIN * with a USING clause. * The rewrite must take place after ColumnInstance resolution (to * prevent premature failure on ambiguous column names), but before * USING-to-ON clause conversion and wildcard expansion which affect the * projection coalescing and ordering. */ if (tableRefs != null) { for (final FromTableReference ftr : tableRefs) { final TableInstance base = ftr.getBaseTable(); final ListSet<JoinedTable> naturalJoins = NaturalJoinRewriter .collectNaturalJoins(ftr.getTableJoins()); for (final JoinedTable join : naturalJoins) { NaturalJoinRewriter.rewriteToInnerJoin(this.pc, base, join); } convertUsingColSpecToOnSpec(base, naturalJoins); } } ss.getDerivedInfo().takeScope(scope); Scope ps = scope.getParentScope(); if (ps != null) ps.getNestedQueries().add(ss); shouldSetTimestampVariable(ss, null, null); return ss; } public Statement buildUpdateStatement(List<FromTableReference> tableRefs, List<ExpressionNode> updateExprs, ExpressionNode whereClause, List<SortingSpecification> orderbys, LimitSpecification limit, boolean ignore, Object tree) { PEAbstractTable<?> tab = tableRefs.get(0).getBaseTable().getAbstractTable(); if (tab != null && tab.isView()) throw new SchemaException(Pass.SECOND, UPDATABLE_VIEWS); UpdateStatement us = new UpdateStatement(tableRefs, updateExprs, whereClause, orderbys, limit, new AliasInformation(scope), SourceLocation.make(tree)); us.setIgnore(ignore); us.getDerivedInfo().takeScope(scope); if (tab != null) shouldSetTimestampVariable(us, tab.asTable(), updateExprs); return us; } public Statement buildDeleteStatement(List<FromTableReference> tableRefs, List<Name> explicitRefs, ExpressionNode whereClause, List<SortingSpecification> orderbys, LimitSpecification limit, Object sloc) { List<TableInstance> explicitDeletes = null; if (explicitRefs == null || explicitRefs.isEmpty()) { // ignore } else { explicitDeletes = new ArrayList<TableInstance>(); for (Name r : explicitRefs) { if (pc.getCapability() == Capability.PARSING_ONLY) { explicitDeletes.add(new TableInstance(null, r, null, false)); } else { Name actual = r; // if it has a trailing * strip that off List<UnqualifiedName> parts = r.getParts(); if (parts.size() > 1 && parts.get(parts.size() - 1).isAsterisk()) { ArrayList<UnqualifiedName> nparts = new ArrayList<UnqualifiedName>(parts); nparts.remove(nparts.size() - 1); if (nparts.size() == 1) actual = nparts.get(0); else actual = new QualifiedName(nparts); } explicitDeletes.add(scope.lookupTableInstance(pc, actual, true)); } } } DeleteStatement ds = new DeleteStatement(explicitDeletes, tableRefs, whereClause, orderbys, limit, false, new AliasInformation(scope), SourceLocation.make(sloc)); ds.getDerivedInfo().takeScope(scope); shouldSetTimestampVariable(ds, null, null); return ds; } @SuppressWarnings("unchecked") public void pushSkeletonInsert(ExpressionNode tab, boolean replace, Object tree) { TableInstance intoTable = (TableInstance) tab; InsertIntoValuesStatement is = null; SourceLocation sloc = SourceLocation.make(tree); if (replace) is = new ReplaceIntoValuesStatement(intoTable, Collections.EMPTY_LIST, Collections.EMPTY_LIST, new AliasInformation(scope), sloc); else is = new InsertIntoValuesStatement(intoTable, Collections.EMPTY_LIST, Collections.EMPTY_LIST, null, new AliasInformation(scope), sloc); is.getDerivedInfo().addLocalTable(intoTable.getTableKey()); is.getDerivedInfo().takeScope(scope); insertSkeleton = is; } public ExpressionNode pushInsertSkeletonField(ExpressionNode field) { insertSkeleton.getColumnSpecificationEdge().add(field); return field; } public InsertIntoValuesStatement buildInsertStatement(List<List<ExpressionNode>> values, boolean copy, TransactionStatement.Kind txnal, InsertModifier im, boolean ignore) { return buildInsertStatement(null, values, copy, txnal, im, ignore); } private InsertIntoValuesStatement buildInsertStatement(List<ExpressionNode> columnSpec, List<List<ExpressionNode>> values, boolean copy, TransactionStatement.Kind txnal, InsertModifier im, boolean ignore) { InsertIntoValuesStatement is = null; if (copy) is = CopyVisitor.copy(insertSkeleton); else is = insertSkeleton; if (columnSpec != null) is.setColumnSpecification(columnSpec); is.setValues(values); is.setTxnFlag(txnal); is.setIgnore(ignore); if (im != null) { if (opts.isResolve() && im.equals(InsertModifier.DELAYED)) { // replication slave always strips the DELAYED keyword if (!pc.getConnection().originatedFromReplicationSlave()) { EngineTableModifier tem = is.getTableInstance().getAbstractTable().asTable().getEngine(); if (tem.isMyISAM()) is.setModifier(im); else throw new SchemaException(Pass.SECOND, "Insert modifier '" + im.getSQL() + "' option not supported on table of type " + tem.getEngine().getSQL()); } } else { is.setModifier(im); } } shouldSetTimestampVariable(is, is.getTableInstance().getAbstractTable(), is.getColumnSpecification(), values); return is; } public Statement buildInsertStatement(List<List<ExpressionNode>> values, List<ExpressionNode> onDupKey, InsertModifier im, boolean ignore) { InsertIntoValuesStatement is = buildInsertStatement(values, false, (initialOffset > 0 ? TransactionStatement.Kind.COMMIT : null), im, ignore); is.setOnDuplicateKey(onDupKey); // clear the skeleton insertSkeleton = null; return is; } /** * @param select * @param ignore * @param onDupKey * @return */ @SuppressWarnings("unchecked") public Statement buildInsertIntoSelectStatement(ExpressionNode select, boolean ignore, List<ExpressionNode> onDupKey) { Subquery sq = (Subquery) select; ProjectingStatement selectStatement = sq.getStatement(); // copy the table, etc. out of the skeleton, then clear it InsertIntoSelectStatement iiss = null; if (insertSkeleton.isReplace()) { iiss = new ReplaceIntoSelectStatement(insertSkeleton.getTableInstance(), insertSkeleton.getColumnSpecification(), selectStatement, sq.isGrouped(), new AliasInformation(scope), insertSkeleton.getSourceLocation()); } else { iiss = new InsertIntoSelectStatement(insertSkeleton.getTableInstance(), insertSkeleton.getColumnSpecification(), selectStatement, sq.isGrouped(), onDupKey, new AliasInformation(scope), insertSkeleton.getSourceLocation()); iiss.setIgnore(ignore); } // the select is nested iiss.getDerivedInfo().addNestedStatements(Collections.singleton(selectStatement)); iiss.getDerivedInfo().addLocalTable(insertSkeleton.getTableInstance().getTableKey()); iiss.getDerivedInfo().takeScope(scope); shouldSetTimestampVariable(iiss, insertSkeleton.getTableInstance().getAbstractTable(), insertSkeleton.getColumnSpecification(), Collections.EMPTY_LIST); insertSkeleton = null; return iiss; } public void enough(PE_MySQL parser, List<List<ExpressionNode>> insertValues) { Lexer lexer = (Lexer) parser.getTokenStream().getTokenSource(); if (lexer.getCharIndex() - initialOffset > continuationThreshold) { finalOffset = lexer.getCharIndex(); throw new EnoughException(buildInsertStatement(insertValues, true, (initialOffset == 0 ? TransactionStatement.Kind.START : null), null, false)); } } public void reportContinuationOnDupKey() { throw new ParserException(Pass.FIRST, "Statement is too large. Consider increasing the '" + VariableConstants.LARGE_INSERT_THRESHOLD_NAME + "' value.", null); } public InputState getInputState(InputState in) { if (finalOffset == -1) return null; if (finalOffset > -1) { in.setCurrentPosition(finalOffset); } if (insertSkeleton != null && in.getInsertSkeleton() == null) in.setInsertSkeleton(insertSkeleton); return in; } /** * @param updateExprs * @param ignore * @param onDupKey * @param im * @return */ public Statement buildInsertIntoSetStatement(List<ExpressionNode> updateExprs, boolean ignore, List<ExpressionNode> onDupKey, InsertModifier im) { // use insert skeleton as is, since we cannot match the extended insert in the parser // but we have to unpack the update exprs to build the column spec and values List<ExpressionNode> columnSpec = new ArrayList<ExpressionNode>(); List<ExpressionNode> values = new ArrayList<ExpressionNode>(); for (ExpressionNode en : updateExprs) { FunctionCall fc = (FunctionCall) en; columnSpec.add(fc.getParametersEdge().get(0)); values.add(fc.getParametersEdge().get(1)); } return buildInsertStatement(columnSpec, Collections.singletonList(values), false, null, im, ignore); } private boolean shouldSetTimestampVariable(DMLStatement dmls, PETable tab, List<ExpressionNode> updateExprs) { // separate the update set column=value expression into columns and // values lists List<ExpressionNode> fields = new ArrayList<ExpressionNode>(); List<List<ExpressionNode>> allValues = new ArrayList<List<ExpressionNode>>(); List<ExpressionNode> rowValues = new ArrayList<ExpressionNode>(); if (updateExprs != null) { for (ExpressionNode node : updateExprs) { // update set column= are function calls FunctionCall f = (FunctionCall) node; Pair<ColumnInstance, ExpressionNode> params = decomposeUpdateAssignment(f); fields.add(params.getFirst()); rowValues.add(params.getSecond()); } } allValues.add(rowValues); return shouldSetTimestampVariable(dmls, tab, fields, allValues); } private boolean shouldSetTimestampVariable(DMLStatement dmls, PEAbstractTable<?> tab, List<ExpressionNode> fields, List<List<ExpressionNode>> values) { // check if the now or current_timestamp function is used boolean ret = TimestampVariableUtils.isNowFunctionCallSpecified(dmls.getDerivedInfo().getFunctions()); // can't do anything if petable is null if (tab == null) { // could have been set by above call so save in our statement // save the set timestamp variable flag in our statement dmls.getDerivedInfo().setSetTimestampVariable(ret); return ret; } if (!ret) { // determine which columns in the table are specified and which are // not List<PEColumn> specifiedColumns = new ArrayList<PEColumn>(); List<PEColumn> unspecifiedColumns = new ArrayList<PEColumn>(tab.getColumns(pc)); if (fields == null || fields.isEmpty()) { specifiedColumns.addAll(unspecifiedColumns); unspecifiedColumns.clear(); } else { List<PEColumn> temp = new ArrayList<PEColumn>(); for (ExpressionNode field : fields) { temp.add(((ColumnInstance) field).getPEColumn()); } unspecifiedColumns.removeAll(temp); for (ExpressionNode col : fields) { PEColumn c = ((ColumnInstance) col).getPEColumn(); specifiedColumns.add(c); } } for (PEColumn c : unspecifiedColumns) { ret = TimestampVariableUtils.setTimestampVariableForUnspecifiedColumn(pc, dmls, c); if (ret) { // set the variable so break loop break; } } // we need values to check against if (!ret && (values != null)) { // haven't set the timestamp variable yet // so check if the specified columns need to set it for (int i = 0; i < specifiedColumns.size(); ++i) { PEColumn c = specifiedColumns.get(i); for (List<ExpressionNode> v : values) { // make sure the ___mtid is skipped // by checking the specified column count doesn't // exceed the values if (i >= v.size()) { continue; } ExpressionNode e = v.get(i); ExpressionNode r = e; if (e instanceof Default) { ExpressionNode defaultValue = c.getDefaultValue(); if (defaultValue == null) { if (c.isNullable()) { r = LiteralExpression.makeNullLiteral(); } } else { r = (ExpressionNode) ((LiteralExpression) defaultValue).copy(null); } } ret = TimestampVariableUtils.setTimestampVariableForSpecifiedValue(c, r); if (ret) { break; } } if (ret) { break; } } } } // save the set timestamp variable flag in our statement dmls.getDerivedInfo().setSetTimestampVariable(ret); return ret; } private Pair<ColumnInstance, ExpressionNode> decomposeUpdateAssignment(FunctionCall fc) { ColumnInstance ci = null; ExpressionNode le = null; // for update assignment, we know exactly what we have - so just access // by index if (fc.getFunctionName().isEquals()) { List<ExpressionNode> params = fc.getParameters(); if (params.get(0) instanceof ColumnInstance) ci = (ColumnInstance) params.get(0); else return null; le = params.get(1); return new Pair<ColumnInstance, ExpressionNode>(ci, le); } return null; } public Statement buildCreateTable(Name tableName, Name oldTableName, Boolean ine) { if ((tableName == null) || (oldTableName == null)) { throw new SchemaException(Pass.FIRST, MISSING_UNQUALIFIED_IDENTIFIER_ERROR_MSG); } PECreateTableStatement pecs = null; UnqualifiedName tabName = tableName.getUnqualified(); TableInstance ti = pc.getCurrentPEDatabase().getSchema().buildInstance(pc, tabName, lockInfo); if (Boolean.TRUE.equals(ine) && opts.isResolve()) { // see if the table already exists // UnqualifiedName dbName = null; if (ti != null) { if (ti.getAbstractTable().isView()) throw new SchemaException(Pass.FIRST, tabName + " is a view, cannot create like"); pecs = new PECreateTableStatement(ti.getAbstractTable().asTable(), ine, true); return pecs; } } PEAbstractTable<?> tab = null; if (ti != null) tab = ti.getAbstractTable(); // see if the table already exists if (tab == null) { Name dbName = null; // now need to determine if source or old table exists too if (oldTableName.isQualified()) { dbName = ((QualifiedName) oldTableName).getNamespace(); } if (dbName == null) { dbName = (pc.getCurrentDatabase() == null) ? null : pc.getCurrentDatabase().getName(); } PEDatabase db = pc.findPEDatabase(dbName); if (db == null) throw new SchemaException(Pass.FIRST, "No such database: '" + dbName + "'"); TableInstance otab = db.getSchema().buildInstance(pc, oldTableName.getUnqualified(), lockInfo); if (otab == null) { throw new SchemaException(Pass.FIRST, "No source table: '" + oldTableName + "'"); } if (otab.getAbstractTable().isView()) throw new SchemaException(Pass.FIRST, "Source table is a view"); PETable oldTab = otab.getAbstractTable().asTable(); String cts = oldTab.getDeclaration(); if (cts == null) throw new SchemaException(Pass.FIRST, "Unable to obtain source create table statement"); tab = oldTab.recreate(pc, cts, lockInfo); tab.setName(tabName); tab.asTable().removeForeignKeys(pc); tab.asTable().setDeclaration(pc, tab.asTable()); } pecs = new PECreateTableStatement(tab.asTable(), ine, false); return pecs; } public Statement buildCreateTable(Name tableName, List<TableComponent<?>> fieldsAndKeys, UnresolvedDistributionVector indv, Name groupName, List<TableModifier> modifiers, Boolean ine, Pair<UnqualifiedName, List<UnqualifiedName>> discriminator, ProjectingStatement ctas, boolean temporary) { if (tableName == null) { throw new SchemaException(Pass.FIRST, MISSING_UNQUALIFIED_IDENTIFIER_ERROR_MSG); } PECreateTableStatement pecs = null; if (Boolean.TRUE.equals(ine) && opts.isResolve()) { // see if the table already exists // UnqualifiedName dbName = null; TableInstance ti = new TableResolver().withMTChecks().lookupTable(pc, tableName, lockInfo); if (ti != null) { if (ti.getAbstractTable().isView()) throw new SchemaException(Pass.FIRST, tableName + " is a view (cannot recreate)"); pecs = new PECreateTableStatement(ti.getAbstractTable().asTable(), ine, true); } } PEPersistentGroup pesg = null; if (groupName != null) { pesg = pc.findStorageGroup(groupName); if (pesg == null) throw new SchemaException(Pass.SECOND, "No such persistent group: " + groupName.getSQL()); } List<TableComponent<?>> actualFieldsAndKeys = null; ListOfPairs<PEColumn, Integer> ctaProjectionOffsets = null; if (ctas != null) { ctaProjectionOffsets = new ListOfPairs<PEColumn, Integer>(); // the columns are ordered like so: // first all columns that are only explicitly declared // then all columns that are only implicitly or both declared // we will determine projection column types at runtime, and use a placeholder in the meantime ListSet<PEColumn> inproj = new ListSet<PEColumn>(); ProjectionInfo pmd = ctas.getProjectionMetadata(pc); for (int i = 1; i <= pmd.getWidth(); i++) { int offset = i - 1; ColumnInfo ci = pmd.getColumnInfo(i); UnqualifiedName cname = new UnqualifiedName(ci.getAlias()); PEColumn matching = lookupInProcessColumn(cname, true); if (matching != null) { ctaProjectionOffsets.add(matching, offset); inproj.add(matching); continue; } // declare the column with a placeholder type PEColumn viaCTA = PECreateTableAsSelectStatement.createColumnFromExpression(pc, ci, ctas.getProjections().get(0).get(offset)); scope.registerColumn(viaCTA); ctaProjectionOffsets.add(viaCTA, offset); inproj.add(viaCTA); } actualFieldsAndKeys = new ArrayList<TableComponent<?>>(); // first do the decl only bits for (Iterator<TableComponent<?>> iter = fieldsAndKeys.iterator(); iter.hasNext();) { TableComponent<?> tc = iter.next(); if (tc instanceof PEKey) continue; PEColumn pec = (PEColumn) tc; if (!inproj.contains(pec)) actualFieldsAndKeys.add(pec); iter.remove(); } // now all the projection fields actualFieldsAndKeys.addAll(inproj); // now we have all columns declared, resolve anything that was forward for (Iterator<TableComponent<?>> iter = fieldsAndKeys.iterator(); iter.hasNext();) { TableComponent<?> tc = iter.next(); if (tc instanceof PEKey) { PEKey pek = (PEKey) tc; actualFieldsAndKeys.add(pek.resolve(pc, scope)); } else { actualFieldsAndKeys.add(tc); } } } else { actualFieldsAndKeys = fieldsAndKeys; } // resolve the distribution vector DistributionVector dv = null; if (indv != null) dv = indv.resolve(pc, this); if (pecs == null) { // unpack the dbstuff PETable newTab = null; // we want to inject when both the dist vect and the discriminator are null; if either is non-null the dist info // was specified if (dv == null && discriminator == null) { newTab = buildTable(tableName, actualFieldsAndKeys, null, pesg, modifiers, ctaProjectionOffsets != null, temporary); if ((pc.getCapability() == Capability.PARSING_ONLY) || (opts != null && opts.isOmitMetadataInjection())) { dv = new DistributionVector(pc, null, DistributionVector.Model.RANDOM); newTab.setDistributionVector(pc, dv); } else try { if (!TemplateManager.inject(pc, newTab.getPEDatabase(pc), newTab)) { if (newTab.getPEDatabase(pc).hasStrictTemplateMode()) { throw new SchemaException(Pass.SECOND, "No matching template found for table " + newTab.getName().getSQL()); } dv = new DistributionVector(pc, null, DistributionVector.Model.RANDOM); newTab.setDistributionVector(pc, dv); } } catch (Exception e) { throw new SchemaException(Pass.SECOND, e); } } else if (dv != null) { newTab = buildTable(tableName, actualFieldsAndKeys, dv, pesg, modifiers, ctaProjectionOffsets != null, temporary); } else if (discriminator != null) { // newTab will be the base table on the container - so change the dist vect on it to be the container PEContainer container = pc.findContainer(discriminator.getFirst()); if (container == null) throw new SchemaException(Pass.SECOND, "No such container: " + discriminator.getFirst().getSQL()); if (container.hasBaseTable()) { throw new SchemaException(Pass.SECOND, "Cannot set table '" + tableName + "' as a base table because container '" + discriminator.getFirst().getSQL() + "' already has a base table."); } dv = new ContainerDistributionVector(pc, container, false); newTab = buildTable(tableName, fieldsAndKeys, dv, pesg, modifiers, ctaProjectionOffsets != null, temporary); // newTab is actually the container base table - so go resolve the columns now and so mark them List<UnqualifiedName> colNames = discriminator.getSecond(); for (int i = 0; i < colNames.size(); i++) { UnqualifiedName un = colNames.get(i); PEColumn pec = newTab.lookup(pc, un); if (pec == null) throw new SchemaException(Pass.SECOND, "No such column: " + un.getSQL() + " - cannot build discriminator"); pec.setContainerDistributionValuePosition(i + 1); } container.setBaseTable(pc, newTab); } else { throw new SchemaException(Pass.SECOND, "Unable to determine declared distribution for table " + tableName.getSQL()); } if (ctas == null) pecs = new PECreateTableStatement(newTab, ine, false); else pecs = new PECreateTableAsSelectStatement(newTab, ine, false, ctas, ctaProjectionOffsets); } Statement out = pecs; if (pc.getCapability() != Capability.PARSING_ONLY && !pc.getOptions().isTSchema()) { // containers don't generally have a separate policy at creation time - check for it on // the dist vect if (pecs.getCreated().get().getDistributionVector(pc).isContainer()) { out = ContainerPolicyContext.modifyCreateTable(pc, pecs); } else { out = pc.getPolicyContext().modifyCreateTable(pecs); } } return out; } public Statement buildDropTableStatement(List<Name> givenNames, Boolean ifExists, boolean tempTabs) { if (givenNames == null) { throw new SchemaException(Pass.FIRST, MISSING_UNQUALIFIED_IDENTIFIER_ERROR_MSG); } TableResolver resolver = new TableResolver().withMTChecks() .withDatabaseFunction(new UnaryProcedure<Database<?>>() { @Override public void execute(Database<?> object) { if (!(object instanceof PEDatabase)) throw new SchemaException(Pass.SECOND, "Invalid database for drop table: '" + object.getName() + "'"); } }); List<TableKey> tblKeys = new ArrayList<TableKey>(); List<Name> unknownTables = new ArrayList<Name>(); for (Name givenName : givenNames) { TableInstance ti = resolver.lookupTable(pc, givenName, lockInfo); if (ti == null) { unknownTables.add(givenName); } else { if (tempTabs && !ti.getTableKey().isUserlandTemporaryTable()) throw new SchemaException( new ErrorInfo(AvailableErrors.UNKNOWN_TABLE, givenName.getUnquotedName().get())); tblKeys.add(ti.getTableKey()); } } // we can throw if there is no valid existing table if ((tblKeys.size() == 0) && unknownTables.size() > 0) { if (!Boolean.TRUE.equals(ifExists)) throw new SchemaException(Pass.SECOND, "No such table(s) '" + StringUtils.join(unknownTables, ",") + "'"); } PEDropTableStatement stmt = new PEDropTableStatement(pc, tblKeys, unknownTables, ifExists, tempTabs); return pc.getPolicyContext().modifyDropTable(stmt); } private Database<?> findDatabase(Name givenName) { Database<?> ondb = pc.getCurrentDatabase(false); if (ondb == null || givenName.isQualified()) { if (!givenName.isQualified()) pc.getCurrentDatabase(true); QualifiedName qname = (QualifiedName) givenName; UnqualifiedName dbName = qname.getNamespace(); if (ondb == null || !ondb.getName().equals(dbName)) { ondb = pc.findDatabase(dbName); if (ondb == null) return ondb; } } return ondb; } public Statement buildDropDatabaseStatement(Name dbName, Boolean ifExists, boolean dropmt, String tag) { if (dbName == null) { throw new SchemaException(Pass.FIRST, MISSING_UNQUALIFIED_IDENTIFIER_ERROR_MSG); } return pc.getPolicyContext().buildDropDatabaseStatement(dbName, ifExists, dropmt, tag); } public Statement buildShowCreateDatabaseQuery(String onInfoSchemaTable, Name objectName, Boolean ifNotExists) { ShowSchemaBehavior ist = Singletons.require(InformationSchemaService.class) .lookupShowTable(new UnqualifiedName(onInfoSchemaTable)); if (ist == null) throw new MigrationException("Need to add info schema table for " + onInfoSchemaTable); ShowOptions opts = new ShowOptions(); if (Boolean.TRUE.equals(ifNotExists)) opts = opts.withIfNotExists(); return ist.buildUniqueStatement(pc, objectName, opts); } public Statement buildUseDatabaseStatement(Name firstName) { if (firstName == null) throw new SchemaException(Pass.FIRST, MISSING_UNQUALIFIED_IDENTIFIER_ERROR_MSG); if (pc.getCapability() == Capability.PARSING_ONLY) return new SessionStatement("use " + firstName.getSQL()) { @Override public boolean isPassthrough() { return false; } }; return pc.getPolicyContext().buildUseDatabaseStatement(firstName); } /** * @param projName * @return */ public Statement buildUseProjectStatement(Name projName) { // no longer supported (just for the persistent version) throw new ParserException(Pass.FIRST, "No support for use project for persistent schema"); } /** * @param jdbcURL * @return */ public Statement buildCreateCatalog(Token jdbcURL) { throw new SchemaException(Pass.SECOND, "No support for create catalog."); } @SuppressWarnings("unchecked") public Statement buildCreateDatabase(Name dbName, Boolean ifNotExists, String tag, MultitenantMode mm, List<Pair<?, ?>> consolidatedDefs) { if (dbName == null) { throw new SchemaException(Pass.FIRST, MISSING_UNQUALIFIED_IDENTIFIER_ERROR_MSG); } Name charSetValue = null; Name collationValue = null; Name pgName = null; FKMode fkMode = null; Pair<Name, TemplateMode> templateDecl = null; for (Pair<?, ?> p : consolidatedDefs) { if (p.getFirst() instanceof String) { String key = (String) p.getFirst(); if ("fkmode".equals(key)) { fkMode = (FKMode) p.getSecond(); continue; } Name value = (Name) p.getSecond(); if ("charset".equals(key)) { charSetValue = value; } else if ("collate".equals(key)) { collationValue = value; } else if ("pers_group".equals(key)) { pgName = value; } else { throw new SchemaException(Pass.FIRST, "Unknown create db attribute: " + key); } } else if (p.getSecond() instanceof TemplateMode) { templateDecl = (Pair<Name, TemplateMode>) p; } } if (templateDecl == null) { templateDecl = new Pair<Name, TemplateMode>(null, TemplateMode.getCurrentDefault(pc.getConnection())); } final Pair<String, String> charSetCollationPair = getCharsetCollationPair(charSetValue, collationValue); if (pc.getCapability() == Capability.PARSING_ONLY) { PEDatabase pdb = new PEDatabase(null, dbName.getUnquotedName(), null, templateDecl, mm, fkMode, charSetCollationPair.getFirst(), charSetCollationPair.getSecond()); PECreateStatement<PEDatabase, UserDatabase> cdb = new PECreateDatabaseStatement(pdb, false, ifNotExists, tag, false); return cdb; } return pc.getPolicyContext().buildCreateDatabase(dbName, pgName, templateDecl, ifNotExists, tag, mm, fkMode, charSetCollationPair.getFirst(), charSetCollationPair.getSecond()); } public Statement buildAlterDatabaseStatement(final Name dbName, final Name charSetName, final Name collationName) { if ((charSetName == null) && (collationName == null)) { throw new SchemaException(Pass.SECOND, "Can't alter database '" + dbName.getSQL() + "'; syntax error"); } final Pair<String, String> charSetCollationPair = getCharsetCollationPair(charSetName, collationName); final PEDatabase db = getAlterDatabase(dbName); return new AlterDatabaseStatement(db, charSetCollationPair.getFirst(), charSetCollationPair.getSecond()); } public Statement buildAlterDatabaseStatement(final Name dbName, final Pair<Name, TemplateMode> templateDeclaration) { final PEDatabase db = getAlterDatabase(dbName); final Pair<Name, TemplateMode> checkedTemplateDecl = TemplateManager.findTemplateForDatabase(pc, dbName, templateDeclaration.getFirst(), templateDeclaration.getSecond()); return new AlterDatabaseTemplateStatement(db, checkedTemplateDecl); } public Pair<Name, TemplateMode> buildTemplateDeclaration(final Name templateName, TemplateMode mode) { final String templateNameIdentifier = templateName.get(); if (TemplateMode.hasModeForName(templateNameIdentifier)) { if (templateNameIdentifier.equals(TemplateMode.OPTIONAL.toString())) { if (mode == null) { return new Pair<Name, TemplateMode>(null, TemplateMode.OPTIONAL); } } throw new SchemaException(Pass.SECOND, "Redundant mode specification '" + mode.toString() + "'; syntax error"); } if ((mode != null) && !mode.requiresTemplate()) { throw new SchemaException(Pass.SECOND, "Redundant template specification '" + templateName.getSQL() + "' for " + VariableConstants.TEMPLATE_MODE_NAME + " '" + mode.toString() + "'; syntax error"); } if (mode == null) { mode = TemplateMode.getCurrentDefault(pc.getConnection()); } return new Pair<Name, TemplateMode>(templateName, mode); } private PEDatabase getAlterDatabase(final Name dbName) { final Database<?> db = (dbName != null) ? pc.findDatabase(dbName) : pc.getCurrentDatabase(); if (db == null) { throw new SchemaException(Pass.SECOND, "Can't alter database '" + dbName.getSQL() + "'; database doesn't exist"); } else if (!(db instanceof PEDatabase)) { throw new SchemaException(Pass.SECOND, "Can't alter database '" + dbName.getSQL() + "'; target is not alterable"); } return (PEDatabase) db; } private Pair<String, String> getCharsetCollationPair(final Name charSetName, final Name collationName) { return CharsetCollationModifierBuilder.buildCharsetCollationNamePair(charSetName, collationName, getNativeCharSetCatalog(), getNativeCollationCatalog()); } public Statement buildCreatePersistentInstance(Name persistentInstanceName, List<Pair<Name, LiteralExpression>> options) { pc.getPolicyContext().checkRootPermission("create a persistent instance"); if (persistentInstanceName == null) throw new SchemaException(Pass.SECOND, "Persistent instance name must be specified."); PESiteInstance pesi = pc.findSiteInstance(persistentInstanceName); if (pesi != null) throw new SchemaException(Pass.SECOND, "Persistent instance " + persistentInstanceName + " already exists."); return PECreateSiteInstanceStatement.build(pc, persistentInstanceName, options); } public Statement buildAlterPersistentInstanceStatement(Name persistentInstanceName, List<Pair<Name, LiteralExpression>> options) { pc.getPolicyContext().checkRootPermission("change a persistent instance"); PESiteInstance pesi = pc.findSiteInstance(persistentInstanceName); if (pesi == null) throw new SchemaException(Pass.SECOND, "No such persistent instance: " + persistentInstanceName.getUnqualified().get()); return new PEAlterSiteInstanceStatement(pesi, options); } @SuppressWarnings({ "unchecked", "rawtypes" }) public Statement buildDropPersistentInstanceStatement(Name persistentInstanceName) { pc.getPolicyContext().checkRootPermission("drop a persistent instance"); PESiteInstance pesi = pc.findSiteInstance(persistentInstanceName); if (pesi == null) throw new SchemaException(Pass.SECOND, "No such persistent instance: " + persistentInstanceName.getUnqualified().get()); return new PEDropStatement(PESiteInstance.class, null, true, pesi, PERSISTENT_INSTANCE); } public Statement buildCreatePersistentSite(Name persistentSiteName, List<Pair<Name, LiteralExpression>> opts) { pc.getPolicyContext().checkRootPermission("create a persistent site"); PEStorageSite pess = pc.findStorageSite(persistentSiteName); if (pess != null) throw new SchemaException(Pass.SECOND, "Persistent site " + persistentSiteName.getSQL() + " already exists."); return PECreateStorageSiteStatement.build(pc, persistentSiteName, opts); } public Statement buildCreatePersistentSite(Name persistentSiteName, String url, String user, String password) { pc.getPolicyContext().checkRootPermission("create a persistent site"); PEStorageSite pess = pc.findStorageSite(persistentSiteName); if (pess != null) throw new SchemaException(Pass.SECOND, "Persistent site " + persistentSiteName.getSQL() + " already exists."); // the jdbcURL probably still has the quotes on - have to strip those String stripped = Singletons.require(DBNative.class).getValueConverter().convertStringLiteral(url); // convert it into the other format List<Pair<Name, LiteralExpression>> opts = new ArrayList<Pair<Name, LiteralExpression>>(); opts.add(buildConfigOption(new UnqualifiedName("URL"), LiteralExpression.makeStringLiteral(stripped))); opts.add(buildConfigOption(new UnqualifiedName("USER"), LiteralExpression.makeStringLiteral(user))); opts.add(buildConfigOption(new UnqualifiedName("PASSWORD"), LiteralExpression.makeStringLiteral(password))); return PECreateStorageSiteStatement.build(pc, persistentSiteName, opts); } @SuppressWarnings("unchecked") public Statement buildCreatePersistentSite(Name persistentSiteName, String haType, Name masterName, List<Name> siteInstances) { pc.getPolicyContext().checkRootPermission("create a persistent site"); PEStorageSite pess = pc.findStorageSite(persistentSiteName); if (pess != null) throw new SchemaException(Pass.SECOND, "Persistent site " + persistentSiteName.getSQL() + " already exists."); PESiteInstance masterPersistentInstance = pc.findSiteInstance(masterName); if (masterPersistentInstance == null) { throw new SchemaException(Pass.SECOND, "No such persistent instance: " + masterName.getQuoted()); } List<PESiteInstance> peSiteInstances = null; if (siteInstances == null) peSiteInstances = Collections.EMPTY_LIST; else peSiteInstances = Functional.apply(siteInstances, new UnaryFunction<PESiteInstance, Name>() { @Override public PESiteInstance evaluate(Name object) { PESiteInstance pesi = pc.findSiteInstance(object); if (pesi == null) throw new SchemaException(Pass.SECOND, "No such persistent instance: " + object.getQuoted()); return pesi; } }); return new PECreateStorageSiteStatement( new PEStorageSite(pc, persistentSiteName, haType, masterPersistentInstance, peSiteInstances)); } public Statement buildAlterPersistentSite(Name persistentSiteName, String haType) { pc.getPolicyContext().checkRootPermission("alter a persistent site"); PEStorageSite pess = pc.findStorageSite(persistentSiteName); if (pess == null) throw new SchemaException(Pass.SECOND, "No such persistent site: " + persistentSiteName.getSQL()); return new PEAlterPersistentSite(pess, haType); } public Statement buildAlterPersistentSite(Name persistentSiteName, Name masterName) { pc.getPolicyContext().checkRootPermission("alter a persistent site"); PEStorageSite pess = pc.findStorageSite(persistentSiteName); if (pess == null) throw new SchemaException(Pass.SECOND, "No such persistent site: " + persistentSiteName.getSQL()); PESiteInstance masterSiteInstance = pc.findSiteInstance(masterName); if (masterSiteInstance == null) throw new SchemaException(Pass.SECOND, "No such persistent instance: " + masterName.getUnqualified().get()); return new PEAlterPersistentSite(pess, masterSiteInstance); } public Statement buildAlterPersistentSite(Name persistentSiteName, Boolean addOperation, List<Name> siteInstanceNames) { pc.getPolicyContext().checkRootPermission("alter a persistent site"); PEStorageSite pess = pc.findStorageSite(persistentSiteName); if (pess == null) throw new SchemaException(Pass.SECOND, "No such persistent site: " + persistentSiteName.getSQL()); ArrayList<PESiteInstance> siteInstances = new ArrayList<PESiteInstance>(); for (Name n : siteInstanceNames) { PESiteInstance pesi = pc.findSiteInstance(n); if (pesi == null) throw new SchemaException(Pass.SECOND, "No such persistent instance: " + n.getUnqualified().get()); siteInstances.add(pesi); } return new PEAlterPersistentSite(pess, addOperation, siteInstances); } public Statement buildDropPersistentSiteStatement(Name persistentSiteName) { pc.getPolicyContext().checkRootPermission("drop a persistent site"); PEStorageSite pess = pc.findStorageSite(persistentSiteName); if (pess == null) throw new SchemaException(Pass.SECOND, "No such persistent site: " + persistentSiteName.getSQL()); PEDropStorageSiteStatement out = new PEDropStorageSiteStatement(pess); out.ensureUnreferenced(pc); return out; } @SuppressWarnings("unchecked") public Statement buildCreatePersistentGroup(Name groupName, List<Name> sites) { pc.getPolicyContext().checkRootPermission("create a persistent group"); PEPersistentGroup pesg = pc.findStorageGroup(groupName); if (pesg != null) throw new SchemaException(Pass.SECOND, "Persistent group " + groupName.getSQL() + " already exists"); List<PEStorageSite> pesites = null; if (sites == null) pesites = Collections.EMPTY_LIST; else pesites = Functional.apply(sites, new UnaryFunction<PEStorageSite, Name>() { @Override public PEStorageSite evaluate(Name object) { PEStorageSite pess = pc.findStorageSite(object); if (pess == null) throw new SchemaException(Pass.SECOND, "No such persistent site: " + object.getQuoted()); return pess; } }); return new PECreateStatement<PEPersistentGroup, PersistentGroup>( new PEPersistentGroup(pc, groupName, pesites), true, PERSISTENT_GROUP_TAG, false); } public PEColumn lookupInProcessColumn(Name n, boolean missingOk) { PEColumn c = scope.lookupInProcessColumn(n); if (c == null) c = scope.lookupInProcessColumn(n.getCapitalized()); if (c == null && !missingOk) throw new SchemaException(Pass.SECOND, "No such column: " + n.getSQL()); return c; } public UnresolvedDistributionVector buildDistributionVector(DistributionVector.Model model, List<Name> columnNames, Name rangeOrContainer) { return new UnresolvedDistributionVector(model, columnNames, rangeOrContainer); } public ColumnModifier buildColumnModifier(ColumnModifierKind tag) { return new ColumnModifier(tag); } public ColumnModifier buildDefaultValue(ExpressionNode v) { return new DefaultValueModifier(v); } public ColumnModifier buildEnumDefaultValue(Type typeDef, ExpressionNode value) { final DBEnumType enumValues = (DBEnumType) typeDef; final ActualLiteralExpression defaultValue = (ActualLiteralExpression) value; /* * Integral default values are treated as 1-based indices into the ENUM. */ if (defaultValue.isIntegerLiteral()) { final int valuePositionIndex = ((Long) defaultValue.getValue()).intValue(); try { final LiteralExpression valueAtIndex = enumValues.getValueAt(valuePositionIndex); return new DefaultValueModifier(valueAtIndex); } catch (final IndexOutOfBoundsException e) { throw new SchemaException(Pass.SECOND, "No value at position " + valuePositionIndex + " in the " + enumValues.getEnumerationTypeName().toUpperCase(), e); } } return new DefaultValueModifier(value); } public TypeModifier buildCollationSpec(Name collated) { return new StringTypeModifier(TypeModifierKind.COLLATE, collated.getUnquotedName().get()); } public TypeModifier buildCharsetSpec(Name spec) { return new StringTypeModifier(TypeModifierKind.CHARSET, spec.getUnquotedName().get()); } public Set<TableModifier> buildCharsetCollationModifiers(final CharsetCollationModifierBuilder builder) { if (builder.hasValues()) { return builder.buildModifiers(getNativeCharSetCatalog(), getNativeCollationCatalog()); } return Collections.EMPTY_SET; } public ColumnModifier buildOnUpdate() { return new ColumnModifier(ColumnModifierKind.ONUPDATE); // buildIdentifierLiteral("CURRENT_TIMESTAMP")); } public Name buildKeywordName(String in) { return new UnqualifiedName(in); } public Name buildIdentifier(String in, Object tree) { Name out = new UnqualifiedName(in, SourceLocation.make(tree)); return out; } public Name buildIdentifier(Token tok) { Name out = new UnqualifiedName(tok.getText(), SourceLocation.make(tok)); return out; } public Object buildLiteralValue(String in) { return in; } public Integer buildIntegerLiteral(String in) { try { return Integer.parseInt(in); } catch (NumberFormatException nfe) { throw new ParserException(Pass.SECOND, "Bad integer value: '" + in + "': " + nfe.getMessage(), nfe); } } private LiteralExpression asLiteral(ExpressionNode e) { if (e instanceof LiteralExpression) { return (LiteralExpression) e; } else if (e == null) { return null; } else { throw new ParserException(Pass.SECOND, "Expecting literal, got: " + e); } } private Integer asIntegralLiteral(ExpressionNode e) { LiteralExpression integLit = asLiteral(e); Object lv = null; if (integLit instanceof DelegatingLiteralExpression) { DelegatingLiteralExpression dle = (DelegatingLiteralExpression) integLit; lv = literals.get(dle.getPosition()).getSecond(); } else { lv = integLit.getValue(pc.getValues()); } if (lv instanceof Long) { return ((Long) lv).intValue(); } throw new ParserException(Pass.SECOND, "Expecting integral literal, got: " + lv); } public SizeTypeAttribute buildSizeTypeAttribute(ExpressionNode a, ExpressionNode b) { // i.e. (x, y) if (b == null) return new SizeTypeAttribute(asIntegralLiteral(a)); Integer precision = asIntegralLiteral(a); Integer scale = asIntegralLiteral(b); return new FloatSizeTypeAttribute(precision, precision, scale); } @SuppressWarnings("unchecked") public BasicType buildType(List<Name> typeNames, SizeTypeAttribute sizing, List<TypeModifier> modifiers) { return BasicType.buildType(typeNames, Collections.singletonList(sizing), (modifiers == null ? Collections.EMPTY_LIST : modifiers), pc.getTypes()); } public BasicType buildEnum(boolean isSet, List<LiteralExpression> values, List<TypeModifier> modifiers) { return DBEnumType.make(isSet, values, modifiers, pc.getTypes()); } public TypeModifier buildTypeModifier(TypeModifierKind tmk) { return new TypeModifier(tmk); } public TypeModifier buildComparisonModifier(String className) { String stripped = Singletons.require(DBNative.class).getValueConverter().convertStringLiteral(className); return new StringTypeModifier(TypeModifierKind.COMPARISON, stripped); } public List<TableComponent<?>> buildFieldDefinition(Name fieldName, Type type, List<ColumnModifier> attrs, String commentText) throws SchemaException { Comment comment = null; if (commentText != null) { comment = buildTableFieldComment(fieldName, commentText); } List<ColumnKeyModifier> inlineKeys = new ArrayList<ColumnKeyModifier>(); for (Iterator<ColumnModifier> iter = attrs.iterator(); iter.hasNext();) { ColumnModifier cm = iter.next(); if (cm.getTag() == ColumnModifierKind.INLINE_KEY) { inlineKeys.add((ColumnKeyModifier) cm); iter.remove(); } } List<TableComponent<?>> out = new ArrayList<TableComponent<?>>(); PEColumn nc = null; if (pc.getCapability() == Capability.PARSING_ONLY || !(pc.getPolicyContext().allowTenantColumnDeclaration() && TenantColumn.TENANT_COLUMN.equals(fieldName.get()))) nc = scope.registerColumn(PEColumn.buildColumn(pc, fieldName, type, attrs, comment, inlineKeys)); else nc = scope.registerColumn(new TenantColumn(pc)); out.add(nc); // collapse the case where we see UNIQUE, KEY if (inlineKeys.size() > 1) { int uniqued = -1; int keyed = -1; for (int i = 0; i < inlineKeys.size(); i++) { if (inlineKeys.get(i).getConstraint() == ConstraintType.UNIQUE && uniqued == -1) uniqued = i; else if (inlineKeys.get(i).getConstraint() == null && keyed == -1) keyed = i; } if (uniqued > -1 && keyed > uniqued) inlineKeys.remove(keyed); } for (ColumnKeyModifier ckm : inlineKeys) { // first build the key @SuppressWarnings("unchecked") PEKey pek = buildKey(null, null, Collections.singletonList((PEKeyColumnBase) new PEKeyColumn(nc, null, -1L)), Collections.EMPTY_LIST); if (ckm.getConstraint() != null) pek = withConstraint(ckm.getConstraint(), null, pek); out.add(pek); } return out; } public PEKey buildKey(IndexType type, Name name, List<PEKeyColumnBase> cols, List<Object> options) throws SchemaException { // unpack the options in case we have anything lurking IndexType postSpecifiedType = null; Comment anyComment = null; for (Object o : options) { if (o instanceof String) { anyComment = buildTableFieldComment(name, (String) o); } else if (o instanceof IndexType) { postSpecifiedType = (IndexType) o; } else { throw new SchemaException(Pass.SECOND, "Unknown key option: " + o); } } IndexType actualType = type; if (actualType == null) actualType = postSpecifiedType; if (actualType == null) actualType = IndexType.BTREE; return new PEKey(name, actualType, cols, anyComment); } public PEKey withConstraint(ConstraintType ct, Name symbolName, PEKey pek) { pek.setConstraint(ct); if (symbolName != null) pek.setSymbol(symbolName.getUnqualified()); return pek; } public ColumnModifier buildInlineKeyModifier(ConstraintType ct) { return new ColumnKeyModifier(ct); } public PEKeyColumnBase buildPEKeyColumn(Name identifier, ExpressionNode length, ExpressionNode cardinality) { PEColumn c = lookupInProcessColumn(identifier, true); Integer keyLength = (length == null ? null : asIntegralLiteral(length)); long keyCardinality = (cardinality == null ? -1L : asIntegralLiteral(cardinality)); if (c == null) return new PEForwardKeyColumn(null, identifier.getUnqualified(), keyLength, keyCardinality); else return new PEKeyColumn(c, keyLength, keyCardinality); } @SuppressWarnings("cast") public PEKey buildForeignKey(Name name, List<PEKeyColumnBase> mycols, Name targetTableName, List<UnqualifiedName> targetColumns, ForeignKeyAction deleteAction, ForeignKeyAction updateAction) { // are unknown tables ok? boolean required = (pc.getCapability() != Capability.PARSING_ONLY && KnownVariables.FOREIGN_KEY_CHECKS .getSessionValue(pc.getConnection().getVariableSource()).booleanValue()); // figure out whether the target table is known or not PETable targetTab = null; Database<?> db = null; UnqualifiedName candidateName = null; if (targetTableName.isQualified()) { QualifiedName qn = (QualifiedName) targetTableName; UnqualifiedName ofdb = qn.getNamespace(); candidateName = qn.getUnqualified(); db = pc.findPEDatabase(ofdb); if (db == null && required) throw new SchemaException(Pass.FIRST, "No such database: " + ofdb); } else { if (pc.getCapability() != Capability.PARSING_ONLY) db = pc.getCurrentDatabase(); if (db == null && required) throw new SchemaException(Pass.FIRST, "No current database"); candidateName = (UnqualifiedName) targetTableName; } if (db != null) { boolean mtchecks = (pc.getCapability() != Capability.PARSING_ONLY && !pc.getOptions().isDisableMTLookupChecks()); TableInstance ti = db.getSchema().buildInstance(pc, candidateName, lockInfo, mtchecks); if (ti == null && required && mtchecks) throw new SchemaException(Pass.FIRST, "No such table: " + targetTableName); if (ti != null) targetTab = ti.getAbstractTable().asTable(); } Name fullyQualifiedTargetName = null; if (targetTab == null) { if (targetTableName.isQualified()) fullyQualifiedTargetName = targetTableName; else if (db != null) fullyQualifiedTargetName = targetTableName.postfix(db.getName()); else if (pc.getCapability() == Capability.PARSING_ONLY) fullyQualifiedTargetName = targetTableName; else throw new SchemaException(Pass.FIRST, "No current database"); } // regardless of whether the target table is known, we need to convert the PEKeyColumns to PEForeignKeyColumns if (mycols.size() != targetColumns.size()) throw new SchemaException(Pass.FIRST, "Invalid foreign key declaration: source table names " + mycols.size() + " columns but references " + targetColumns.size()); List<PEKeyColumnBase> fkcols = new ArrayList<PEKeyColumnBase>(); for (int i = 0; i < mycols.size(); i++) { PEKeyColumnBase mine = mycols.get(i); UnqualifiedName targName = targetColumns.get(i); PEKeyColumnBase pefk = null; if (targetTab == null) { if (mine.isUnresolved()) pefk = new PEForwardForeignKeyColumn(null, mine.getName(), targName); else pefk = new PEForeignKeyColumn(mine.getColumn(), targName); } else { PEColumn targCol = targetTab.lookup(pc, targName); if (targCol == null) throw new SchemaException(Pass.SECOND, "No such column " + targName + " in " + targetTableName); if (mine.isUnresolved()) pefk = new PEForwardForeignKeyColumn(null, mine.getName(), targCol); else pefk = new PEForeignKeyColumn(mine.getColumn(), targCol); } fkcols.add(pefk); } return new PEForeignKey(pc, name, targetTab, fullyQualifiedTargetName, fkcols, updateAction == null ? ForeignKeyAction.RESTRICT : updateAction, deleteAction == null ? ForeignKeyAction.RESTRICT : deleteAction); } public PETable buildTable(Name tableName, List<TableComponent<?>> fieldsAndKeys, DistributionVector dv, PEPersistentGroup sg, List<TableModifier> modifiers, boolean nascent, boolean temporary) { if (tableName == null) { throw new SchemaException(Pass.FIRST, MISSING_UNQUALIFIED_IDENTIFIER_ERROR_MSG); } Database<?> cdb = null; Name unqualifiedTableName = tableName; if (pc.getCapability() != Capability.PARSING_ONLY) { cdb = pc.getCurrentDatabase(false); if (cdb == null || tableName.isQualified()) { if (cdb == null && !tableName.isQualified()) throw new SchemaException(Pass.SECOND, "Current database not set"); QualifiedName qname = (QualifiedName) tableName; UnqualifiedName leading = qname.getNamespace(); if (cdb == null || !cdb.getName().equals(leading)) { cdb = pc.findDatabase(leading); if (cdb == null) throw new SchemaException(Pass.SECOND, "No such database: '" + leading + "'"); } unqualifiedTableName = tableName.getUnqualified(); } if (!(cdb instanceof PEDatabase)) throw new SchemaException(Pass.SECOND, "Invalid database for table creation: '" + cdb.getName() + "'"); } // the dv should have the container here, if applicable PETable newtab = null; if (nascent || temporary) { ComplexPETable ctab = new ComplexPETable(pc, unqualifiedTableName, fieldsAndKeys, dv, modifiers, sg, (PEDatabase) cdb, TableState.SHARED); if (nascent) ctab.withCTA(); if (temporary) ctab.withTemporaryTable(pc); newtab = ctab; } else newtab = new PETable(pc, unqualifiedTableName, fieldsAndKeys, dv, modifiers, sg, (PEDatabase) cdb, TableState.SHARED); if (pc.getCapability() != Capability.PARSING_ONLY) { pc.getPolicyContext().modifyTablePart(newtab); } newtab.setDeclaration(pc, newtab); return newtab; } public ExpressionNode buildBooleanLiteral(Boolean v, Token orig) { if (opts.isActualLiterals()) { return new ActualLiteralExpression(v, orig.getType(), SourceLocation.make(orig), null); } else { DelegatingLiteralExpression litex = new DelegatingLiteralExpression(TokenTypes.BOOLEAN, SourceLocation.make(orig), this, literals.size(), null); literals.add(litex, v); return litex; } } public ExpressionNode buildColumnReference(Name parsedName) { if (resolveColumnsAsIdentifiers) return buildIdentifierLiteral(parsedName); if (opts.isResolve()) return scope.buildColumnInstance(pc, parsedName); return new ColumnInstance(parsedName, null, null); } protected ExpressionNode buildLiteral(Token o) { String t = o.getText(); int tok = o.getType(); if ((tok == TokenTypes.NULL) || (tok == TokenTypes.GLOBAL)) return new ActualLiteralExpression(t, tok, SourceLocation.make(o), null); // if it's a string literal, strip off any charset hint for later UnqualifiedName charsetHint = null; if (tok == TokenTypes.Character_String_Literal && t.length() > 0) { if (t.charAt(0) == '_') { int firstQuote = t.indexOf("'"); if (firstQuote == -1) firstQuote = t.indexOf("\""); String hint = t.substring(0, firstQuote); charsetHint = new UnqualifiedName(hint, false); t = t.substring(firstQuote); } if ((t.length() > 2) && (t.startsWith("\"") && (t.endsWith("\"")))) { t = PEStringUtils.escapeSingleQuoteIfNecessary(t); } } if (PEStringUtils.isHexNumber(t)) { tok = TokenTypes.Hex_String_Literal; } ExpressionNode ex = null; if (opts.isActualLiterals() || (pc.getCapability() != Capability.PARSING_ONLY && pc.isMutableSource())) ex = new ActualLiteralExpression(ValueConverter.INSTANCE.convertLiteral(t, tok), tok, SourceLocation.make(o), charsetHint); else { DelegatingLiteralExpression litex = new DelegatingLiteralExpression(tok, SourceLocation.make(o), this, literals.size(), charsetHint); literals.add(litex, ValueConverter.INSTANCE.convertLiteral(t, tok)); ex = litex; } return ex; } public ExpressionNode buildIdentifierLiteral(String ident) { return buildIdentifierLiteral(new UnqualifiedName(ident)); } public ExpressionNode buildIdentifierLiteral(Name ident) { return new IdentifierLiteralExpression(ident); } public ExpressionNode buildNullLiteral() { return LiteralExpression.makeNullLiteral(); } public ExpressionNode buildFunctionCall(FunctionName givenName, List<ExpressionNode> params, SetQuantifier sq, Object tree) { FunctionName unqualifiedName = givenName; if (pc.getCapability() != Capability.PARSING_ONLY) { if (unqualifiedName.isPipes()) { forceUncacheable(ValueManager.CacheStatus.NOCACHE_DYNAMIC_FUNCTION); SQLMode mode = KnownVariables.SQL_MODE.getSessionValue(pc.getConnection().getVariableSource()); if (mode.isPipesAsConcat()) { // rewrite to use the concat function call unqualifiedName = new FunctionName("CONCAT", -1, false); } else { // rewrite using or unqualifiedName = FunctionName.makeOr(); } } else if (unqualifiedName.isDoubleAmpersand()) { unqualifiedName = FunctionName.makeAnd(); } } @SuppressWarnings("unchecked") FunctionCall fc = new FunctionCall(unqualifiedName, (params == null ? Collections.EMPTY_LIST : params), sq, SourceLocation.make(tree)); if (EngineConstant.FUNCTION.has(fc, EngineConstant.DATABASE) || EngineConstant.FUNCTION.has(fc, EngineConstant.SCHEMA)) { forceUncacheable(ValueManager.CacheStatus.NOCACHE_DYNAMIC_FUNCTION); Database<?> peds = pc.getCurrentDatabase(false); if (peds == null) return LiteralExpression.makeNullLiteral(); return LiteralExpression.makeStringLiteral(peds.getName().get()); } else if (EngineConstant.FUNCTION.has(fc, EngineConstant.CURRENT_USER)) { forceUncacheable(ValueManager.CacheStatus.NOCACHE_DYNAMIC_FUNCTION); PEUser peu = pc.getCurrentUser().get(pc); if (peu == null) return LiteralExpression.makeNullLiteral(); // not entirely correct return LiteralExpression.makeStringLiteral(peu.getUserScope().getSQL()); } else if (EngineConstant.FUNCTION.has(fc, EngineConstant.LAST_INSERT_ID)) { forceUncacheable(ValueManager.CacheStatus.NOCACHE_DYNAMIC_FUNCTION); return LiteralExpression.makeLongLiteral(pc.getConnection().getLastInsertedId()); } else if (EngineConstant.FUNCTION.has(fc, EngineConstant.RAND)) { return buildRandCall(fc.getParameters()); } if (unqualifiedName.isAggregate() || isFunctionThatRequiresSetTimestampVariable( fc.getFunctionName().getUnqualified().get(), params)) { scope.registerFunction(fc); } return fc; } private boolean isFunctionThatRequiresSetTimestampVariable(String name, List<ExpressionNode> params) { boolean ret = false; if (TimestampVariableUtils.isTimestampFunction(name)) { // unix_timestamp also takes a parameter // so we only need to set the timestamp variable if there are no // parameter(s) if (TimestampVariableUtils.isFunctionUnixTimestamp(name)) { if (params != null && params.size() > 0) { ret = false; } else { ret = true; } } else { ret = true; } } return ret; } private UnqualifiedName castAlias(Name alias) { if (alias == null) return null; if (alias instanceof UnqualifiedName) return (UnqualifiedName) alias; throw new ParserException(Pass.SECOND, "Use of qualified identifier for alias: '" + alias.getSQL() + "'"); } public ExpressionNode buildTableInstance(Name name, Name alias) { return buildTableInstance(name, alias, null); } public ExpressionNode buildTableInstance(Name name, Name alias, List<IndexHint> hints) { if (name == null) { throw new SchemaException(Pass.FIRST, MISSING_UNQUALIFIED_IDENTIFIER_ERROR_MSG); } TableInstance ti = null; if (opts.isResolve()) { ti = scope.buildTableInstance(name, castAlias(alias), pc, lockInfo); } else { ti = new TableInstance(null, name, castAlias(alias), 0, opts.isResolve()); } if (hints != null) ti.setHints(hints); return ti; } public IndexHint buildIndexHint(HintType type, boolean isKey, HintTarget targ, List<UnqualifiedName> indexNames) { return new IndexHint(type, isKey, targ, indexNames); } public ExpressionNode buildWildcard(Token orig) { return new Wildcard(SourceLocation.make(orig)); } public ExpressionNode buildQuestionMark(CommonTree orig) { return new Parameter(SourceLocation.make(orig)); } public LimitSpecification buildLimitSpecification(ExpressionNode rowcount, ExpressionNode offset) { return new LimitSpecification(rowcount, offset); } /** * @param a * @param asc * @param desc * @return */ public SortingSpecification buildSortingSpecification(ExpressionNode a, Object asc, Object desc) { // default is asc, so as long as desc is non-null it is descending boolean direction = (desc == null); return new SortingSpecification(a, direction); } public FunctionName buildOperatorName(CommonTree ct) { return new FunctionName(ct.getText(), ct.getType(), true); } public FunctionName buildOperatorName(Token t) { return new FunctionName(t.getText(), t.getType(), true); } public FunctionName buildFunctionName(String v, int tokenKind) { return new FunctionName(v, tokenKind, false); } public FunctionName buildFunctionName(Token tok, boolean op) { return new FunctionName(tok.getText(), tok.getType(), op, SourceLocation.make(tok)); } public JoinSpecification buildJoinType(String primary) { return buildJoinType(primary, null, null); } public JoinSpecification buildJoinType(String primary, String natural, String outer) { StringBuilder buf = new StringBuilder(); if (natural != null) buf.append(natural).append(" "); if (primary != null) buf.append(primary).append(" "); if (outer != null) buf.append(outer); return JoinSpecification.makeJoinSpecification(buf.toString().toUpperCase()); } public JoinClauseType buildJoinClauseType(ExpressionNode node, List<Name> namedCols) { return new JoinClauseType(node, namedCols, ((namedCols != null) ? ClauseType.USING : ClauseType.ON)); } public JoinedTable buildJoinedTable(ExpressionNode target, JoinClauseType joinOn, JoinSpecification injoinType) { // JOIN is INNER JOIN JoinSpecification joinType = (injoinType == null ? buildJoinType("INNER") : injoinType); return new JoinedTable(target, (joinOn == null ? null : joinOn.getNode()), joinType, (joinOn == null ? null : joinOn.getColumnIdentifiers())); } public TableJoin buildTableJoin(ExpressionNode factor, List<JoinedTable> joins) { return new TableJoin(factor, joins); } public FromTableReference buildFromTableReference(ExpressionNode factor, List<JoinedTable> joins) { if (joins.isEmpty()) { return new FromTableReference(factor); } convertUsingColSpecToOnSpec(factor, joins); return new FromTableReference(new TableJoin(factor, joins)); } private void convertUsingColSpecToOnSpec(ExpressionNode factor, List<JoinedTable> joins) { if (!opts.isResolve()) return; List<UnqualifiedName> visibleAliases = new LinkedList<UnqualifiedName>(); if (factor instanceof TableInstance) visibleAliases.add(0, ((TableInstance) factor).getReferenceName(pc).getUnqualified()); for (JoinedTable jt : joins) { List<Name> usingColSpec = jt.getUsingColSpec(); if (usingColSpec != null && usingColSpec.size() > 0) { ExpressionNode jtTable = jt.getJoinedTo(); visibleAliases.add(0, ((TableInstance) jtTable).getReferenceName(pc).getUnqualified()); // turn USING column spec to equivalent ON t1.fieldn = t2.fieldn List<Name> unqparts = new ArrayList<Name>(); List<ExpressionNode> params = new ArrayList<ExpressionNode>(); List<ExpressionNode> equals = new ArrayList<ExpressionNode>(); // build list of t1.fieldn = t2.fieldn function(s) first List<ExpressionNode> functions = new ArrayList<ExpressionNode>(); for (Name name : usingColSpec) { params.clear(); // try to find the right table to hang the thing on int foff = -1; SchemaException any = null; int offset = -1; for (UnqualifiedName un : visibleAliases) { offset++; if (params.size() == 2) break; unqparts.clear(); unqparts.add(un); unqparts.add(name.getUnqualified()); try { ExpressionNode en = buildColumnReference(buildQualifiedName(unqparts)); if (params.isEmpty()) { params.add(en); foff = offset; } else if (foff > offset) params.add(en); else params.add(0, en); } catch (SchemaException se) { any = se; } } if (params.size() != 2) { if (any != null) throw any; throw new SchemaException(Pass.SECOND, "Failed to resolve using clause"); } equals.add(buildFunctionCall(FunctionName.makeEquals(), params, null, null)); } if (equals.size() > 0) { // build function(s) of AND'ed t1.fieldn = t2.fieldn functions.clear(); ExpressionNode current = null; ExpressionNode last = null; for (int i = 0; i < equals.size(); ++i) { current = equals.get(i); if (i > 0) { params.clear(); params.add(last); params.add(current); current = buildFunctionCall(FunctionName.makeAnd(), params, null, null); } last = current; } // just set using the last function Edge<?, ExpressionNode> edge = jt.getJoinOnEdge(); edge.add(last); // clear the using column spec // usingColSpec.clear(); } } } } public Name buildQualifiedName(List<Name> parts) { if (parts.size() == 1) return parts.get(0); ArrayList<UnqualifiedName> unqparts = new ArrayList<UnqualifiedName>(); for (Name n : parts) { if (n == null) continue; unqparts.addAll(n.getParts()); } Name out = new QualifiedName(unqparts); // verify that none of the parts (other than the last), is an asterisk for (Iterator<UnqualifiedName> iter = unqparts.iterator(); iter.hasNext();) { UnqualifiedName un = iter.next(); if (un.isAsterisk()) { if (iter.hasNext()) throw new SchemaException(Pass.FIRST, "Invalid qualified name: " + out.getSQL()); } } return out; } public Name buildNameFromStringLiteral(Object in) { CommonTree tree = (CommonTree) in; return new UnqualifiedName(PEStringUtils.dequote(tree.getText())); } public Name buildName(Token tok) { return new UnqualifiedName(tok.getText(), SourceLocation.make(tok)); } public Name buildName(Object in) { CommonTree tree = (CommonTree) in; return new UnqualifiedName(tree.getText(), SourceLocation.make(tree)); } public Name buildName(String in) { return new UnqualifiedName(in, null); } public ExpressionNode addGrouping(ExpressionNode in) { in.setGrouped(); return in; } public ProjectingStatement addGrouping(ProjectingStatement in) { in.setGrouped(true); return in; } // only 1 of the first four args will be non null. /** * @param plusSign * @param minusSign * @param binary * @param tilde * @param in * @param collate * @param collation * @return */ public ExpressionNode applyExprFlags(Token plusSign, Token minusSign, Token binary, Token tilde, ExpressionNode in, Token collate, Name collation) { ExpressionNode out = in; if (collation != null) { // collation is an operator - it has higher precedence than the other stuff; hack it in FunctionName fn = new FunctionName(collate.getText(), collate.getType(), true); FunctionCall fc = new FunctionCall(fn, out, new IdentifierLiteralExpression(collation)); out = fc; } if (minusSign != null) { out.setNegated(); } else if (tilde != null) { out.setBitNegated(); } else if (binary != null) { // this is a function call FunctionName fn = new FunctionName(binary.getText(), binary.getType(), true); FunctionCall fc = new FunctionCall(fn, out); out = fc; } return out; } public ExpressionNode buildDefaultKeywordExpr(Token orig) { return new Default(SourceLocation.make(orig)); } public ExpressionNode buildUpdateExpression(FunctionName eqop, Name columnRef, ExpressionNode expr, Object in) { CommonTree tree = (CommonTree) in; // this is just a function call, but we have to wrap the column ref ArrayList<ExpressionNode> params = new ArrayList<ExpressionNode>(); params.add(buildColumnReference(columnRef)); params.add(expr); return buildFunctionCall(eqop, params, null, tree); } public VariableInstance buildLHSVariableInstance(VariableScope vs, Name n, Object tree) { return captureVariable(new VariableInstance(n.getUnqualified(), vs, SourceLocation.make(tree), false)); } public VariableInstance buildRHSVariableInstance(Object fat, Object sat, VariableScopeKind vsk, Name n, Object tree) { VariableScopeKind kind = vsk; if (kind == null) { if (fat != null) { if (sat != null) { /* * MySQL returns the session value if it exists and the * global value otherwise. */ final String varName = n.getUnqualified().getUnquotedName().get(); final VariableHandler<?> exists = Singletons.require(VariableService.class).getVariableManager() .lookup(varName); if (exists != null) { if (exists.getScopes().contains(VariableScopeKind.SESSION)) { kind = VariableScopeKind.SESSION; } else { kind = VariableScopeKind.GLOBAL; } } } else { kind = VariableScopeKind.USER; } } else { kind = VariableScopeKind.SESSION; } } return captureVariable( new VariableInstance(n.getUnqualified(), new VariableScope(kind), SourceLocation.make(tree), true)); } private VariableInstance captureVariable(VariableInstance vi) { if (!scope.isEmpty()) scope.getVariables().add(vi); return vi; } public VariableScope buildVariableScope(VariableScopeKind vsk) { return new VariableScope(vsk); } public VariableScope buildVariableScope(Name scoped) { if (scoped == null) return new VariableScope(VariableScopeKind.SCOPED); return new VariableScope(scoped.getUnquotedName().get()); } public SetExpression buildSetVariableExpression(VariableInstance v, ExpressionNode en) { return buildSetVariableExpression(v, Collections.singletonList(en)); } public SetExpression buildSetVariableExpression(VariableInstance v, List<ExpressionNode> l) { if (StringUtils.endsWithIgnoreCase(v.getVariableName().get(), "NAMES")) { // validate NAME variable is one of our supported ones // should only be one item in l if (l.get(0) instanceof LiteralExpression) { LiteralExpression le = (LiteralExpression) l.get(0); if (le.isNullLiteral()) { throw new SchemaException(Pass.FIRST, "Must specify a character set"); } String value = (String) le.getValue(pc.getValues()); if (Singletons.require(CharSetNative.class).getCharSetCatalog().findCharSetByName(value) == null) { // character set not supported throw new SchemaException(Pass.FIRST, "Cannot set an unsupported character set: " + value); } } } if (l.size() == 1) return new SetVariableExpression(v, l.get(0)); return new SetVariableExpression(v, l); } public SetExpression buildSetTransactionIsolation(SetTransactionIsolationExpression.IsolationLevel il, VariableScopeKind scopeKind) { return new SetTransactionIsolationExpression(il, scopeKind); } public SessionSetVariableStatement buildSessionSetVarStatement(List<SetExpression> l) { return new SessionSetVariableStatement(l); } public SessionSetVariableStatement buildAlterPersistentVariable(VariableInstance vi, ExpressionNode expr) { ArrayList<SetExpression> sets = new ArrayList<SetExpression>(); sets.add(new SetVariableExpression(vi, expr)); return new SessionSetVariableStatement(sets); } @SuppressWarnings("rawtypes") public Statement buildAddVariable(Name newName, List<Pair<Name, LiteralExpression>> options) { pc.getPolicyContext().checkRootPermission("create a new system variable"); String varName = newName.getUnqualified().getUnquotedName().get(); VariableHandler exists = Singletons.require(VariableService.class).getVariableManager().lookup(varName); if (exists != null) throw new SchemaException(Pass.SECOND, "Variable " + newName + " already exists"); return AddGlobalVariableStatement.decode(pc, varName, options); } private Comment buildComment(String c) { return new Comment(PEStringUtils.dequote(c)); } public TableModifier buildTableModifier(List<ExpressionNode> l) { return new UnknownTableModifier(l); } public TableModifier buildTableModifier(ExpressionNode lhs, boolean hasEquals, ExpressionNode rhs) { ArrayList<ExpressionNode> out = new ArrayList<ExpressionNode>(); if (hasEquals) { out.add(buildFunctionCall(FunctionName.makeEquals(), Arrays.asList(new ExpressionNode[] { lhs, rhs }), null, null)); } else { out.add(lhs); out.add(rhs); } return new UnknownTableModifier(out); } public TableModifier buildAutoincTableModifier(ExpressionNode litval) { LiteralExpression lit = (LiteralExpression) litval; Object value = lit.getValue(pc.getValues()); if (value instanceof Number) { Number n = (Number) value; return new AutoincTableModifier(n.longValue()); } throw new SchemaException(Pass.SECOND, "Unknown autoinc value kind: " + value.getClass().getSimpleName()); } public TableModifier buildEngineTableModifier(Name name) { EngineTableModifier.EngineTag actualTag = EngineTableModifier.EngineTag .findEngine(name.getUnqualified().getUnquotedName().get()); if (actualTag == null) actualTag = EngineTableModifier.EngineTag.INNODB; return new EngineTableModifier(actualTag); } public TableModifier buildCommentTableModifier(final Name tableName, final String s) throws SchemaException { final long maxAllowedLength = Singletons.require(DBNative.class).getMaxTableCommentLength(); if (s.length() > maxAllowedLength) { throw new SchemaException(new ErrorInfo(AvailableErrors.TOO_LONG_TABLE_COMMENT, tableName.getUnqualified().getUnquotedName().get(), maxAllowedLength)); } return new CommentTableModifier(buildComment(s)); } public Comment buildTableFieldComment(final Name fieldName, final String s) throws SchemaException { final long maxAllowedLength = Singletons.require(DBNative.class).getMaxTableFieldCommentLength(); if (s.length() > maxAllowedLength) { throw new SchemaException(new ErrorInfo(AvailableErrors.TOO_LONG_TABLE_FIELD_COMMENT, fieldName.getUnquotedName().get(), maxAllowedLength)); } return buildComment(s); } public TableModifier buildRowFormatTableModifier(Name n) { return new RowFormatTableModifier(n.getUnqualified()); } public TableModifier buildMaxRowsModifier(ExpressionNode en) { LiteralExpression litex = asLiteral(en); Object v = litex.getValue(pc.getValues()); if (v instanceof Number) { Number n = (Number) v; return new MaxRowsModifier(n.longValue()); } throw new SchemaException(Pass.FIRST, "Invalid max rows value - not a number"); } public TableModifier buildChecksumModifier(ExpressionNode en) { Integer v = asIntegralLiteral(en); return new ChecksumModifier(v.intValue()); } public TableModifier buildDelayKeyWriteTableModifier(ExpressionNode en) { throw new SchemaException(Pass.FIRST, "No support for DELAY_KEY_WRITE table option"); } public Statement buildCommitTransactionStatement() { return new TransactionStatement(TransactionStatement.Kind.COMMIT); } public Statement buildStartTransactionStatement(boolean snapshot) { return new StartTransactionStatement(snapshot); } public Statement buildSavepointTransactionStatement(Name n) { return new SavepointStatement(n, false); } public Statement buildReleaseSavepointTransactionStatement(Name n) { return new SavepointStatement(n, true); } public Statement buildRollbackTransactionStatement(Name n) { return new RollbackTransactionStatement(n); } public Statement buildTruncateStatement(Name name, Object tree) { final TableInstance ti = (TableInstance) buildTableInstance(name, null); if (ti.getAbstractTable().isTable()) { final TruncateStatement ts = new TruncateStatement(ti, SourceLocation.make(tree)); ts.getDerivedInfo().takeScope(scope); return ts; } UnqualifiedName encName = null; UnqualifiedName tname = null; if (name.isQualified()) { QualifiedName qn = (QualifiedName) name; encName = qn.getNamespace(); tname = qn.getUnqualified(); } else { tname = (UnqualifiedName) name; encName = pc.getCurrentDatabase().getName().getUnqualified(); } throw new SchemaException(new ErrorInfo(AvailableErrors.TABLE_DNE, encName.getUnquotedName().get(), tname.getUnquotedName().get())); } public ExpressionNode buildSubquery(Statement in, Name alias, Object orig, boolean makeVirtualTable) { ProjectingStatement dmls = (ProjectingStatement) in; Subquery sq = new Subquery(dmls, alias, SourceLocation.make(orig)); if (makeVirtualTable) { SubqueryTable sqt = SubqueryTable.make(pc, dmls); sq.setTable(sqt); scope.pushVirtualTable(sqt, alias.getUnqualified(), pc); scope.getNestedQueries().add(dmls); } // if an alias was specified, then enter a fake table into the scope. return sq; } public ExpressionNode buildExists(Token exists, Statement ss, Object orig) { ExpressionNode param = buildSubquery(ss, null, orig, false); return buildFunctionCall(buildFunctionName(exists, false), Collections.singletonList(param), null, null); } public Statement buildCreateRangeStatement(Name rangeName, Name persistentGroup, List<BasicType> types, Boolean ifNotExists) { pc.getPolicyContext().checkRootPermission("create a range"); RangeDistribution rd = pc.findRange(rangeName, persistentGroup); if (rd != null && !getOptions().isAllowDuplicates()) { if (Boolean.TRUE.equals(ifNotExists)) { return buildEmptyStatement("Create an existing range."); } throw new SchemaException(Pass.SECOND, "Range " + rangeName.getSQL() + " already exists."); } PEPersistentGroup onGroup = pc.findStorageGroup(persistentGroup); if (onGroup == null) throw new SchemaException(Pass.SECOND, "No such persistent group: " + persistentGroup.getSQL()); RangeDistribution nrd = new RangeDistribution(pc, rangeName, types, onGroup); if (rd != null) try { // it is an error if the redeclaration doesn't match the original rd.verifySame(pc, nrd); } catch (PEException pe) { throw new SchemaException(Pass.SECOND, pe); } return new PECreateStatement<RangeDistribution, DistributionRange>((rd == null ? nrd : rd), true, "RANGE", rd != null); } public Statement buildDropRangeStatement(Name rangeName, Boolean ifExists, Name storageGroup) { pc.getPolicyContext().checkRootPermission("drop a range"); RangeDistribution rd = null; if (storageGroup == null) { List<DistributionRange> allsuch = pc.getCatalog() .findDistributionRange(rangeName.getUnquotedName().get()); if (allsuch.size() > 1) throw new SchemaException(Pass.SECOND, "More than one range named " + rangeName + " please specify group (add persistent group <name>)"); else if (allsuch.isEmpty()) { if (Boolean.TRUE.equals(ifExists)) { return buildEmptyStatement("Drop a non existing range."); } throw new SchemaException(Pass.SECOND, "No such range: " + rangeName.getSQL()); } rd = pc.findRange(rangeName, new UnqualifiedName(allsuch.get(0).getStorageGroup().getName())); } else { rd = pc.findRange(rangeName, storageGroup); if (rd == null) { if (Boolean.TRUE.equals(ifExists)) { return buildEmptyStatement("Drop a non existing range."); } throw new SchemaException(Pass.SECOND, "No such range: " + rangeName.getSQL()); } } PEDropRangeStatement out = new PEDropRangeStatement(rd); out.ensureUnreferenced(pc); return out; } public Statement buildDropPersistentGroupStatement(Name groupName) { pc.getPolicyContext().checkRootPermission("drop a persistent group"); PEPersistentGroup peg = pc.findStorageGroup(groupName); if (peg == null) throw new SchemaException(Pass.SECOND, "No such persistent group: " + groupName.getSQL()); PEDropStorageGroupStatement out = new PEDropStorageGroupStatement(peg); out.ensureUnreferenced(pc); return out; } public Statement buildAddPersistentSiteStatement(Name sgName, List<Name> siteNames, boolean rebalance) { pc.getPolicyContext().checkRootPermission("add a persistent site"); PEPersistentGroup pesg = pc.findStorageGroup(sgName); if (pesg == null) throw new SchemaException(Pass.SECOND, "No such persistent group: " + sgName.getSQL()); ArrayList<PEStorageSite> sites = new ArrayList<PEStorageSite>(); for (Name n : siteNames) { PEStorageSite pess = pc.findStorageSite(n); if (pess == null) throw new SchemaException(Pass.SECOND, "No such persistent site: " + n.getSQL()); sites.add(pess); } return new AddStorageSiteStatement(pesg, sites, rebalance); } public Statement buildShowSingularQuery(String onInfoSchemaTable, Name objectName) { if (pc.getCapability() == Capability.PARSING_ONLY && !pc.getCatalog().isPersistent()) return new EmptyStatement("no catalog queries with transient execution engine"); // TODO: // handle !resolve ShowSchemaBehavior ist = Singletons.require(InformationSchemaService.class) .lookupShowTable(new UnqualifiedName(onInfoSchemaTable)); if (ist == null) throw new MigrationException("Need to add info schema table for " + onInfoSchemaTable); return ist.buildUniqueStatement(pc, objectName, new ShowOptions()); } public void push_info_schema_scope(Name n) { // parsing only - just add the darn thing if (pc.getCapability() == Capability.PARSING_ONLY) { pushScope(); scope.buildTableInstance(n, new UnqualifiedName("a"), null, pc, null); } else { ShowSchemaBehavior sst = Singletons.require(InformationSchemaService.class) .lookupShowTable((UnqualifiedName) n); if (sst == null) throw new SchemaException(Pass.SECOND, "No such table: " + n.getSQL()); InformationSchemaTable ist = (InformationSchemaTable) sst; pushScope(); // we put in an alias anyways scope.buildTableInstance(ist.getName(), new UnqualifiedName("a"), Singletons.require(InformationSchemaService.class).getShowSchema(), pc, null); } } public void push_info_schema_scope(String s) { push_info_schema_scope(buildName(s)); } public Statement buildShowPluralQuery(String onInfoSchemaTable, List<Name> scoping, Pair<ExpressionNode, ExpressionNode> likeOrWhere) { return buildShowPluralQuery(onInfoSchemaTable, scoping, likeOrWhere, null); } public Statement buildShowPluralQuery(String onInfoSchemaTable, List<Name> scoping, Pair<ExpressionNode, ExpressionNode> likeOrWhere, Token full) { if (pc.getCapability() == Capability.PARSING_ONLY && !pc.getCatalog().isPersistent()) return new EmptyStatement("no catalog queries with transient execution engine"); ShowSchemaBehavior ist = Singletons.require(InformationSchemaService.class) .lookupShowTable(new UnqualifiedName(onInfoSchemaTable)); if (ist == null) throw new MigrationException("Need to add info schema table for " + onInfoSchemaTable); ExpressionNode likeExpr = (likeOrWhere == null ? null : likeOrWhere.getFirst()); ExpressionNode whereExpr = (likeOrWhere == null ? null : likeOrWhere.getSecond()); ShowOptions so = new ShowOptions(); if (full != null) so.withFull(); // break up the scoping value into parts if qualified List<Name> scopingParts = new ArrayList<Name>(); if (scoping != null) { for (Name name : scoping) { if (name instanceof QualifiedName) { QualifiedName qn = (QualifiedName) name; scopingParts.add(qn.getParts().get(1)); // table name scopingParts.add(qn.getParts().get(0)); // database } else { // assumed UnqualifiedName scopingParts.add(name); } } } return ist.buildShowPlural(pc, scopingParts, likeExpr, whereExpr, so); } public Statement buildReloadLogging() { return new SessionStatement("RELOAD LOGGING") { @Override public boolean isPassthrough() { return false; } @Override public void plan(SchemaContext sc, ExecutionSequence es, BehaviorConfiguration config) throws PEException { es.append(new TransientSessionExecutionStep("RELOAD LOGGING", new AdhocOperation() { @Override public void execute(ExecutionState estate, WorkerGroup wg, DBResultConsumer resultConsumer) throws Throwable { try { // Servers should have been started with a log4j system property // e.g. -Dlog4j.configuration=<something>log4j.properties String name = System.getProperty("log4j.configuration"); if (StringUtils.isBlank(name)) throw new PEException("log4j.configuration property not set"); URL resource = TranslatorUtils.class.getClassLoader().getResource(name); if (resource == null) throw new PEException("Couldn't locate file '" + name + "' on the classpath"); PropertyConfigurator.configure(resource); logger.info("log4j configuration reloaded from '" + name + "'"); } catch (Exception e) { logger.error("Unable to reload logging configuation: " + e.getMessage(), e); throw new PEException("Unable to reload logging configuration: " + e.getMessage(), e); } } })); } }; } public PEPersistentGroup lookupPersistentGroup(Name n) { PEPersistentGroup pesg = pc.findStorageGroup(n); if (pesg == null) throw new SchemaException(Pass.SECOND, "No such persistent group " + n.getSQL()); return pesg; } public Statement setExplainFlag(Statement in, List<Pair<Name, LiteralExpression>> options) { ExplainOptions opts = ExplainOptions.NONE; if (options != null) { for (Pair<Name, LiteralExpression> p : options) { ExplainOption opt = ExplainOption.find(p.getFirst().getUnqualified()); if (opt == null) throw new SchemaException(Pass.FIRST, "No such explain option: " + p.getFirst().getSQL()); opts = opts.addSetting(opt, p.getSecond().getValue(pc.getValues())); } } in.setExplain(opts); return in; } public SetQuantifier lookupSetQuantifier(String in) { SetQuantifier sq = SetQuantifier.fromSQL(in); if (sq == null) throw new SchemaException(Pass.SECOND, "Unknown set quantifier: " + in); return sq; } public Statement buildKillStatement(ExpressionNode expr, Boolean isKillConnection) { return new KillStatement(asIntegralLiteral(expr), isKillConnection.booleanValue()); } public Statement buildEmptyStatement(String text) { return new EmptyStatement(text); } public LockType lookupLockType(String l, String r) { LockType lt = LockType.fromSQL(l, r); if (lt == null) throw new SchemaException(Pass.SECOND, "No such lock type " + (l == null ? "" : l) + " " + (r == null ? "" : r)); return lt; } public Statement buildUnlockTablesStatement() { return new LockStatement(); } public Statement buildLockTablesStatement(List<Pair<ExpressionNode, LockType>> in) { ListOfPairs<TableInstance, LockType> tabs = new ListOfPairs<TableInstance, LockType>(); for (Pair<ExpressionNode, LockType> p : in) { TableInstance ti = (TableInstance) p.getFirst(); tabs.add(ti, p.getSecond()); } return new LockStatement(tabs); } public void startSessionVarsScope() { resolveColumnsAsIdentifiers = true; } public void endSessionVarsScope() { resolveColumnsAsIdentifiers = false; } public UserScope findCurrentUser() { if (pc.getCapability() == Capability.PARSING_ONLY) return null; return pc.getCurrentUser().get(pc).getUserScope(); } public UserScope buildUserScope(String name, String scopeStr) { return new UserScope(PEStringUtils.dequote(name), PEStringUtils.dequote((scopeStr == null) ? "'%'" : scopeStr)); } public PEUser buildUserSpec(UserScope us, String pword) { return new PEUser(us, pword == null ? null : PEStringUtils.dequote(pword), false); } public Statement buildCreateUserStatement(List<PEUser> specs) { pc.getPolicyContext().checkRootPermission("create a user"); // should check to see whether the users already exist if (pc.getCapability() != Capability.PARSING_ONLY && pc.isPersistent()) { for (PEUser peu : specs) { List<User> users = pc.getCatalog().findUsers(peu.getUserScope().getUserName(), peu.getUserScope().getScope()); if (!users.isEmpty()) throw new SchemaException(Pass.SECOND, "User " + peu.getUserScope().getSQL() + " already exists"); } } return new PECreateUserStatement(specs, false); } public Statement buildSetPasswordStatement(UserScope us, String text) { pc.getPolicyContext().checkRootPermission("set a password"); PEUser exists = pc.findUser(us.getUserName(), us.getScope()); if (exists == null) throw new SchemaException(Pass.SECOND, "User " + us.getUserName() + " does not exist"); return new SetPasswordStatement(exists, PEStringUtils.dequote(text)); } public Statement buildDropUserStatement(UserScope us, Boolean ifExists) { pc.getPolicyContext().checkRootPermission("drop a user"); PEUser peu = pc.findUser(us.getUserName(), us.getScope()); if (peu == null) { if (Boolean.TRUE.equals(ifExists)) { // just do an empty statement return new EmptyStatement("drop nonexistent user"); } throw new SchemaException(new ErrorInfo(AvailableErrors.UNKNOWN_USER, us.getUserName(), us.getScope())); } return new PEDropUserStatement(peu); } public Statement buildAlterTableStatement(TableKey tab, AlterTableAction single) { return buildAlterTableStatement(tab, Collections.singletonList(single)); } public Statement buildAlterTableStatement(TableKey tab, List<AlterTableAction> actions) { if (pc.getCapability() == Capability.PARSING_ONLY) return new PEAlterTableStatement(pc, tab, actions); PEAlterStatement<PETable> single = null; AlterTableAction singleAction = null; for (AlterTableAction aa : actions) { single = aa.requiresSingleStatement(pc, tab); if (single != null) { singleAction = aa; break; } } if (single != null) { if (actions.size() > 1) throw new SchemaException(Pass.SECOND, "alter action of type " + singleAction.getClass().getSimpleName() + " must be the sole alter action"); return single; } PEAlterTableStatement orig = new PEAlterTableStatement(pc, tab, actions); return pc.getPolicyContext().modifyAlterTableStatement(orig); } public Statement buildRenameTableStatement(final List<Pair<Name, Name>> sourceTargetNamePairs) { return RenameTableStatement.buildRenameTableStatement(pc, sourceTargetNamePairs); } public Statement buildRenameDatabaseStatement(final Pair<Name, Name> sourceTargetNames) { throw new SchemaException(Pass.FIRST, "This syntax is not supported as it has been deprecated."); } private List<AlterTableAction> wrapAlterAction(AlterTableAction ata) { return Collections.singletonList(ata); } public List<AlterTableAction> buildRenameTableAction(Name newName) { return wrapAlterAction(new RenameTableAction(newName)); } /** * If you specify CONVERT TO CHARACTER SET without a collation, the default * collation for the character set is used. */ public List<AlterTableAction> buildTableConvertToAction(final Name charSet, final Name collation) { final Pair<String, String> charSetCollationPair = getCharsetCollationPair(charSet, collation); return wrapAlterAction( new ConvertToAction(charSetCollationPair.getFirst(), charSetCollationPair.getSecond())); } public List<AlterTableAction> buildChangeColumnAction(Name columnName, TableComponent<PEColumn> newDef, Pair<String, Name> firstOrAfterSpec) { return wrapAlterAction( new ChangeColumnAction(lookupAlteredColumn(columnName), (PEColumn) newDef, firstOrAfterSpec)); } public List<AlterTableAction> buildChangeColumnAction(Name columnName, List<TableComponent<?>> defs, Pair<String, Name> firstOrAfterSpec) { ArrayList<AlterTableAction> out = new ArrayList<AlterTableAction>(); for (TableComponent<?> tc : defs) { if (tc instanceof PEColumn) { PEColumn pec = (PEColumn) defs.get(0); out.add(new ChangeColumnAction(lookupAlteredColumn(columnName), pec, firstOrAfterSpec)); } else if (tc instanceof PEKey) { out.add(new AddIndexAction((PEKey) tc)); } else { throw new SchemaException(Pass.FIRST, "Unknown alter table change column target: " + tc); } } return out; } public List<AlterTableAction> buildModifyColumnAction(List<TableComponent<?>> defs, Pair<String, Name> firstOrAfterSpec) { if (defs.size() > 1) throw new SchemaException(Pass.SECOND, "No support for modifying column def with inline key def"); PEColumn newDef = (PEColumn) defs.get(0); PEColumn existing = lookupAlteredColumn(newDef.getName()); return wrapAlterAction(new ChangeColumnAction(existing, newDef, firstOrAfterSpec)); } public List<AlterTableAction> buildAlterColumnAction(Name columnName, ExpressionNode litex) { return wrapAlterAction(new AlterColumnAction(lookupAlteredColumn(columnName), (LiteralExpression) litex)); } public List<AlterTableAction> buildAddIndexAction(PEKey newIndex) { if (pc.getCapability() != Capability.PARSING_ONLY && newIndex.isUnresolved()) throw new SchemaException(Pass.FIRST, "Invalid forward key during alter"); return wrapAlterAction(new AddIndexAction((PEKey) newIndex)); } public List<AlterTableAction> buildDropIndexAction(ConstraintType kt, Name indexName) { PEKey targ = lookupAlteredKey(kt, indexName); return wrapAlterAction(new DropIndexAction(targ)); } public Statement buildExternalDropIndexStatement(Name indexName, Name tableName) { TableKey tk = lookupAlteredTable(tableName); AlterTableAction aa = buildDropIndexAction(null, indexName).get(0); return buildAlterTableStatement(tk, aa); } public List<AlterTableAction> buildDropColumnAction(Name columnName) { List<AlterTableAction> actions = new ArrayList<AlterTableAction>(); PEColumn alteredCol = lookupAlteredColumn(columnName); // cannot drop column if it is the target in an FK if (pc.getCapability() == Capability.FULL) { for (UserTable ut : pc.getCatalog() .findTablesWithFKSReferencing(alteredCol.getTable().getPersistentID())) { for (Key k : ut.getKeys()) { if (k.isForeignKey() && StringUtils.equals(k.getReferencedTable().getName(), alteredCol.getTable().getName().get())) { for (KeyColumn c : k.getColumns()) { if (StringUtils.equals(c.getTargetColumnName(), alteredCol.getName().get())) { throw new SchemaException(Pass.SECOND, "Cannot drop column '" + columnName.get() + "' because it is part of foreign key '" + k.getName() + "'"); } } } } } for (PEKey key : alteredCol.getTable().getKeys(pc)) { if (key.containsColumn(alteredCol)) { if (key.isForeign()) { throw new SchemaException(Pass.SECOND, "Cannot drop column '" + columnName.get() + "' because it is part of foreign key '" + key.getName().get() + "'"); } actions.add(buildDropIndexAction(null, key.getName()).get(0)); if (key.getColumns(pc).size() > 1) { // rebuild index if multicol PEKey newPEKey = key.copy(pc, alteredCol.getTable().asTable()); newPEKey.removeColumn(alteredCol); actions.add(buildAddIndexAction(newPEKey).get(0)); } } } } actions.add(new DropColumnAction(alteredCol)); return actions; } public List<AlterTableAction> buildAlterTableOptionActions(List<TableModifier> tm) { final List<AlterTableAction> actions = new ArrayList<AlterTableAction>(tm.size()); for (final TableModifier modifier : tm) { actions.add(new ChangeTableModifierAction(modifier)); } return actions; } public List<AlterTableAction> buildModifyDistributionAction(UnresolvedDistributionVector ndv) { return wrapAlterAction(new ChangeTableDistributionAction(ndv.resolve(pc, this))); } @SuppressWarnings("rawtypes") public List<AlterTableAction> buildAddColumnAction(List<TableComponent> newColumns) { return buildAddColumnAction(newColumns, null); } @SuppressWarnings("rawtypes") public List<AlterTableAction> buildAddColumnAction(List<TableComponent> newColumns, Pair<String, Name> firstOrAfterSpec) { if (firstOrAfterSpec != null) { // only valid when adding one column. note that if we added a column & a key at the same time we should // ignore the key part (because keys doen't really have a position). int ncols = 0; for (TableComponent tc : newColumns) if (tc instanceof PEColumn) ncols++; if (ncols > 1) { // only valid when adding one column throw new SchemaException(Pass.FIRST, "Cannot specify FIRST or AFTER option with multicolumn ADD"); } } ArrayList<PEColumn> casted = new ArrayList<PEColumn>(); ArrayList<PEKey> keys = new ArrayList<PEKey>(); for (TableComponent nc : newColumns) { if (nc instanceof PEColumn) casted.add((PEColumn) nc); else if (nc instanceof PEKey) keys.add((PEKey) nc); } List<AlterTableAction> out = new ArrayList<AlterTableAction>(); if (!casted.isEmpty()) { out.add(new AddColumnAction(casted, firstOrAfterSpec)); } for (PEKey pek : keys) { out.add(new AddIndexAction(pek)); } return out; } @SuppressWarnings("unchecked") private PEColumn lookupAlteredColumn(Name columnName) { PEColumn c = null; final Table<?> parentTable = scope.getAlteredTable(); c = (PEColumn) parentTable.lookup(pc, columnName); if (c == null) { if (pc.getCapability() == Capability.PARSING_ONLY) { c = PEColumn.buildColumn(pc, columnName, TempColumnType.TEMP_TYPE, Collections.EMPTY_LIST, null, null); } else { throw new SchemaException(Pass.SECOND, "Unknown column '" + columnName + "' in '" + parentTable.getName().get() + "'"); } } return c; } /** * @param kt * @param keyName * @return */ @SuppressWarnings("unchecked") private PEKey lookupAlteredKey(ConstraintType kt, Name keyName) { PEKey k = null; if (pc.getCapability() == Capability.PARSING_ONLY) { k = new PEKey(keyName, IndexType.BTREE, Collections.EMPTY_LIST, null); } else { k = ((PETable) scope.getAlteredTable()).lookupKey(pc, keyName); if (k == null) throw new SchemaException(Pass.SECOND, "No such key: " + keyName); } return k; } @SuppressWarnings("unchecked") public TableKey lookupAlteredTable(Name tabName) { TableKey tab = null; if (pc.getCapability() == Capability.PARSING_ONLY) { tab = TableKey.make(pc, new PETable(pc, tabName, Collections.EMPTY_LIST, null, null, null), 0); } else { TableResolver resolver = new TableResolver().withMTChecks() .withDatabaseFunction(new UnaryProcedure<Database<?>>() { @Override public void execute(Database<?> object) { if (!(object instanceof PEDatabase)) throw new SchemaException(Pass.SECOND, "Invalid database for table alter: '" + object.getName() + "'"); } }); TableInstance ti = resolver.lookupTable(pc, tabName, lockInfo); if (ti == null) throw new SchemaException(Pass.SECOND, "No such table: " + tabName.getSQL()); tab = ti.getTableKey(); } // now we have to push all the columns in case they are used pushScope(); scope.registerAlterColumns(pc, tab.getAbstractTable().asTable()); return tab; } public WhenClause buildWhenClause(ExpressionNode te, ExpressionNode re, Object orig) { return new WhenClause(te, re, SourceLocation.make(orig)); } public ExpressionNode buildCaseExpression(ExpressionNode te, ExpressionNode ee, List<WhenClause> whens, Object orig) { return new CaseExpression(te, ee, whens, SourceLocation.make(orig)); } public ExpressionNode buildCastCall(String castText, ExpressionNode toCast, String asText, Name tn) { return new CastFunctionCall(toCast, castText, tn, asText); } public Name buildCastToIntegralType(String signed, String integer) { if (integer == null) return new UnqualifiedName(signed); return new UnqualifiedName(signed + " " + integer); } public Name buildCastToSizedType(String theType, String theFirstSize, String theSecondSize) { if (theFirstSize == null && theSecondSize == null) return new UnqualifiedName(theType); StringBuilder buf = new StringBuilder(); buf.append(theType).append("(").append(theFirstSize); if (theSecondSize != null) buf.append(",").append(theSecondSize); buf.append(")"); return new UnqualifiedName(buf.toString()); } public Name buildCastToBinaryOrChar(String theType, String maybeFirstSize, Name maybeCharset) { StringBuilder buf = new StringBuilder(); buf.append(theType); if (maybeFirstSize != null) { buf.append("(").append(maybeFirstSize).append(")"); } else if (maybeCharset != null) { buf.append(" charset ").append(maybeCharset.getSQL()); } return new UnqualifiedName(buf.toString()); } public ExpressionNode buildCharCall(List<ExpressionNode> charCodes, Name outputEncoding) { return new CharFunctionCall(charCodes, outputEncoding); } public ExpressionNode buildRandCall(List<ExpressionNode> args) { if (args.isEmpty()) { return new RandFunctionCall(null); } else if (args.size() == 1) { return new RandFunctionCall(args.get(0)); } else { throw new SchemaException(new ErrorInfo(AvailableErrors.INCORRECT_PARAM_COUNT_FUNCTION_CALL, "RAND")); } } public ExpressionNode buildConvertCall(ExpressionNode toConvert, Name transcodingName, Type castToType) { Name rhs = transcodingName; if (castToType != null) { StringBuilder buf = new StringBuilder(); Singletons.require(DBNative.class).getEmitter().emitConvertTypeDeclaration(castToType, buf); rhs = new UnqualifiedName(buf.toString()); } return new ConvertFunctionCall(toConvert, rhs, (transcodingName != null)); } public ExpressionNode buildTimestampDiffCall(String unit, ExpressionNode param1, ExpressionNode param2) { FunctionName fn = new FunctionName("TIMESTAMPDIFF", TokenTypes.TIMESTAMPDIFF, false); ArrayList<ExpressionNode> actuals = new ArrayList<ExpressionNode>(); actuals.add(buildIdentifierLiteral(unit)); actuals.add(param1); actuals.add(param2); return buildFunctionCall(fn, actuals, null, null); } public ExpressionNode buildInterval(ExpressionNode intervalExpression, String unit) { return new IntervalExpression(intervalExpression, unit, null); } public ExpressionNode buildMultivalueExpression(final List<ExpressionNode> values) { if (values.size() == 1) { return addGrouping(values.get(0)); } return buildExpressionSet(values); } public ExpressionNode buildExpressionSet(List<ExpressionNode> values) { return new ExpressionSet(values, null); } public ExpressionNode buildGroupConcat(FunctionName fn, List<ExpressionNode> params, boolean distinct, String separator) { SetQuantifier sq = (distinct ? SetQuantifier.DISTINCT : null); return new GroupConcatCall(fn, params, sq, separator); } public Statement buildCreateTenantStatement(Name tenantName, Name onDB, String description) { PEDatabase peds = null; if (onDB == null) { peds = pc.findSingleMTDatabase(); if (peds == null) throw new SchemaException(Pass.SECOND, "No multitenant database found"); } if (peds == null) peds = pc.findPEDatabase(onDB); if (peds == null) throw new SchemaException(Pass.SECOND, "No such database: " + (onDB == null ? "(blank)" : onDB.getSQL())); if (!peds.getMTMode().isMT()) throw new SchemaException(Pass.SECOND, "Cannot create tenant on " + peds.getMTMode().describe() + " database " + (onDB == null ? "(blank)" : onDB.getSQL())); return pc.getPolicyContext().buildCreateTenantStatement(peds, tenantName, (description == null ? null : PEStringUtils.dequote(description))); } public Statement buildSuspendTenantStatement(Name tenantName) { return pc.getPolicyContext().buildSuspendTenantStatement(tenantName); } public Statement buildResumeTenantStatement(Name tenantName) { return pc.getPolicyContext().buildResumeTenantStatement(tenantName); } public Statement buildDropTenantStatement(Name tenantName) { return pc.getPolicyContext().buildDropTenantStatement(tenantName, false); } public Name buildUnrestrictedName(List<Name> names) { ArrayList<UnqualifiedName> parts = new ArrayList<UnqualifiedName>(); for (Name n : names) { // should not happen if (n.isQualified()) throw new SchemaException(Pass.FIRST, "Qualified name found where unqualified name expected"); parts.add(n.getUnqualified()); } return new QualifiedName(parts); } public Pair<Name, LiteralExpression> buildConfigOption(Name key, ExpressionNode value) { return new Pair<Name, LiteralExpression>(key, asLiteral(value)); } private static final Name pluginKey = new UnqualifiedName("PLUGIN"); private static final Name activeKey = new UnqualifiedName("ACTIVE"); public Statement buildCreateDynamicSiteProvider(Name name, List<Pair<Name, LiteralExpression>> options) { pc.getPolicyContext().checkRootPermission("create a dynamic site provider"); // see if we have one already Provider extant = pc.getCatalog().findProvider(name.get()); if (extant != null) throw new SchemaException(Pass.SECOND, "Dynamic site provider " + name.getSQL() + " already exists"); String plugin = null; Boolean isActive = null; for (Iterator<Pair<Name, LiteralExpression>> iter = options.iterator(); iter.hasNext();) { Pair<Name, LiteralExpression> p = iter.next(); if (p.getFirst().getCapitalized().equals(pluginKey)) { plugin = p.getSecond().asString(pc.getValues()); iter.remove(); } else if (p.getFirst().getCapitalized().equals(activeKey)) { isActive = (Boolean) p.getSecond().getValue(pc.getValues()); iter.remove(); } } if (isActive == null) isActive = Boolean.TRUE; if (plugin == null) throw new SchemaException(Pass.SECOND, "Must specify plugin for CREATE DYNAMIC SITE PROVIDER"); PEProvider provider = new PEProvider(pc, name, plugin, isActive); return new PECreateGroupProviderStatement(provider, options); } public Statement buildAlterDynamicSiteProviderStatement(Name name, List<Pair<Name, LiteralExpression>> options) { pc.getPolicyContext().checkRootPermission("alter a dynamic site provider"); // see if we have one already Provider extant = pc.getCatalog().findProvider(name.get()); if (extant == null) throw new SchemaException(Pass.SECOND, "No such dynamic site provider: " + name.getSQL()); PEProvider pep = PEProvider.load(extant, pc); return new PEAlterGroupProviderStatement(pep, options); } public Statement buildShowDynamicSiteProvider(Name name, List<Pair<Name, LiteralExpression>> options) { pc.getPolicyContext().checkRootPermission("show a dynamic site provider"); // see if we have one already Provider extant = pc.getCatalog().findProvider(name.get()); if (extant == null) throw new SchemaException(Pass.SECOND, "No such dynamic site provider: " + name.getSQL()); List<CatalogEntity> ents = null; // build the command block, use null for the action SiteManagerCommand smc = new SiteManagerCommand(Command.SHOW, extant, PEGroupProviderDDLStatement.convertOptions(pc, options)); try { SiteProviderPlugin sm = SiteProviderFactory.getInstance(smc.getTarget().getName()); ents = sm.show(smc); } catch (PEException pe) { throw new SchemaException(Pass.SECOND, "Unable to query provider " + extant.getName(), pe); } return new SchemaQueryStatement(true, DYNAMIC_SITE_PROVIDER, ents, false, null); } public Statement buildShowDynamicSiteProvidersSites() { pc.getPolicyContext().checkRootPermission("show dynamic site providers sites"); // in this case, we just find all the providers, then route the // appropriate command to each provider, aggregate results, // etc. ListOfPairs<String, Object> options = new ListOfPairs<String, Object>(); // or whatever you like options.add("cmd", "sites"); ArrayList<CatalogEntity> results = new ArrayList<CatalogEntity>(); List<Provider> providers = pc.getCatalog().findAllProviders(); for (Provider p : providers) { try { SiteManagerCommand smc = new SiteManagerCommand(Command.SHOW, p, options); SiteProviderPlugin sm = SiteProviderFactory.getInstance(smc.getTarget().getName()); results.addAll(sm.show(smc)); } catch (PEException pe) { throw new SchemaException(Pass.SECOND, "Unable to query provider " + p.getName(), pe); } } return new SchemaQueryStatement(true, DYNAMIC_SITE_PROVIDER_SITES, results, false, null); } @SuppressWarnings("unchecked") public Statement buildDropDynamicSiteProviderStatement(Name name, List<Pair<Name, LiteralExpression>> options) { pc.getPolicyContext().checkRootPermission("drop a dynamic site provider"); // see if we have one already Provider extant = pc.getCatalog().findProvider(name.get()); if (extant == null) throw new SchemaException(Pass.SECOND, "No such dynamic site provider: " + name.getSQL()); PEProvider pep = PEProvider.load(extant, pc); return new PEDropGroupProviderStatement(pep, (options == null ? Collections.EMPTY_LIST : options)); } public PEPolicyClassConfig buildClassConfig(Name theClassName, ExpressionNode countLiteral, ExpressionNode providerLiteral, ExpressionNode poolLiteral) { PolicyClass theClass = PolicyClass.findSQL(theClassName.getUnqualified().getUnquotedName().get()); if (theClass == null) throw new SchemaException(Pass.SECOND, "No such policy type: " + theClassName); Integer theCount = null; String theProvider = null; String thePool = null; if (poolLiteral instanceof LiteralExpression) thePool = (String) ((LiteralExpression) poolLiteral).getValue(pc.getValues()); if (providerLiteral instanceof LiteralExpression) theProvider = (String) ((LiteralExpression) providerLiteral).getValue(pc.getValues()); if (countLiteral instanceof LiteralExpression) { LiteralExpression litex = (LiteralExpression) countLiteral; Number n = (Number) litex.getValue(pc.getValues()); theCount = n.intValue(); } return new PEPolicyClassConfig(theClass, theProvider, thePool, (theCount == null ? 0 : theCount)); } public Statement buildCreateDynamicSitePolicyStatement(Name name, boolean strict, List<PEPolicyClassConfig> classes) { if (name == null) { throw new SchemaException(Pass.FIRST, MISSING_UNQUALIFIED_IDENTIFIER_ERROR_MSG); } pc.getPolicyContext().checkRootPermission("create a dynamic site policy"); DynamicPolicy dp = pc.getCatalog().findPolicy(name.get()); if (dp != null) throw new SchemaException(Pass.SECOND, "Dynamic site policy " + name.getSQL() + " already exists"); PEPolicy pep = new PEPolicy(pc, name, strict, classes); return new PECreateStatement<PEPolicy, DynamicPolicy>(pep, true, DYNAMIC_SITE_POLICY_TAG, false); } public Statement buildAlterDynamicSitePolicyStatement(Name name, Name newName, Boolean newStrict, List<PEPolicyClassConfig> configs) { pc.getPolicyContext().checkRootPermission("alter a dynamic site policy"); DynamicPolicy dp = pc.getCatalog().findPolicy(name.get()); if (dp == null) throw new SchemaException(Pass.SECOND, "No such dynamic site policy: " + name.getSQL()); PEPolicy pep = PEPolicy.load(dp, pc); return new PEAlterPolicyStatement(pep, newName, newStrict, configs); } @SuppressWarnings({ "unchecked", "rawtypes" }) public Statement buildDropDynamicSitePolicyStatement(Name name) { pc.getPolicyContext().checkRootPermission("drop a dynamic site policy"); DynamicPolicy dp = pc.getCatalog().findPolicy(name.get()); if (dp == null) throw new SchemaException(Pass.SECOND, "Dynamic site policy " + name.getSQL() + " does not exist"); PEPolicy pep = PEPolicy.load(dp, pc); return new PEDropStatement(PEPolicy.class, null, true, pep, "DYNAMIC SITE POLICY"); } public Statement buildCreateExternalServiceStatement(Name name, List<Pair<Name, LiteralExpression>> options) { if (name == null) { throw new SchemaException(Pass.FIRST, MISSING_UNQUALIFIED_IDENTIFIER_ERROR_MSG); } // check permissions pc.getPolicyContext().checkRootPermission("create an external service"); ExternalService es = pc.getCatalog().findExternalService(name.getUnqualified().get()); if (es != null) throw new SchemaException(Pass.SECOND, "External Service " + name.getSQL() + " already exists."); return new PECreateExternalServiceStatement(new PEExternalService(pc, name, options), true, "EXTERNAL SERVICE", false); } public Statement buildDropExternalServiceStatement(Name name) { pc.getPolicyContext().checkRootPermission("drop an external service"); ExternalService es = pc.getCatalog().findExternalService(name.getUnqualified().get()); if (es == null) throw new SchemaException(Pass.SECOND, "No such external service: " + name.getSQL()); return new PEDropExternalServiceStatement(PEExternalService.class, null, true, new PEExternalService(pc, es), "EXTERNAL SERVICE"); } public Statement buildAlterExternalServiceStatement(Name name, List<Pair<Name, LiteralExpression>> options) { pc.getPolicyContext().checkRootPermission("alter an external service"); ExternalService es = pc.getCatalog().findExternalService(name.getUnqualified().get()); if (es == null) throw new SchemaException(Pass.SECOND, "No such external service: " + name.getSQL()); return new PEAlterExternalServiceStatement(new PEExternalService(pc, es, options)); } public Statement buildStartExternalServiceStatement(Name name) { pc.getPolicyContext().checkRootPermission("start an external service"); ExternalService es = pc.getCatalog().findExternalService(name.getUnqualified().get()); if (es == null) throw new SchemaException(Pass.SECOND, "No such external service: " + name.getSQL()); return new ExternalServiceControlStatement(ExternalServiceControlStatement.Action.START, es); } public Statement buildStopExternalServiceStatement(Name name) { pc.getPolicyContext().checkRootPermission("stop an external service"); ExternalService es = pc.getCatalog().findExternalService(name.getUnqualified().get()); if (es == null) throw new SchemaException(Pass.SECOND, "No such external service: " + name.getSQL()); return new ExternalServiceControlStatement(ExternalServiceControlStatement.Action.STOP, es); } public Statement buildCreateContainerStatement(Name containerName, Name groupName, Pair<DistributionVector.Model, UnqualifiedName> backingModel, Boolean ifNotExists) { // // check permissions // pc.getPolicyContext().checkRootPermission("create a container"); Container container = pc.getCatalog().findContainer(containerName.getUnqualified().get()); if (container != null) { if (Boolean.TRUE.equals(ifNotExists)) { // just do an empty statement return new EmptyStatement("Create existing container"); } throw new SchemaException(Pass.SECOND, "Container " + containerName.getSQL() + " already exists."); } PEPersistentGroup pesg = null; if (groupName != null) { pesg = pc.findStorageGroup(groupName); if (pesg == null) throw new SchemaException(Pass.SECOND, "No such persistent group: " + groupName.getSQL()); } if (backingModel == null) { throw new SchemaException(Pass.SECOND, "Missing distribution declaration on container " + containerName.getSQL()); } DistributionVector.Model model = backingModel.getFirst(); RangeDistribution rd = null; if (model == DistributionVector.Model.RANGE) { UnqualifiedName rangeName = backingModel.getSecond(); rd = pc.findRange(rangeName, groupName); if (rd == null) throw new SchemaException(Pass.SECOND, "No such range on group " + groupName + ": " + rangeName.getSQL()); } return new PECreateStatement<PEContainer, Container>(new PEContainer(pc, containerName, pesg, model, rd), true, "CONTAINER", false); } public Statement buildDropContainerStatement(Name name, Boolean ifExists) { pc.getPolicyContext().checkRootPermission("drop a container"); PEContainer cont = pc.findContainer(name); if (cont == null) { if (Boolean.TRUE.equals(ifExists)) { return buildEmptyStatement("Drop a non existing container."); } throw new SchemaException(Pass.SECOND, "No such container: " + name.getSQL()); } return new PEDropContainerStatement(cont); } // move this somewhere else public Statement buildUseContainerStatement(Name containerName, List<Pair<LiteralExpression, Name>> values) { for (Pair<LiteralExpression, Name> val : values) { LiteralExpression expr = val.getFirst(); if (expr.isNullLiteral()) { if (values.size() == 1) { return new UseContainerStatement(pc, true); } throw new SchemaException(Pass.SECOND, "NULL context cannot be specified with container discriminant."); } else if (expr.isGlobalLiteral()) { if (values.size() == 1) { return new UseContainerStatement(pc, false); } throw new SchemaException(Pass.SECOND, "GLOBAL context cannot be specified with container discriminant."); } } PEContainer cont = pc.findContainer(containerName); if (cont == null) throw new SchemaException(Pass.SECOND, "No such container: " + containerName.getSQL()); PETable bt = cont.getBaseTable(pc); if (bt == null) throw new SchemaException(Pass.SECOND, "Unable to use container " + containerName.getSQL() + ": no discriminator set"); List<PEColumn> discCols = cont.getDiscriminantColumns(pc); if (discCols.size() != values.size()) throw new SchemaException(Pass.SECOND, "Invalid discriminant value. Found " + values.size() + " columns but require " + discCols.size() + " columns"); return new UseContainerStatement(pc, cont, bt, discCols, values, false); } public Parameter buildParameter(Token tree) { Parameter param = new Parameter(SourceLocation.make(tree)); parameters.add(param); return param; } public Statement buildShowProcesslistStatement(Boolean full) { return new ShowProcesslistStatement(full); } public Statement buildShowPassthroughStatement(String command) { if (StringUtils.equals(command, "PLUGINS")) { return new ShowPassthroughStatement(PassThroughCommandType.PLUGINS, false, null); } else if (StringUtils.equals(command, "MASTER LOGS")) { return new ShowPassthroughStatement(PassThroughCommandType.MASTERLOGS, false, null); } else if (StringUtils.equals(command, "MASTER STATUS")) { return new ShowPassthroughStatement(PassThroughCommandType.MASTERSTATUS, false, null); } else if (StringUtils.equals(command, "SLAVE STATUS")) { return new ShowPassthroughStatement(PassThroughCommandType.SLAVESTATUS, false, null); } else if (StringUtils.equals(command, "GRANTS")) { return new ShowPassthroughStatement(PassThroughCommandType.GRANTS, false, null); } throw new SchemaException(Pass.SECOND, "No SHOW support for command '" + command + "'"); } public GrantScope buildGrantScope(Name n) { if (n == null) return new GrantScope(); // otherwise it's a db.* or db.table // the grant scope might be a tenant if (pc.getCapability() == Capability.PARSING_ONLY) return new GrantScope(n); PEDatabase peds = pc.findPEDatabase(n); PETenant ten = null; if (peds == null) ten = pc.findTenant(n); if (peds == null && ten == null) throw new SchemaException(Pass.SECOND, "No such database: " + n.getSQL()); if (peds != null) return new GrantScope(peds); return new GrantScope(ten); } /** * @param gs * @param user * @param whatToGrant * @return */ public Statement buildGrant(GrantScope gs, PEUser user, String whatToGrant) { if (pc.getCapability() == Capability.PARSING_ONLY) { return new GrantStatement(gs.buildPriviledge(pc, user)); } pc.getPolicyContext().checkRootPermission("grant privileges"); // we're going to use the PEUser bit to look up the actual user PEUser actualUser = pc.findUser(user.getUserScope().getUserName(), user.getUserScope().getScope()); if (actualUser == null) actualUser = user; // so, a grant statement always creates a priv, but optionally creates the user return new GrantStatement(gs.buildPriviledge(pc, actualUser)); } public Statement buildFlushPrivileges() { return new FlushPrivilegesStatement(); } protected DelegatingLiteralExpression replaceLiteral(DelegatingLiteralExpression oldLiteral, int valueType, SourceLocation sloc, Object value) { literals.remove(oldLiteral.getPosition()); DelegatingLiteralExpression dle = new DelegatingLiteralExpression(valueType, sloc, this, oldLiteral.getPosition(), oldLiteral.getCharsetHint()); literals.add(oldLiteral.getPosition(), new Pair<DelegatingLiteralExpression, Object>(dle, value)); return dle; } public ExpressionNode maybeNegate(Token tok, ExpressionNode rhs) { if (tok == null) return rhs; FunctionName fn = buildFunctionName(tok, true); ArrayList<ExpressionNode> parts = new ArrayList<ExpressionNode>(1); parts.add(rhs); return buildFunctionCall(fn, parts, null, null); } public ExpressionNode buildFunctionOrIdentifier(Name name, SetQuantifier sq, List<ExpressionNode> params, Token asterisk, Object loc, Token leftParen, Token rightParen) { SourceLocation sloc = SourceLocation.make(loc); if (sq == null && params == null && asterisk == null && leftParen == null && rightParen == null) { if (opts.isResolve()) return buildColumnReference(name); return new NameInstance(name, sloc); } UnqualifiedName unq = name.getUnqualified(); FunctionName fn = new FunctionName(unq, false); if (sq != null && !fn.isAggregate()) throw new SchemaException(Pass.FIRST, "Illegal use of set quantifier"); else if (asterisk != null && !fn.isCount()) throw new SchemaException(Pass.FIRST, "Illegal use of '*' in a function"); else if (asterisk != null && (params != null) && !params.isEmpty()) throw new SchemaException(Pass.FIRST, "Mixed use of parameters and '*'"); ArrayList<ExpressionNode> actuals = new ArrayList<ExpressionNode>(); if (asterisk != null) actuals.add(new Wildcard(SourceLocation.make(asterisk))); else { if (params != null) { actuals.addAll(params); } } return buildFunctionCall(fn, actuals, sq, sloc); } public ExpressionNode maybeBuildExprAlias(ExpressionNode targ, Name alias, String stringAlias, Object tree) { if (alias == null && stringAlias == null) return targ; if (targ instanceof NameInstance && alias != null) { // Don't allow an alias to be the same name as the column // This will cause a stack overflow because the column will refer to an alias // which refers back to the column. NameInstance colName = (NameInstance) targ; if (colName.getName().get().equals(alias.get())) { return targ; } } Alias a = null; if (alias != null) a = new NameAlias(castAlias(alias)); else if (stringAlias != null) a = new StringLiteralAlias(PEStringUtils.dequote(stringAlias)); return scope.buildExpressionAlias(targ, a, SourceLocation.make(tree)); } public ProjectingStatement maybeBuildUnionStatement(List<ProjectingStatement> stmts, List<Boolean> unionOps) { ProjectingStatement singleReturn = null; if (stmts.size() == 1) singleReturn = stmts.get(0); else { // working from the back of the stmts list, build union clauses until // there is only one stmt left for (int op = unionOps.size() - 1; op > -1; op--) { ProjectingStatement rhs = stmts.get(op + 1); ProjectingStatement lhs = stmts.get(op); Boolean variety = unionOps.get(op); UnionStatement nus = new UnionStatement(lhs, rhs, variety.booleanValue(), lhs.getSourceLocation()); stmts.remove(op + 1); stmts.remove(op); stmts.add(op, nus); nus.getDerivedInfo().addNestedStatements(Arrays.asList(new ProjectingStatement[] { lhs, rhs })); } singleReturn = stmts.get(0); } return singleReturn; } public Statement buildShowErrorsOrWarnings(String typeTag, LimitSpecification limit) { return new ShowErrorsWarningsStatement(typeTag, limit); } public Statement buildShowSitesStatus() { return new ShowSitesStatusStatement(); } @SuppressWarnings("unchecked") public Statement buildShowStatus(Pair<ExpressionNode, ExpressionNode> likeOrWhere) { DirectShowStatusInformation ist = (DirectShowStatusInformation) Singletons .require(InformationSchemaService.class).lookupShowTable(new UnqualifiedName("status")); ExpressionNode likeExpr = (likeOrWhere == null ? null : likeOrWhere.getFirst()); ExpressionNode whereExpr = (likeOrWhere == null ? null : likeOrWhere.getSecond()); if (pc.getCapability() == Capability.PARSING_ONLY) return new SchemaQueryStatement(false, "status", Collections.EMPTY_LIST, true, null); return ist.buildShowPlural(pc, null, likeExpr, whereExpr, null); } @SuppressWarnings("unchecked") public Statement buildShowVariables(VariableScope ivs, Pair<ExpressionNode, ExpressionNode> likeOrWhere) { DirectShowVariablesTable ist = (DirectShowVariablesTable) Singletons.require(InformationSchemaService.class) .lookupShowTable(new UnqualifiedName("variables")); VariableScope vs = ivs; if (vs == null) vs = new VariableScope(VariableScopeKind.SESSION); ExpressionNode likeExpr = (likeOrWhere == null ? null : likeOrWhere.getFirst()); ExpressionNode whereExpr = (likeOrWhere == null ? null : likeOrWhere.getSecond()); if (pc.getCapability() == Capability.PARSING_ONLY) return new SchemaQueryStatement(false, "variables", Collections.EMPTY_LIST, true, null); return ist.buildShow(pc, vs, likeExpr, whereExpr); } public Statement buildShowColumns(String onInfoSchemaTable, List<Name> scoping, Pair<ExpressionNode, ExpressionNode> likeOrWhere, Token full) { if (pc.getCapability() == Capability.PARSING_ONLY && !pc.getCatalog().isPersistent()) return new EmptyStatement("no catalog queries with transient execution engine"); ShowSchemaBehavior ist = Singletons.require(InformationSchemaService.class) .lookupShowTable(new UnqualifiedName(onInfoSchemaTable)); if (ist == null) throw new MigrationException("Need to add info schema table for " + onInfoSchemaTable); ExpressionNode likeExpr = (likeOrWhere == null ? null : likeOrWhere.getFirst()); ExpressionNode whereExpr = (likeOrWhere == null ? null : likeOrWhere.getSecond()); ShowOptions so = new ShowOptions(); if (full != null) so.withFull(); // break up the scoping value into parts if qualified List<Name> scopingParts = new ArrayList<Name>(); for (Name name : scoping) { if (name instanceof QualifiedName) { QualifiedName qn = (QualifiedName) name; scopingParts.add(qn.getParts().get(1)); // table name scopingParts.add(qn.getParts().get(0)); // database } else { // assumed UnqualifiedName scopingParts.add(name); } } return ist.buildShowPlural(pc, scopingParts, likeExpr, whereExpr, so); } public List<AlterTableAction> buildEnableKeysAction() { return wrapAlterAction(new ChangeKeysStatusAction(true)); } public List<AlterTableAction> buildDisableKeysAction() { return wrapAlterAction(new ChangeKeysStatusAction(false)); } public Statement buildShowMultitenantLocks() { return new SchemaQueryStatement(true, "multitenant locks", Singletons.lookup(LockManager.class).showState()); } public Statement buildMaintenanceQuery(String operation, String option, List<Name> tables) { MaintenanceCommandType maintenanceCommand = MaintenanceCommandType.valueOf(operation.toUpperCase()); if (maintenanceCommand == null) { throw new SchemaException(Pass.FIRST, "Invalid table maintenance command: " + operation); } MaintenanceOptionType maintenanceOption = MaintenanceOptionType.NONE; if (option != null) { maintenanceOption = MaintenanceOptionType.valueOf(option.toUpperCase()); if (maintenanceOption == null) { throw new SchemaException(Pass.FIRST, "Invalid table maintenance option: " + option); } } List<TableInstance> tblInstances = lookupTables(tables); // restrict maintenance commands to a single Persistent Group Name persistentGroup = tblInstances.get(0).getAbstractTable().getPersistentStorage(pc).getName(); for (TableInstance tableInstance : tblInstances) { if (!persistentGroup.equals(tableInstance.getAbstractTable().getPersistentStorage(pc).getName())) { throw new SchemaException(Pass.FIRST, "Table '" + tableInstance.getAbstractTable().getName(pc, pc.getValues()).get() + "' in maintenance command is not in Persistent Group '" + persistentGroup.get() + "'"); } } if (MaintenanceCommandType.ANALYZE == maintenanceCommand) return new AnalyzeTablesStatement(maintenanceOption, tblInstances); return new TableMaintenanceStatement(maintenanceCommand, maintenanceOption, tblInstances); } private List<TableInstance> lookupTables(List<Name> tableNames) { List<TableInstance> tblInstances = new ArrayList<TableInstance>(); TableResolver resolver = new TableResolver().withMTChecks(); // figure out whether the target table(s) are known or not for (Name targetTableName : tableNames) { /* Database<?> db = null; UnqualifiedName candidateName = null; if (targetTableName.isQualified()) { QualifiedName qn = (QualifiedName) targetTableName; UnqualifiedName ofdb = qn.getNamespace(); candidateName = qn.getUnqualified(); db = pc.findPEDatabase(ofdb); if (db == null) throw new SchemaException(Pass.FIRST, "No such database: " + ofdb); } else { db = pc.getCurrentDatabase(); if (db == null) throw new SchemaException(Pass.FIRST, "No current database"); candidateName = (UnqualifiedName) targetTableName; } TableInstance ti = db.getSchema().buildInstance(pc, candidateName, lockInfo, true); */ TableInstance ti = resolver.lookupTable(pc, targetTableName, lockInfo); if (ti == null) throw new SchemaException(Pass.FIRST, "No such table: " + targetTableName); tblInstances.add(ti.adapt(targetTableName.getUnqualified(), null, ti.getNode(), false)); } return tblInstances; } public Statement buildAnalyzeKeys(List<Name> names) { return new AnalyzeKeysStatement(lookupTables(names)); } @Override public Object getValue(IParameter p) { throw new SchemaException(Pass.SECOND, "Attempt to access parameter value from non value source"); } @Override public Object getLiteral(IDelegatingLiteralExpression dle) { return literals.get(dle.getPosition()).getSecond(); } @Override public Object getTenantID() { throw new SchemaException(Pass.SECOND, "Attempt to access tenant id value from non tenant id source"); } @Override public Object getAutoincValue(IAutoIncrementLiteralExpression exp) { throw new SchemaException(Pass.SECOND, "Attempt to access autoinc value before planning"); } public LoadDataInfileColOption buildLoadDataInfileColOption(String terminated, String enclosed, String escaped) { LoadDataInfileColOption option = new LoadDataInfileColOption(terminated, enclosed, escaped); return option; } public LoadDataInfileLineOption buildLoadDataInfileLineOption(String starting, String terminated) { LoadDataInfileLineOption option = new LoadDataInfileLineOption(starting, terminated); return option; } public Statement buildLoadDataInfileStatement(LoadDataInfileModifier modifier, boolean local, String fileName, boolean replace, boolean ignore, Name tempTableName, Name characterSet, LoadDataInfileColOption colOption, LoadDataInfileLineOption lineOption, ExpressionNode ignoredLines, List<Name> colOrVarList, List<ExpressionNode> updateExprs) { // validate this table is a qualified table or has a current database set Name dbName = null; Name tableName = tempTableName; if (tableName.isQualified()) { dbName = ((QualifiedName) tempTableName).getNamespace(); tableName = ((QualifiedName) tempTableName).getUnqualified(); } if (dbName == null) { dbName = (pc.getCurrentDatabase() == null) ? null : pc.getCurrentDatabase().getName(); } if (dbName == null) { throw new SchemaException(Pass.FIRST, "No database has been specified."); } PEDatabase db = pc.findPEDatabase(dbName); if (db == null) { throw new SchemaException(Pass.FIRST, "No such database: '" + dbName + "'"); } if (colOption != null) { if ((colOption.getEnclosed() != null) && (colOption.getEnclosed().length() > 1)) { throw new SchemaException(Pass.FIRST, "Fields enclosed by must be a single character. Value is '" + colOption.getEnclosed() + "'"); } if ((colOption.getEscaped() != null) && (colOption.getEscaped().length() > 1)) { throw new SchemaException(Pass.FIRST, "Fields escaped by must be a single character. Value is '" + colOption.getEscaped() + "'"); } } if (replace) { throw new SchemaException(Pass.FIRST, "REPLACE option is not currently supported."); } if (ignoredLines != null) { throw new SchemaException(Pass.FIRST, "Ignoring lines is not currently supported."); } if (updateExprs != null) { throw new SchemaException(Pass.FIRST, "SET option is not currently supported."); } LoadDataInfileStatement stmt = new LoadDataInfileStatement(modifier, local, PEStringUtils.dequote(fileName), replace, ignore, db, tableName, characterSet, colOption, lineOption, (ignoredLines == null) ? null : asIntegralLiteral(ignoredLines), colOrVarList, updateExprs); return stmt; } private static String[] unpackXmlParams(List<Pair<String, String>> params, String[] tags) { String[] out = new String[tags.length]; for (Pair<String, String> p : params) { String t = p.getFirst(); for (int i = 0; i < tags.length; i++) { if (tags[i].equals(t)) { if (out[i] != null) throw new SchemaException(Pass.SECOND, "Duplicate " + t + " specified"); if (p.getSecond() != null) out[i] = PEStringUtils.dequote(p.getSecond()); } } } return out; } // 0=xml, 1=match, 2=comment private String[] unpackTemplateParams(List<Pair<String, String>> params) { return unpackXmlParams(params, new String[] { "xml", "match", "comment" }); } public Statement buildCreateTemplateStatement(Name name, boolean ine, List<Pair<String, String>> params) { PETemplate pet = pc.findTemplate(name); if (pet != null) { if (ine) return buildEmptyStatement("create existing template"); throw new SchemaException(Pass.SECOND, "Template " + name.getSQL() + " already exists"); } String[] p = unpackTemplateParams(params); if (p[0] == null) throw new SchemaException(Pass.SECOND, "Must specify template body for add template"); pet = new PETemplate(pc, name.getUnqualified(), p[0], p[1], p[2]); return new PECreateStatement<PETemplate, PersistentTemplate>(pet, true, "TEMPLATE", false); } public Statement buildAlterTemplateStatement(Name name, List<Pair<String, String>> params) { PETemplate pet = pc.findTemplate(name); if (pet == null) throw new SchemaException(Pass.SECOND, "Template " + name.getSQL() + " does not exist"); String[] p = unpackTemplateParams(params); return new PEAlterTemplateStatement(pet, p[0], p[1], p[2]); } public Statement buildDropTemplateStatement(Name name, boolean ifExists) { PETemplate pet = pc.findTemplate(name); if (pet == null) { if (!ifExists) throw new SchemaException(Pass.SECOND, "Template " + name.getSQL() + " does not exist"); return new PEDropStatement<PETemplate, PersistentTemplate>(PETemplate.class, true, true, name, "TEMPLATE"); } return new PEDropStatement<PETemplate, PersistentTemplate>(PETemplate.class, ifExists, true, pet, "TEMPLATE"); } // 0=xml, 1=comment, 2=enabled private String[] unpackRawPlanParams(List<Pair<String, String>> params) { return unpackXmlParams(params, new String[] { "xml", "comment", "enabled" }); } public Statement buildCreateRawPlanStatement(Name name, boolean ine, Name dbName, List<Pair<String, String>> params) { PERawPlan perp = pc.findRawPlan(name); if (perp != null) { if (ine) return buildEmptyStatement("create existing plan"); throw new SchemaException(Pass.SECOND, "Raw plan " + name + " already exists"); } PEDatabase pdb = pc.findPEDatabase(dbName); if (pdb == null) throw new SchemaException(Pass.SECOND, "No such database: " + dbName.getSQL()); // unpack the params String[] fields = unpackRawPlanParams(params); perp = new PERawPlan(pc, name.getUnqualified(), pdb, fields[0], (fields[2] == null ? true : Boolean.valueOf(fields[2])), fields[1]); return new PECreateRawPlanStatement(perp, ine); } public Statement buildDropRawPlanStatement(Name name, boolean ie) { PERawPlan perp = pc.findRawPlan(name); if (perp == null) { if (ie) return buildEmptyStatement("drop nonexistent raw plan"); throw new SchemaException(Pass.SECOND, "Raw plan " + name + " does not exist"); } return new PEDropRawPlanStatement(perp, ie); } public Statement buildAlterRawPlanStatement(Name name, List<Pair<String, String>> params) { PERawPlan perp = pc.findRawPlan(name); if (perp == null) throw new SchemaException(Pass.SECOND, "No such raw plan: " + name); // 0=xml, 1=comment, 2=enabled String[] fields = unpackRawPlanParams(params); return new PEAlterRawPlanStatement(perp, fields[1], (fields[2] == null ? null : Boolean.valueOf(fields[2])), fields[0]); } public Statement buildCreateViewStatementKern(Name viewName, ProjectingStatement viewDef, List<UnqualifiedName> columnNames, String checkOption, List<TableComponent<?>> colDefs) { return PECreateViewStatement.build(pc, viewName, viewDef, columnNames, checkOption, colDefs); } public Statement buildDropViewStatement(Name viewName, boolean ifExists) { if (pc.getCapability() == Capability.PARSING_ONLY) return new PEDropViewStatement(viewName, ifExists); UnqualifiedName tableName = viewName.getUnqualified(); Database<?> ondb = findDatabase(viewName); if (ondb == null) throw new SchemaException(Pass.SECOND, "No such database: '" + viewName + "'"); if (!(ondb instanceof PEDatabase)) throw new SchemaException(Pass.SECOND, "Invalid database for drop view: '" + ondb.getName() + "'"); PEAbstractTable<?> exists = pc.findTable(PEAbstractTable.getTableKey((PEDatabase) ondb, tableName)); if (exists == null) { if (!ifExists) throw new SchemaException(Pass.SECOND, "No such view: " + viewName); return new PEDropViewStatement(viewName, ifExists); } return new PEDropViewStatement(exists.asView(), ifExists); } public Statement buildDropTriggerStatement(Name triggerName, boolean ifExists) { try { final Database<?> parentSchema = getDatabaseForObject(pc, triggerName); final PETrigger trigger = PETrigger.lookup(pc, triggerName, parentSchema); if (trigger != null) { return new PEDropTriggerStatement(trigger, ifExists); } else if (Boolean.TRUE.equals(ifExists)) { return new EmptyStatement("drop nonexistent trigger", StatementType.DROP_TRIGGER); } } catch (final SchemaException e) { final ErrorInfo error = e.getErrorInfo(); if (!AvailableErrors.UNKNOWN_DATABASE.equals(error.getCode())) { throw e; } } throw new SchemaException(new ErrorInfo(AvailableErrors.TRG_DOES_NOT_EXIST)); } public Statement buildPreparePreparedStatement(Name pstmtName, String stmt) { return new PreparePStmtStatement(pstmtName.getUnqualified(), PEStringUtils.dequote(stmt)); } public Statement buildExecutePreparedStatement(Name pstmtName, List<VariableInstance> vars) { return new ExecutePStmtStatement(pstmtName.getUnqualified(), vars); } public Statement buildDeallocatePreparedStatement(Name pstmtName) { return new DeallocatePStmtStatement(pstmtName.getUnqualified()); } public Statement buildShowPlanCache(boolean statsToo) { pc.getPolicyContext().checkRootPermission("show plan cache"); return new ShowPlanCacheStatement(statsToo); } public Statement buildXACommit(UserXid xid, Object onePhase) { return new XACommitTransactionStatement(xid, onePhase != null); } public Statement buildXAEnd(UserXid xid, Object suspend, Object forMigrate) { if (forMigrate != null) throw new SchemaException(Pass.SECOND, "No support for xa end suspend for migrate"); if (suspend != null) throw new SchemaException(Pass.SECOND, "No support for xa end suspend"); return new XAEndTransactionStatement(xid); } public Statement buildXAPrepare(UserXid xid) { return new XAPrepareTransactionStatement(xid); } public Statement buildXARecover() { return new XARecoverTransactionStatement(); } public Statement buildXARollback(UserXid xid) { return new XARollbackTransactionStatement(xid); } public Statement buildXAStart(UserXid xid, Object join, Object resume) { if (join != null) throw new SchemaException(Pass.SECOND, "No support for xa start join"); if (resume != null) throw new SchemaException(Pass.SECOND, "No support for xa start resume"); return new XABeginTransactionStatement(xid); } public UserXid buildXAXid(String gtrid, String bqual, String formatID) { // not quite right yet - we should convert based on the type of the literal return new UserXid(gtrid, bqual, formatID); } public void pushDML(String reason) { if (lockInfo == null && (opts != null && !opts.isIgnoreLocking())) { com.tesora.dve.lockmanager.LockType lt = StatementTraits.getLockType(reason); if (lt == null) throw new SchemaException(Pass.FIRST, "Missing lock type for dml reason " + reason); lockInfo = new LockInfo(lt, reason); } } public NativeCharSetCatalog getNativeCharSetCatalog() { if (supportedCharSets == null) { supportedCharSets = Singletons.require(NativeCharSetCatalog.class); } return supportedCharSets; } public NativeCollationCatalog getNativeCollationCatalog() { if (supportedCollations == null) { supportedCollations = Singletons.require(NativeCollationCatalog.class); } return supportedCollations; } public Statement buildCompoundStatement(List<Statement> stmts) { return new CompoundStatementList(null, stmts); } public Statement buildCreateTrigger(Name triggerName, boolean isBefore, TriggerEvent triggerType, PETable targetTable, Statement body, Token triggerToken) { PETrigger already = pc.findTrigger(PETrigger.buildCacheKey(triggerName.getUnquotedName().get(), (TableCacheKey) targetTable.getCacheKey())); if (already != null) { throw new SchemaException(new ErrorInfo(AvailableErrors.TRG_ALREADY_EXISTS)); } else if (((triggerType == TriggerEvent.UPDATE) || (triggerType == TriggerEvent.DELETE)) && !targetTable.hasUniqueKey(pc)) { final String targetTableName = targetTable.getName().getUnquotedName().get(); throw new SchemaException(new ErrorInfo(AvailableErrors.NO_UNIQUE_KEY_ON_TRG_TARGET, targetTableName)); } final EarlyTriggerTableCollector collector = TriggerTableInstance.collectTriggerTableReferences(body); if ((triggerType == TriggerEvent.INSERT) && collector.hasBeforeColumns()) { throw new SchemaException(new ErrorInfo(AvailableErrors.NO_SUCH_ROW_IN_TRG, TriggerTime.BEFORE.getAlias().get(), TriggerEvent.INSERT.toString())); } else if ((triggerType == TriggerEvent.DELETE) && collector.hasAfterColumns()) { throw new SchemaException(new ErrorInfo(AvailableErrors.NO_SUCH_ROW_IN_TRG, TriggerTime.AFTER.getAlias().get(), TriggerEvent.DELETE.toString())); } String origStmt = getInputSQL(); int l = triggerToken.getCharPositionInLine(); String rawSQL = origStmt.substring(l); String charset = KnownVariables.CHARACTER_SET_CLIENT.getSessionValue(pc.getConnection().getVariableSource()) .getName(); String collation = KnownVariables.COLLATION_CONNECTION .getSessionValue(pc.getConnection().getVariableSource()); String collationDB = KnownVariables.COLLATION_DATABASE .getSessionValue(pc.getConnection().getVariableSource()); SQLMode sqlMode = KnownVariables.SQL_MODE.getSessionValue(pc.getConnection().getVariableSource()); SQLMode globalMode = KnownVariables.SQL_MODE.getGlobalValue(pc.getConnection().getVariableSource()); if (globalMode.equals(sqlMode)) sqlMode = null; PETrigger trig = new PETrigger(pc, triggerName, targetTable, body, triggerType, null /* PEUser user */, collation, charset, collationDB, isBefore ? TriggerTime.BEFORE : TriggerTime.AFTER, sqlMode, rawSQL); popScope(); opts = opts.setResolve(); return new PECreateTriggerStatement(trig); } public Statement addViewTriggerFields(Statement in, boolean createOrReplace, String algo, UserScope definer, String security) { PECreateStatement pect = (PECreateStatement) in; Persistable pt = pect.getCreated(); PEUser user = null; if (definer == null || pc.getOptions().isIgnoreMissingUser()) user = pc.getCurrentUser().get(pc); else { user = pc.findUser(definer.getUserName(), definer.getScope()); if (user == null) // apparently it is legal to specify a user that doesn't exist. in that case, just use the current user user = pc.getCurrentUser().get(pc); // throw new SchemaException(Pass.SECOND, "No such user: " + definer.getSQL()); } if (pt instanceof PEView) { PECreateViewStatement cvs = (PECreateViewStatement) pect; PEView pev = (PEView) pt; pev.setUser(pc, user, false); PEDatabase theDB = cvs.getDatabase(pc); PEAbstractTable<?> existing = pc.findTable(PEAbstractTable.getTableKey(theDB, pev.getName())); if (existing != null && !createOrReplace) { throw new SchemaException(Pass.SECOND, "View " + pev.getName() + " already exists"); } if (createOrReplace) { ((PECreateViewStatement) pect).setCreateOrReplace(); } String algorithm = (algo == null ? "UNDEFINED" : algo); String sec = (security == null ? "DEFINER" : security); pev.setAlgorithm(algorithm); pev.setSecurity(sec); } else { PETrigger trig = (PETrigger) pt; trig.setUser(pc, user); if (createOrReplace || algo != null || security != null) { // TODO: // come back and put in the right error message throw new SchemaException(Pass.FIRST, "Illegal syntax"); } } return pect; } public PETable pushTriggerTable(Name n) { TableInstance targTab = basicResolver.lookupTable(pc, n, lockInfo); PETable theTable = targTab.getAbstractTable().asTable(); long node = pc.getNextTable(); TriggerTableInstance before = new TriggerTableInstance(theTable, node, TriggerTime.BEFORE); TriggerTableInstance after = new TriggerTableInstance(theTable, node, TriggerTime.AFTER); pushScope(); scope.insertTable(before); scope.insertTable(after); opts = opts.clearSetting(Option.RESOLVE); return theTable; } public PETable pushTriggerTable(PETable tab) { // we always use the same node number for trigger tables so that // we can correctly plan when there are both before and after triggers long node = -1; TriggerTableInstance before = new TriggerTableInstance(tab, node, TriggerTime.BEFORE); TriggerTableInstance after = new TriggerTableInstance(tab, node, TriggerTime.AFTER); pushScope(); scope.insertTable(before); scope.insertTable(after); return tab; } public Statement buildCaseStatement(ExpressionNode testExpr, List<StatementWhenClause> whenClauses, Statement elseStatement) { return new CaseStatement(null, testExpr, whenClauses, elseStatement); } public StatementWhenClause buildStatementWhenClause(ExpressionNode testExpr, Statement result) { return new StatementWhenClause(testExpr, result, null); } }