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