Package org.h2.command

Class Parser

java.lang.Object
org.h2.command.Parser
public class Parser extends Object
The parser is used to convert a SQL statement string to an command object.

  • Field Details

    • WITH_STATEMENT_SUPPORTS_LIMITED_SUB_STATEMENTS

      private static final String WITH_STATEMENT_SUPPORTS_LIMITED_SUB_STATEMENTS
      See Also:

    • database

      private final Database database

    • session

      private final SessionLocal session

    • identifiersToLower

      private final boolean identifiersToLower
      See Also:

    • identifiersToUpper

      private final boolean identifiersToUpper
      See Also:

    • variableBinary

      private final boolean variableBinary
      See Also:

    • nonKeywords

      private final BitSet nonKeywords

    • tokens

      ArrayList<Token> tokens

    • tokenIndex

      int tokenIndex

    • token

      Token token

    • currentTokenType

      private int currentTokenType

    • currentToken

      private String currentToken

    • sqlCommand

      private String sqlCommand

    • createView

      private CreateView createView

    • currentPrepared

      private Prepared currentPrepared

    • currentSelect

      private Select currentSelect

    • cteCleanups

      private List<TableView> cteCleanups

    • parameters

      private ArrayList<Parameter> parameters

    • suppliedParameters

      private ArrayList<Parameter> suppliedParameters

    • schemaName

      private String schemaName

    • expectedList

      private ArrayList<String> expectedList

    • rightsChecked

      private boolean rightsChecked

    • recompileAlways

      private boolean recompileAlways

    • literalsChecked

      private boolean literalsChecked

    • orderInFrom

      private int orderInFrom

    • parseDomainConstraint

      private boolean parseDomainConstraint

  • Constructor Details

    • Parser

      public Parser(SessionLocal session)
      Creates a new instance of parser.
      Parameters:
      session - the session

    • Parser

      public Parser()
      Creates a new instance of parser for special use cases.

  • Method Details

    • parseNonKeywords

      public static BitSet parseNonKeywords(String[] nonKeywords)
      Parses the specified collection of non-keywords.
      Parameters:
      nonKeywords - array of non-keywords in upper case
      Returns:
      bit set of non-keywords, or null

    • formatNonKeywords

      public static String formatNonKeywords(BitSet nonKeywords)
      Formats a comma-separated list of keywords.
      Parameters:
      nonKeywords - bit set of non-keywords, or null
      Returns:
      comma-separated list of non-keywords

    • prepare

      public Prepared prepare(String sql)
      Parse the statement and prepare it for execution.
      Parameters:
      sql - the SQL statement to parse
      Returns:
      the prepared object

    • prepareCommand

      public Command prepareCommand(String sql)
      Parse a statement or a list of statements, and prepare it for execution.
      Parameters:
      sql - the SQL statement to parse
      Returns:
      the command object

    • prepareCommandList

      private CommandList prepareCommandList(CommandContainer command, Prepared p, String sql, String remainingSql, ArrayList<Token> remainingTokens)

    • getRemainingTokens

      private ArrayList<Token> getRemainingTokens(int offset)

    • parse

      Prepared parse(String sql, ArrayList<Token> tokens)
      Parse the statement, but don't prepare it for execution.
      Parameters:
      sql - the SQL statement to parse
      tokens - tokens, or null
      Returns:
      the prepared object

    • parse

      private Prepared parse(String sql, boolean withExpectedList)

    • parsePrepared

      private Prepared parsePrepared()

    • getSyntaxError

      private DbException getSyntaxError()

    • parseBackup

      private Prepared parseBackup()

    • parseAnalyze

      private Prepared parseAnalyze()

    • parseBegin

      private TransactionCommand parseBegin()

    • parseCommit

      private TransactionCommand parseCommit()

    • parseShutdown

      private TransactionCommand parseShutdown()

    • parseRollback

      private TransactionCommand parseRollback()

    • parsePrepare

      private Prepared parsePrepare()

    • parsePrepareProcedure

      private Prepared parsePrepareProcedure()

    • parseSavepoint

      private TransactionCommand parseSavepoint()

    • parseReleaseSavepoint

      private Prepared parseReleaseSavepoint()

    • findSchema

      private Schema findSchema(String schemaName)

    • getSchema

      private Schema getSchema(String schemaName)

    • getSchema

      private Schema getSchema()

    • getSchemaWithDefault

      private Schema getSchemaWithDefault()

    • readTableColumn

      private Column readTableColumn(TableFilter filter)

    • readTableColumn

      private String readTableColumn(TableFilter filter, String tableAlias)

    • parseUpdate

      private Update parseUpdate(int start)

    • readUpdateSetClause

      private SetClauseList readUpdateSetClause(TableFilter filter)

    • readSimpleTableFilter

      private TableFilter readSimpleTableFilter()

    • parseDelete

      private Delete parseDelete(int start)

    • readFetchOrLimit

      private Expression readFetchOrLimit()

    • parseIndexColumnList

      private IndexColumn[] parseIndexColumnList()

    • parseSortType

      private int parseSortType()

    • parseColumnList

      private String[] parseColumnList()

    • parseColumnList

      private Column[] parseColumnList(Table table)

    • parseColumn

      private Column parseColumn(Table table)

    • readIfMore

      private boolean readIfMore()
      Read comma or closing brace.
      Returns:
      true if comma is read, false if brace is read

    • parseHelp

      private Prepared parseHelp()

    • parseShow

      private Prepared parseShow()

    • prepare

      private static Prepared prepare(SessionLocal s, String sql, ArrayList<Value> paramValues)

    • isDerivedTable

      private boolean isDerivedTable()

    • isQuery

      private boolean isQuery()

    • scanToCloseParen

      private int scanToCloseParen(int offset)

    • isQueryQuick

      private boolean isQueryQuick()

    • isDirectQuery

      private boolean isDirectQuery(int offset)

    • parseMerge

      private Prepared parseMerge(int start)

    • parseMergeInto

      private Prepared parseMergeInto(TableFilter targetTableFilter, int start)

    • parseMergeUsing

      private MergeUsing parseMergeUsing(TableFilter targetTableFilter, int start)

    • parseWhenMatched

      private void parseWhenMatched(MergeUsing command)

    • parseWhenNotMatched

      private void parseWhenNotMatched(MergeUsing command)

    • parseInsert

      private Insert parseInsert(int start)

    • readIfOverriding

      private Boolean readIfOverriding()

    • parseInsertSet

      private void parseInsertSet(Insert command, Table table, Column[] columns)

    • parseInsertCompatibility

      private void parseInsertCompatibility(Insert command, Table table, Mode mode)

    • parseReplace

      private Merge parseReplace(int start)
      MySQL compatibility. REPLACE is similar to MERGE.

    • parseValuesForCommand

      private void parseValuesForCommand(CommandWithValues command)

    • readTablePrimary

      private TableFilter readTablePrimary()

    • readCorrelation

      private TableFilter readCorrelation(TableFilter tableFilter)

    • readDerivedTableWithCorrelation

      private TableFilter readDerivedTableWithCorrelation()

    • buildTableFilter

      private TableFilter buildTableFilter(Table table, String alias, ArrayList<String> derivedColumnNames, IndexHints indexHints)

    • readDataChangeDeltaTable

      private Table readDataChangeDeltaTable(String resultOptionName, int backupIndex)

    • readTableFunction

      private TableFunction readTableFunction(String name, Schema schema)

    • readIfUseIndex

      private boolean readIfUseIndex()

    • parseIndexHints

      private IndexHints parseIndexHints(Table table)

    • readFromAlias

      private String readFromAlias(String alias)

    • readDerivedColumnNames

      private ArrayList<String> readDerivedColumnNames()

    • discardWithTableHints

      private void discardWithTableHints()

    • discardTableHint

      private void discardTableHint()

    • parseTruncate

      private Prepared parseTruncate()

    • readIfExists

      private boolean readIfExists(boolean ifExists)

    • parseComment

      private Prepared parseComment()

    • parseDrop

      private Prepared parseDrop()

    • parseDropDomain

      private DropDomain parseDropDomain()

    • parseDropAggregate

      private DropAggregate parseDropAggregate()

    • readTableReference

      private TableFilter readTableReference()

    • readJoinSpecification

      private Expression readJoinSpecification(TableFilter filter1, TableFilter filter2, boolean rightJoin)

    • addJoinColumn

      private Expression addJoinColumn(Expression on, TableFilter filter1, TableFilter filter2, Column column1, Column column2, boolean rightJoin)

    • addJoin

      private void addJoin(TableFilter top, TableFilter join, boolean outer, Expression on)
      Add one join to another. This method creates nested join between them if required.
      Parameters:
      top - parent join
      join - child join
      outer - if child join is an outer join
      on - the join condition
      See Also:

    • parseExecutePostgre

      private Prepared parseExecutePostgre()

    • parseExecuteSQLServer

      private Prepared parseExecuteSQLServer()

    • getFunctionAliasWithinPath

      private FunctionAlias getFunctionAliasWithinPath(String name, Schema schema)

    • parseDeallocate

      private DeallocateProcedure parseDeallocate()

    • parseExplain

      private Explain parseExplain()

    • parseQuery

      private Query parseQuery()

    • parseWithStatementOrQuery

      private Prepared parseWithStatementOrQuery(int start)

    • parseQueryExpression

      private Query parseQueryExpression()

    • parseQueryExpressionBodyAndEndOfQuery

      private Query parseQueryExpressionBodyAndEndOfQuery()

    • parseQueryExpressionBody

      private Query parseQueryExpressionBody()

    • parseQueryTerm

      private Query parseQueryTerm()

    • parseEndOfQuery

      private void parseEndOfQuery(Query command)

    • parseIsolationClause

      private void parseIsolationClause()
      DB2 isolation clause

    • parseQueryPrimary

      private Query parseQueryPrimary()

    • parseSelectFromPart

      private void parseSelectFromPart(Select command)

    • parseSelectExpressions

      private void parseSelectExpressions(Select command)

    • parseSelect

      private Select parseSelect(int start)

    • isOrdinaryGroupingSet

      private boolean isOrdinaryGroupingSet()
      Checks whether current opening parenthesis can be a start of ordinary grouping set. This method reads this parenthesis if it is.
      Returns:
      whether current opening parenthesis can be a start of ordinary grouping set

    • parseExplicitTable

      private Query parseExplicitTable(int start)

    • setSQL

      private void setSQL(Prepared command, int start)

    • readExpressionOrDefault

      private Expression readExpressionOrDefault()

    • readExpressionWithGlobalConditions

      private Expression readExpressionWithGlobalConditions()

    • readExpression

      private Expression readExpression()

    • readExpressionPart2

      private Expression readExpressionPart2(Expression r1)

    • readAnd

      private Expression readAnd(Expression r)

    • readCondition

      private Expression readCondition()

    • readConditionRightHandSide

      private Expression readConditionRightHandSide(Expression r, boolean not, boolean whenOperand)

    • readConditionIs

      private Expression readConditionIs(Expression left, boolean whenOperand)

    • readTypePredicate

      private TypePredicate readTypePredicate(Expression left, boolean not, boolean whenOperand)

    • readInPredicate

      private Expression readInPredicate(Expression left, boolean not, boolean whenOperand)

    • readJsonPredicate

      private IsJsonPredicate readJsonPredicate(Expression left, boolean not, boolean whenOperand)

    • readLikePredicate

      private Expression readLikePredicate(Expression left, CompareLike.LikeType likeType, boolean not, boolean whenOperand)

    • readComparison

      private Expression readComparison(Expression left, int compareType, boolean whenOperand)

    • readConcat

      private Expression readConcat()

    • readSum

      private Expression readSum()

    • readFactor

      private Expression readFactor()

    • readTildeCondition

      private Expression readTildeCondition(Expression r, boolean not)

    • readAggregate

      private Expression readAggregate(AggregateType aggregateType, String aggregateName)

    • readWithinGroup

      private Aggregate readWithinGroup(AggregateType aggregateType, Expression[] args, boolean distinct, Object extraArguments, boolean forHypotheticalSet, boolean simple)

    • readAggregateOrder

      private void readAggregateOrder(Aggregate r, Expression expr, boolean parseSortType)

    • readIfOrderBy

      private ArrayList<QueryOrderBy> readIfOrderBy()

    • parseSortSpecificationList

      private ArrayList<QueryOrderBy> parseSortSpecificationList()

    • parseSortSpecification

      private QueryOrderBy parseSortSpecification()

    • readUserDefinedFunctionIf

      private Expression readUserDefinedFunctionIf(Schema schema, String functionName)

    • readDistinctAgg

      private boolean readDistinctAgg()

    • readFilterAndOver

      private void readFilterAndOver(AbstractAggregate aggregate)

    • readOver

      private void readOver(DataAnalysisOperation operation)

    • readWindowNameOrSpecification

      private Window readWindowNameOrSpecification()

    • readWindowSpecification

      private Window readWindowSpecification()

    • readWindowFrame

      private WindowFrame readWindowFrame()

    • readWindowFrameStarting

      private WindowFrameBound readWindowFrameStarting()

    • readWindowFrameRange

      private WindowFrameBound readWindowFrameRange()

    • readFunction

      private Expression readFunction(Schema schema, String name)

    • readFunctionWithSchema

      private Expression readFunctionWithSchema(Schema schema, String name, String upperName)

    • readCompatibilityFunction

      private Expression readCompatibilityFunction(String name)

    • readParameters

      private <T extends ExpressionWithVariableParameters> T readParameters(T expression)

    • decodeToWhen

      private SimpleCase.SimpleWhen decodeToWhen(Expression caseOperand, boolean canOptimize, Expression whenOperand, Expression result)

    • readCompatibilityCase

      private Expression readCompatibilityCase(Expression when)

    • readCompatibilitySequenceValueFunction

      private Expression readCompatibilitySequenceValueFunction(boolean current)

    • readBuiltinFunctionIf

      private Expression readBuiltinFunctionIf(String upperName)

    • readDateTimeFormatFunction

      private Expression readDateTimeFormatFunction(int function)

    • readTrimFunction

      private Expression readTrimFunction()

    • readUnnestFunction

      private ArrayTableFunction readUnnestFunction()

    • readTableFunction

      private ArrayTableFunction readTableFunction(int functionType)

    • readSingleArgument

      private Expression readSingleArgument()

    • readNextArgument

      private Expression readNextArgument()

    • readLastArgument

      private Expression readLastArgument()

    • readIfSingleArgument

      private Expression readIfSingleArgument()

    • readIfArgument

      private Expression readIfArgument()

    • readCoalesceFunction

      private Expression readCoalesceFunction(int function)

    • readConcatFunction

      private Expression readConcatFunction(int function)

    • readSubstringFunction

      private Expression readSubstringFunction()

    • readDateTimeField

      private int readDateTimeField()

    • readWindowFunction

      private WindowFunction readWindowFunction(String name)

    • readFromFirstOrLast

      private void readFromFirstOrLast(WindowFunction function)

    • readRespectOrIgnoreNulls

      private void readRespectOrIgnoreNulls(WindowFunction function)

    • readJsonObjectFunctionFlags

      private boolean readJsonObjectFunctionFlags(ExpressionWithFlags function, boolean forArray)

    • readKeywordCompatibilityFunctionOrColumn

      private Expression readKeywordCompatibilityFunctionOrColumn()

    • readCurrentDateTimeValueFunction

      private Expression readCurrentDateTimeValueFunction(int function, boolean hasParen, String name)

    • readIfWildcardRowidOrSequencePseudoColumn

      private Expression readIfWildcardRowidOrSequencePseudoColumn(String schema, String objectName)

    • parseWildcard

      private Wildcard parseWildcard(String schema, String objectName)

    • readIfSequencePseudoColumn

      private SequenceValue readIfSequencePseudoColumn(String schema, String objectName)

    • readTermObjectDot

      private Expression readTermObjectDot(String objectName)

    • checkDatabaseName

      private void checkDatabaseName(String databaseName)

    • readParameter

      private Parameter readParameter()

    • readTerm

      private Expression readTerm()

    • readCurrentGeneralValueSpecification

      private Expression readCurrentGeneralValueSpecification(int specification)

    • readColumnIfNotFunction

      private Expression readColumnIfNotFunction()

    • readSetFunction

      private Expression readSetFunction()

    • readOnDuplicateKeyValues

      private Expression readOnDuplicateKeyValues(Table table, Update update)

    • readTermWithIdentifier

      private Expression readTermWithIdentifier(String name, boolean quoted)

    • getCurrentPrepared

      private Prepared getCurrentPrepared()

    • readInterval

      private Expression readInterval()

    • parseDB2SpecialRegisters

      private Expression parseDB2SpecialRegisters(String name)

    • readCase

      private Expression readCase()

    • readSimpleWhenClause

      private SimpleCase.SimpleWhen readSimpleWhenClause(Expression caseOperand)

    • readWhenOperand

      private Expression readWhenOperand(Expression caseOperand)

    • readNonNegativeInt

      private int readNonNegativeInt()

    • readInt

      private int readInt()

    • readPositiveLong

      private long readPositiveLong()

    • readLong

      private long readLong()

    • readBooleanSetting

      private boolean readBooleanSetting()

    • readString

      private String readString()

    • readIdentifierWithSchema

      private String readIdentifierWithSchema(String defaultSchemaName)

    • readIdentifierWithSchema2

      private String readIdentifierWithSchema2(String s)

    • readIdentifierWithSchema

      private String readIdentifierWithSchema()

    • readIdentifier

      private String readIdentifier()

    • read

      private void read(String expected)

    • read

      private void read(int tokenType)

    • readIf

      private boolean readIf(String tokenName)

    • readIf

      private boolean readIf(int tokenType)

    • isToken

      private boolean isToken(String tokenName)

    • isToken

      private boolean isToken(int tokenType)

    • equalsToken

      private boolean equalsToken(String a, String b)

    • isIdentifier

      private boolean isIdentifier()

    • addExpected

      private void addExpected(String token)

    • addExpected

      private void addExpected(int tokenType)

    • addMultipleExpected

      private void addMultipleExpected(int... tokenTypes)

    • read

      private void read()

    • checkLiterals

      private void checkLiterals()

    • initialize

      private void initialize(String sql, ArrayList<Token> tokens, boolean stopOnCloseParen)

    • resetTokenIndex

      private void resetTokenIndex()

    • setTokenIndex

      void setTokenIndex(int index)

    • isKeyword

      private static boolean isKeyword(int tokenType)

    • isKeyword

      private boolean isKeyword(String s)

    • upperName

      private String upperName(String name)

    • parseColumnForTable

      private Column parseColumnForTable(String columnName, boolean defaultNullable)

    • parseCompatibilityIdentityOptions

      private void parseCompatibilityIdentityOptions(Column column)

    • readCommentIf

      private String readCommentIf()

    • parseColumnWithType

      private Column parseColumnWithType(String columnName)

    • parseDataType

      private TypeInfo parseDataType()

    • readIfDataType

      private TypeInfo readIfDataType()

    • readIfDataType1

      private TypeInfo readIfDataType1()

    • getInvalidPrecisionException

      private static DbException getInvalidPrecisionException(DataType dataType, long precision)

    • getColumnWithDomain

      private static Column getColumnWithDomain(String columnName, Domain domain)

    • parseFloatType

      private TypeInfo parseFloatType()

    • parseNumericType

      private TypeInfo parseNumericType(boolean decimal)

    • parseDecfloatType

      private TypeInfo parseDecfloatType()

    • getInvalidNumericPrecisionException

      private static DbException getInvalidNumericPrecisionException(long precision)

    • parseTimeType

      private TypeInfo parseTimeType()

    • parseTimestampType

      private TypeInfo parseTimestampType()

    • parseDateTimeType

      private TypeInfo parseDateTimeType(boolean smallDateTime)

    • readIntervalQualifier

      private TypeInfo readIntervalQualifier()

    • intervalQualifierError

      private DbException intervalQualifierError()

    • intervalDayError

      private DbException intervalDayError()

    • intervalHourError

      private DbException intervalHourError()

    • parseArrayType

      private TypeInfo parseArrayType(TypeInfo componentType)

    • parseEnumType

      private TypeInfo parseEnumType()

    • parseGeometryType

      private TypeInfo parseGeometryType()

    • parseRowType

      private TypeInfo parseRowType()

    • readPrecision

      private long readPrecision(int valueType)

    • parseCreate

      private Prepared parseCreate()

    • addRoleOrRight

      private boolean addRoleOrRight(GrantRevoke command)
      Returns:
      true if we expect to see a TABLE clause

    • parseGrantRevoke

      private GrantRevoke parseGrantRevoke(int operationType)

    • parseValues

      private TableValueConstructor parseValues()

    • parseValuesRow

      private ArrayList<Expression> parseValuesRow(ArrayList<Expression> row)

    • parseCall

      private Call parseCall()

    • parseCreateRole

      private CreateRole parseCreateRole()

    • parseCreateSchema

      private CreateSchema parseCreateSchema()

    • readTableEngineParams

      private ArrayList<String> readTableEngineParams()

    • parseCreateSequence

      private CreateSequence parseCreateSequence()

    • readIfNotExists

      private boolean readIfNotExists()

    • parseCreateConstant

      private CreateConstant parseCreateConstant()

    • parseCreateAggregate

      private CreateAggregate parseCreateAggregate(boolean force)

    • parseCreateDomain

      private CreateDomain parseCreateDomain()

    • parseCreateTrigger

      private CreateTrigger parseCreateTrigger(boolean force)

    • parseCreateUser

      private CreateUser parseCreateUser()

    • parseCreateFunctionAlias

      private CreateFunctionAlias parseCreateFunctionAlias(boolean force)

    • readStringOrIdentifier

      private String readStringOrIdentifier()

    • isReservedFunctionName

      private boolean isReservedFunctionName(String name)

    • parseWith

      private Prepared parseWith()

    • parseWith1

      private Prepared parseWith1(List<TableView> viewsCreated)

    • parseWithQuery

      private Prepared parseWithQuery()

    • parseSingleCommonTableExpression

      private TableView parseSingleCommonTableExpression(boolean isTemporary)

    • createCTEView

      private TableView createCTEView(String cteViewName, String querySQL, List<Column> columnTemplateList, boolean allowRecursiveQueryDetection, boolean addViewToSession, boolean isTemporary)

    • parseCreateView

      private CreateView parseCreateView(boolean force, boolean orReplace)

    • parseCheckpoint

      private TransactionCommand parseCheckpoint()

    • parseAlter

      private Prepared parseAlter()

    • checkSchema

      private void checkSchema(Schema old)

    • parseAlterIndex

      private AlterIndexRename parseAlterIndex()

    • parseAlterDomain

      private DefineCommand parseAlterDomain()

    • parseAlterView

      private DefineCommand parseAlterView()

    • parseAlterSchema

      private Prepared parseAlterSchema()

    • parseAlterSequence

      private AlterSequence parseAlterSequence()

    • parseSequenceOptions

      private boolean parseSequenceOptions(SequenceOptions options, CreateSequence command, boolean allowDataType, boolean forAlterColumn)

    • parseCreateSequenceOption

      private boolean parseCreateSequenceOption(CreateSequence command)

    • parseBasicSequenceOption

      private boolean parseBasicSequenceOption(SequenceOptions options)

    • parseAlterUser

      private AlterUser parseAlterUser()

    • readIfEqualOrTo

      private void readIfEqualOrTo()

    • parseSet

      private Prepared parseSet()

    • parseSetTransactionMode

      private Prepared parseSetTransactionMode()

    • readExpressionOrIdentifier

      private Expression readExpressionOrIdentifier()

    • parseUse

      private Prepared parseUse()

    • parseSetCollation

      private Set parseSetCollation()

    • readSetCompatibility

      private Prepared readSetCompatibility(Mode.ModeEnum modeEnum)

    • parseRunScript

      private RunScriptCommand parseRunScript()

    • parseScript

      private ScriptCommand parseScript()

    • isDualTable

      private boolean isDualTable(String tableName)
      Is this the Oracle DUAL table or the IBM/DB2 SYSIBM table?
      Parameters:
      tableName - table name.
      Returns:
      true if the table is DUAL special table. Otherwise returns false.
      See Also:

    • readTableOrView

      private Table readTableOrView()

    • readTableOrView

      private Table readTableOrView(String tableName)

    • getTableOrViewNotFoundDbException

      private DbException getTableOrViewNotFoundDbException(String tableName)

    • getTableOrViewNotFoundDbException

      private DbException getTableOrViewNotFoundDbException(String schemaName, String tableName)

    • getTableOrViewNotFoundDbException

      private DbException getTableOrViewNotFoundDbException(Set<String> schemaNames, String tableName)

    • findTableNameCandidates

      private void findTableNameCandidates(String schemaName, String tableName, Set<String> candidates)

    • findUserDefinedFunctionWithinPath

      private UserDefinedFunction findUserDefinedFunctionWithinPath(Schema schema, String name)

    • findSequence

      private Sequence findSequence(String schema, String sequenceName)

    • readSequence

      private Sequence readSequence()

    • parseAlterTable

      private Prepared parseAlterTable()

    • parseAlterTableAlter

      private Prepared parseAlterTableAlter(Schema schema, String tableName, boolean ifTableExists)

    • getAlterTableAlterColumnDropDefaultExpression

      private Prepared getAlterTableAlterColumnDropDefaultExpression(Schema schema, String tableName, boolean ifTableExists, Column column, int type)

    • parseAlterTableAlterColumnIdentity

      private Prepared parseAlterTableAlterColumnIdentity(Schema schema, String tableName, boolean ifTableExists, Column column)

    • parseAlterTableAlterColumnSet

      private Prepared parseAlterTableAlterColumnSet(Schema schema, String tableName, boolean ifTableExists, boolean ifExists, String columnName, Column column)

    • parseAlterTableDrop

      private Prepared parseAlterTableDrop(Schema schema, String tableName, boolean ifTableExists)

    • parseAlterTableDropCompatibility

      private Prepared parseAlterTableDropCompatibility(Schema schema, String tableName, boolean ifTableExists)

    • parseAlterTableRename

      private Prepared parseAlterTableRename(Schema schema, String tableName, boolean ifTableExists)

    • parseAlterTableSet

      private Prepared parseAlterTableSet(Schema schema, String tableName, boolean ifTableExists)

    • parseAlterTableCompatibility

      private Prepared parseAlterTableCompatibility(Schema schema, String tableName, boolean ifTableExists, Mode mode)

    • tableIfTableExists

      private Table tableIfTableExists(Schema schema, String tableName, boolean ifTableExists)

    • columnIfTableExists

      private Column columnIfTableExists(Schema schema, String tableName, String columnName, boolean ifTableExists, boolean ifExists)

    • commandIfTableExists

      private Prepared commandIfTableExists(Schema schema, String tableName, boolean ifTableExists, Prepared commandIfTableExists)

    • parseAlterTableAlterColumnType

      private AlterTableAlterColumn parseAlterTableAlterColumnType(Schema schema, String tableName, String columnName, boolean ifTableExists, boolean ifExists, boolean preserveNotNull)

    • parseAlterTableAlterColumnDataType

      private AlterTableAlterColumn parseAlterTableAlterColumnDataType(Schema schema, String tableName, String columnName, boolean ifTableExists, boolean ifExists)

    • parseAlterTableAddColumn

      private AlterTableAlterColumn parseAlterTableAddColumn(String tableName, Schema schema, boolean ifTableExists)

    • parseAlterColumnUsingIf

      private void parseAlterColumnUsingIf(AlterTableAlterColumn command)

    • parseAction

      private ConstraintActionType parseAction()

    • parseCascadeOrRestrict

      private ConstraintActionType parseCascadeOrRestrict()

    • parseTableConstraintIf

      private DefineCommand parseTableConstraintIf(String tableName, Schema schema, boolean ifTableExists)

    • parseReferences

      private void parseReferences(AlterTableAddConstraint command, Schema schema, String tableName)

    • parseCreateLinkedTable

      private CreateLinkedTable parseCreateLinkedTable(boolean temp, boolean globalTemp, boolean force)

    • parseCreateTable

      private CreateTable parseCreateTable(boolean temp, boolean globalTemp, boolean persistIndexes)

    • parseTableColumnDefinition

      private void parseTableColumnDefinition(CommandWithColumns command, Schema schema, String tableName, boolean forCreateTable)

    • newPrimaryKeyConstraintCommand

      public static AlterTableAddConstraint newPrimaryKeyConstraintCommand(SessionLocal session, Schema schema, String tableName, Column column)
      Create a new alter table command.
      Parameters:
      session - the session
      schema - the schema
      tableName - the table
      column - the column
      Returns:
      the command

    • readColumnConstraints

      private void readColumnConstraints(CommandWithColumns command, Schema schema, String tableName, Column column)

    • parseCompatibilityIdentity

      private boolean parseCompatibilityIdentity(Column column, Mode mode)

    • parseCreateTableMySQLTableOptions

      private void parseCreateTableMySQLTableOptions(CreateTable command)

    • readMySQLCharset

      private void readMySQLCharset()

    • parseNotNullConstraint

      private Parser.NullConstraintType parseNotNullConstraint(Parser.NullConstraintType nullConstraint)

    • parseNotNullConstraint

      private Parser.NullConstraintType parseNotNullConstraint()

    • parseNotNullCompatibility

      private Parser.NullConstraintType parseNotNullCompatibility(Parser.NullConstraintType nullConstraint)

    • parseCreateSynonym

      private CreateSynonym parseCreateSynonym(boolean orReplace)

    • getCompareType

      private static int getCompareType(int tokenType)

    • quoteIdentifier

      public static String quoteIdentifier(String s, int sqlFlags)
      Add double quotes around an identifier if required.
      Parameters:
      s - the identifier
      sqlFlags - formatting flags
      Returns:
      the quoted identifier

    • setLiteralsChecked

      public void setLiteralsChecked(boolean literalsChecked)

    • setRightsChecked

      public void setRightsChecked(boolean rightsChecked)

    • setSuppliedParameters

      public void setSuppliedParameters(ArrayList<Parameter> suppliedParameters)

    • parseExpression

      public Expression parseExpression(String sql)
      Parse a SQL code snippet that represents an expression.
      Parameters:
      sql - the code snippet
      Returns:
      the expression object

    • parseDomainConstraintExpression

      public Expression parseDomainConstraintExpression(String sql)
      Parse a SQL code snippet that represents an expression for a domain constraint.
      Parameters:
      sql - the code snippet
      Returns:
      the expression object

    • parseTableName

      public Table parseTableName(String sql)
      Parse a SQL code snippet that represents a table name.
      Parameters:
      sql - the code snippet
      Returns:
      the table object

    • parseColumnList

      public Object parseColumnList(String sql, int offset)
      Parses a list of column names or numbers in parentheses.
      Parameters:
      sql - the source SQL
      offset - the initial offset
      Returns:
      the array of column names (String[]) or numbers (int[])
      Throws:
      DbException - on syntax error

    • getLastParseIndex

      public int getLastParseIndex()
      Returns the last parse index.
      Returns:
      the last parse index

    • toString

      public String toString()
      Overrides:
      toString in class Object