org.vesalainen.parsers.sql

Class SqlParser<R,C>

java.lang.Object

org.vesalainen.parsers.sql.SqlParser<R,C>

public abstract class SqlParser<R,C>
extends Object

This SQL parser implements a subset of the standard

Author:

Timo Vesalainen

See Also:

BNF Syntax for SQL-statements, BNF Grammar for ISO/IEC 9075-2:2003 - Database Language SQL (SQL-2003) SQL/Foundation

Functions, Engine.createFunction

Field Summary

Fields

Modifier and Type	Field and Description
protected SQLDateParser	dateParser

Constructor Summary

Constructors

Constructor and Description
SqlParser()

Method Summary

Methods

Modifier and Type	Method and Description
protected void	asterisk()
protected Statement<R,C>	batchStatement(List<Statement<R,C>> list, Deque<List<Table<R,C>>> tableListStack, LinkedHashMap<String,Placeholder> placeholderMap, Engine<R,C> engine)
protected Statement<R,C>	beginWork(LinkedHashMap<String,Placeholder<R,C>> placeholderMap, Engine<R,C> engine)
protected Condition	betweenPredicate1(RowValue rv1, RowValue rv2, RowValue rv3, Deque<List<Table<R,C>>> tableListStack)
protected Condition	betweenPredicate2(RowValue rv1, RowValue rv2, RowValue rv3, Deque<List<Table<R,C>>> tableListStack)
protected Condition	booleanFactor1(Condition test)
protected Condition	booleanFactor2(Condition test)
protected Condition	booleanPredicate(Condition predicate)
protected Condition	booleanPrimary(Condition predicate)
protected Condition	booleanTerm(Condition factor)
protected Condition	booleanTerm(Condition term, Condition factor)
protected Condition	booleanTest1(Condition primary)
protected Condition	booleanTest2(Condition primary, TruthValue tvl)
protected Condition	booleanTest3(Condition primary, TruthValue tvl)
protected Condition	booleanValueExpression(Condition term)
protected Condition	booleanValueExpression(Condition expression, Condition term)
protected void	cComment(org.vesalainen.parser.util.InputReader reader, SQLLocator locator)
protected abstract void	check(org.vesalainen.parser.util.InputReader reader, SQLLocator locator)
protected abstract void	check(String sql, SQLLocator locator)
protected abstract String	column(String column)
protected ColumnReference	columnReference(String part, List<String> list, String title)
protected Statement<R,C>	commitWork(LinkedHashMap<String,Placeholder<R,C>> placeholderMap, Engine<R,C> engine)
protected Condition	comparisonPredicate1(RowValue rv1, RowValue rv2, Deque<List<Table<R,C>>> tableListStack)
protected Condition	comparisonPredicate2(RowValue rv1, RowValue rv2, Deque<List<Table<R,C>>> tableListStack)
protected Condition	comparisonPredicate3(RowValue rv1, RowValue rv2, Deque<List<Table<R,C>>> tableListStack)
protected Condition	comparisonPredicate4(RowValue rv1, RowValue rv2, Deque<List<Table<R,C>>> tableListStack)
protected Condition	comparisonPredicate5(RowValue rv1, RowValue rv2, Deque<List<Table<R,C>>> tableListStack)
protected Condition	comparisonPredicate6(RowValue rv1, RowValue rv2, Deque<List<Table<R,C>>> tableListStack)
protected C	currentTimestampValue(Engine<R,C> engine)
protected C	currentYearValue(Engine<R,C> engine)
protected Literal<R,C>	dateLiteral(C date, Engine<R,C> engine)
protected C	dateValue(String string, Engine<R,C> engine)
protected Number	decimal(String value)
protected void	deleteStart(Deque<List<Table<R,C>>> tableListStack)
protected Statement<R,C>	deleteStatementSearched(Table<R,C> table, Condition<R,C> condition, LinkedHashMap<String,Placeholder<R,C>> placeholderMap, Engine<R,C> engine, Deque<List<Table<R,C>>> tableListStack)
protected Statement<R,C>	deleteStatementSearched(Table<R,C> table, LinkedHashMap<String,Placeholder<R,C>> placeholderMap, Engine<R,C> engine, Deque<List<Table<R,C>>> tableListStack)
protected Statement	describeSpecification(String identifier, LinkedHashMap<String,Placeholder> placeholderMap, Engine<R,C> engine)
protected void	doubleSlashComment(org.vesalainen.parser.util.InputReader reader, SQLLocator locator)
protected TruthValue	falseL(org.vesalainen.parser.util.InputReader reader, SQLLocator locator)
protected void	fromClause(Table<R,C> table, List<Table<R,C>> list)
protected InsertColumnsAndSource<R,C>	fromConstructor(String column, List<String> columnList, Literal<R,C> literal, List<Literal<R,C>> valueList)
protected InsertColumnsAndSource<R,C>	fromSubQuery(String column, List<String> columnList, Statement subSelect)
protected abstract String	function(String func)
protected void	hashComment(org.vesalainen.parser.util.InputReader reader, SQLLocator locator)
protected abstract String	identifier(String value)
protected Condition	inPredicate1(RowValue rv, Collection<RowValue> inValues, Deque<List<Table<R,C>>> tableListStack)
protected Condition	inPredicate2(RowValue rv, Collection<RowValue> inValues, Deque<List<Table<R,C>>> tableListStack)
protected abstract Collection<RowValue>	inPredicateValue1(Collection<RowValue> inValues)
protected abstract InsertColumnsAndSource<R,C>	insertColumnsAndSource(InsertColumnsAndSource<R,C> insertColumnsAndSource)
protected void	insertStart(Deque<List<Table<R,C>>> tableListStack)
protected Statement<R,C>	insertStatement(Table<R,C> table, InsertColumnsAndSource<R,C> insertColumnsAndSource, LinkedHashMap<String,Placeholder<R,C>> placeholderMap, Engine<R,C> engine, Deque<List<Table<R,C>>> tableListStack)
protected Number	integer(String value)
protected Collection<RowValue>	inValueList(Collection<RowValue> inValues, RowValue rv)
protected Collection<RowValue>	inValueList(RowValue rv)
protected Condition	likePredicate1(RowValue rv, String pattern)
protected Condition	likePredicate2(RowValue rv, String pattern, String escape)
protected Condition	likePredicate3(RowValue rv, String pattern)
protected Condition	likePredicate4(RowValue rv, String pattern, String escape)
protected abstract Literal<R,C>	literal(Literal<R,C> placeholder)
protected Literal<R,C>	literal(Number number, Engine<R,C> engine)
protected Literal<R,C>	literal(String string, Engine<R,C> engine)
protected Condition	newComparisonCondition(RowValue rv1, Relation relation, RowValue rv2, List<Table<R,C>> tableList)
protected Condition	nullPredicate1(RowValue rv)
protected Condition	nullPredicate2(RowValue rv)
protected List<SortSpecification>	orderByClause(SortSpecification ss, List<SortSpecification> list)
protected Condition	parenthesizedBooleanValueExpression(Condition predicate)
protected abstract Statement	parse(InputStream is, Engine<R,C> engine, Deque<List<Table<R,C>>> tableListStack, LinkedHashMap<String,Placeholder> placeholderMap, SQLLocator locator)
protected abstract Statement	parse(String sql, Engine<R,C> engine, Deque<List<Table<R,C>>> tableListStack, LinkedHashMap<String,Placeholder> placeholderMap, SQLLocator locator)
protected Literal<R,C>	placeholder(String identifier, Class<? extends C> type, Map<String,Placeholder> placeholderMap)
protected Literal<R,C>	placeholder(String identifier, Literal<R,C> lit, Map<String,Placeholder> placeholderMap)
protected Literal<R,C>	placeholder(String identifier, Statement query, Map<String,Placeholder> placeholderMap)
protected Class<? extends C>	placeholderType(Engine<R,C> engine)
protected abstract Condition	predicate(Condition predicate)
protected Statement	querySpecification(List<ColumnReference> selectList, TableExpression tableExpression, LinkedHashMap<String,Placeholder> placeholderMap, Engine<R,C> engine, Deque<List<Table<R,C>>> tableListStack)
protected void	reservedWords(org.vesalainen.parser.util.InputReader reader, SQLLocator locator)
protected void	reservedWords2(org.vesalainen.parser.util.InputReader reader, SQLLocator locator)
protected Statement<R,C>	rollbackWork(LinkedHashMap<String,Placeholder<R,C>> placeholderMap, Engine<R,C> engine)
protected RowValue	rowValuePredicant1(ColumnReference columnReference)
protected RowValue	rowValuePredicant3(Literal<R,C> literal, Engine<R,C> engine)
protected Condition	searchCondition(Condition expression)
protected List<ColumnReference>	selectList(ColumnReference columnReference, List<ColumnReference> selectList)
protected List<ColumnReference>	selectList(Engine<R,C> engine)
protected void	selectStart(Deque<List<Table<R,C>>> tableListStack)
protected abstract ColumnReference	selectSublist(ColumnReference columnReference)
protected ColumnReference	selectSublist(String funcName, ColumnReference inner, List<String> args, String title, org.vesalainen.parser.util.InputReader reader, Engine<R,C> engine)
protected ColumnReference	selectSublist(String funcName, ColumnReference inner, Number number, List<Number> args, String title, org.vesalainen.parser.util.InputReader reader, Engine<R,C> engine)
protected SetClause<R,C>	setClause(String identifier, Literal<R,C> literal)
protected Statement	showSpecification(String identifier, LinkedHashMap<String,Placeholder> placeholderMap, Engine<R,C> engine)
protected SortSpecification	sortSpecification1(RowValue rv)
protected SortSpecification	sortSpecification2(RowValue rv)
protected SortSpecification	sortSpecification3(RowValue rv)
protected abstract Statement<R,C>	statement(Statement<R,C> statement)
protected List<Statement<R,C>>	statementList(List<Statement<R,C>> list, Statement<R,C> statement)
protected List<Statement<R,C>>	statementList(Statement<R,C> statement)
protected String	string(String value)
protected abstract String	stringConstant1(String str)
protected abstract String	stringConstant2(String str)
protected TableExpression	tableExpression(Condition condition, List<SortSpecification> sortSpecificationList, Deque<List<Table<R,C>>> tableListStack)
protected Table<R,C>	tableReference(String schema, String tablename, String correlationName, Engine<R,C> engine, Deque<List<Table<R,C>>> tableListStack)
protected C	timestampValue(String string, Engine<R,C> engine)
protected C	timeValue(String string, Engine<R,C> engine)
protected TruthValue	trueL(org.vesalainen.parser.util.InputReader reader, SQLLocator locator)
protected TruthValue	truthValue(TruthValue tvl)
protected TruthValue	unknown(org.vesalainen.parser.util.InputReader reader, SQLLocator locator)
protected void	updateStart(Deque<List<Table<R,C>>> tableListStack)
protected Statement<R,C>	updateStatementSearched(Table<R,C> table, SetClause<R,C> setClause, List<SetClause<R,C>> setClauseList, Condition<R,C> condition, LinkedHashMap<String,Placeholder<R,C>> placeholderMap, Engine<R,C> engine, Deque<List<Table<R,C>>> tableListStack)
protected Statement<R,C>	updateStatementSearched(Table<R,C> table, SetClause<R,C> setClause, List<SetClause<R,C>> setClauseList, LinkedHashMap<String,Placeholder<R,C>> placeholderMap, Engine<R,C> engine)
protected Condition	whereClause(Condition condition)
protected abstract void	whiteSpace()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

dateParser

protected SQLDateParser dateParser

Constructor Detail

SqlParser

public SqlParser()

Method Detail

check

protected abstract void check(String sql,
         SQLLocator locator)

Parameters:

sql -

locator -

See Also:

BNF Syntax for SQL-statement

check

protected abstract void check(org.vesalainen.parser.util.InputReader reader,
         SQLLocator locator)

Parameters:

reader -

locator -

See Also:

BNF Syntax for SQL-statement

parse

protected abstract Statement parse(String sql,
              Engine<R,C> engine,
              Deque<List<Table<R,C>>> tableListStack,
              LinkedHashMap<String,Placeholder> placeholderMap,
              SQLLocator locator)

Parameters:

sql -

engine -

placeholderMap -

locator -

Returns:

See Also:

BNF Syntax for SQL-statement

parse

protected abstract Statement parse(InputStream is,
              Engine<R,C> engine,
              Deque<List<Table<R,C>>> tableListStack,
              LinkedHashMap<String,Placeholder> placeholderMap,
              SQLLocator locator)

Parameters:

is -

engine -

placeholderMap -

locator -

Returns:

See Also:

BNF Syntax for SQL-statement

statement

protected abstract Statement<R,C> statement(Statement<R,C> statement)

batchStatement

protected Statement<R,C> batchStatement(List<Statement<R,C>> list,
                            Deque<List<Table<R,C>>> tableListStack,
                            LinkedHashMap<String,Placeholder> placeholderMap,
                            Engine<R,C> engine)

statementList

protected List<Statement<R,C>> statementList(Statement<R,C> statement)

statementList

protected List<Statement<R,C>> statementList(List<Statement<R,C>> list,
                                 Statement<R,C> statement)

beginWork

protected Statement<R,C> beginWork(LinkedHashMap<String,Placeholder<R,C>> placeholderMap,
                       Engine<R,C> engine)

commitWork

protected Statement<R,C> commitWork(LinkedHashMap<String,Placeholder<R,C>> placeholderMap,
                        Engine<R,C> engine)

rollbackWork

protected Statement<R,C> rollbackWork(LinkedHashMap<String,Placeholder<R,C>> placeholderMap,
                          Engine<R,C> engine)

updateStatementSearched

protected Statement<R,C> updateStatementSearched(Table<R,C> table,
                                     SetClause<R,C> setClause,
                                     List<SetClause<R,C>> setClauseList,
                                     LinkedHashMap<String,Placeholder<R,C>> placeholderMap,
                                     Engine<R,C> engine)

updateStatementSearched

protected Statement<R,C> updateStatementSearched(Table<R,C> table,
                                     SetClause<R,C> setClause,
                                     List<SetClause<R,C>> setClauseList,
                                     Condition<R,C> condition,
                                     LinkedHashMap<String,Placeholder<R,C>> placeholderMap,
                                     Engine<R,C> engine,
                                     Deque<List<Table<R,C>>> tableListStack)

updateStart

protected void updateStart(Deque<List<Table<R,C>>> tableListStack)

setClause

protected SetClause<R,C> setClause(String identifier,
                       Literal<R,C> literal)

deleteStatementSearched

protected Statement<R,C> deleteStatementSearched(Table<R,C> table,
                                     LinkedHashMap<String,Placeholder<R,C>> placeholderMap,
                                     Engine<R,C> engine,
                                     Deque<List<Table<R,C>>> tableListStack)

deleteStatementSearched

protected Statement<R,C> deleteStatementSearched(Table<R,C> table,
                                     Condition<R,C> condition,
                                     LinkedHashMap<String,Placeholder<R,C>> placeholderMap,
                                     Engine<R,C> engine,
                                     Deque<List<Table<R,C>>> tableListStack)

deleteStart

protected void deleteStart(Deque<List<Table<R,C>>> tableListStack)

insertStatement

protected Statement<R,C> insertStatement(Table<R,C> table,
                             InsertColumnsAndSource<R,C> insertColumnsAndSource,
                             LinkedHashMap<String,Placeholder<R,C>> placeholderMap,
                             Engine<R,C> engine,
                             Deque<List<Table<R,C>>> tableListStack)

insertStart

protected void insertStart(Deque<List<Table<R,C>>> tableListStack)

insertColumnsAndSource

protected abstract InsertColumnsAndSource<R,C> insertColumnsAndSource(InsertColumnsAndSource<R,C> insertColumnsAndSource)

fromSubQuery

protected InsertColumnsAndSource<R,C> fromSubQuery(String column,
                                       List<String> columnList,
                                       Statement subSelect)

fromConstructor

protected InsertColumnsAndSource<R,C> fromConstructor(String column,
                                          List<String> columnList,
                                          Literal<R,C> literal,
                                          List<Literal<R,C>> valueList)

column

protected abstract String column(String column)

showSpecification

protected Statement showSpecification(String identifier,
                          LinkedHashMap<String,Placeholder> placeholderMap,
                          Engine<R,C> engine)

describeSpecification

protected Statement describeSpecification(String identifier,
                              LinkedHashMap<String,Placeholder> placeholderMap,
                              Engine<R,C> engine)

querySpecification

protected Statement querySpecification(List<ColumnReference> selectList,
                           TableExpression tableExpression,
                           LinkedHashMap<String,Placeholder> placeholderMap,
                           Engine<R,C> engine,
                           Deque<List<Table<R,C>>> tableListStack)

selectStart

protected void selectStart(Deque<List<Table<R,C>>> tableListStack)

selectList

protected List<ColumnReference> selectList(Engine<R,C> engine)

selectList

protected List<ColumnReference> selectList(ColumnReference columnReference,
                               List<ColumnReference> selectList)

asterisk

protected void asterisk()

selectSublist

protected abstract ColumnReference selectSublist(ColumnReference columnReference)

columnReference

protected ColumnReference columnReference(String part,
                              List<String> list,
                              String title)

selectSublist

protected ColumnReference selectSublist(String funcName,
                            ColumnReference inner,
                            List<String> args,
                            String title,
                            org.vesalainen.parser.util.InputReader reader,
                            Engine<R,C> engine)

selectSublist

protected ColumnReference selectSublist(String funcName,
                            ColumnReference inner,
                            Number number,
                            List<Number> args,
                            String title,
                            org.vesalainen.parser.util.InputReader reader,
                            Engine<R,C> engine)

function

protected abstract String function(String func)

tableExpression

protected TableExpression tableExpression(Condition condition,
                              List<SortSpecification> sortSpecificationList,
                              Deque<List<Table<R,C>>> tableListStack)

fromClause

protected void fromClause(Table<R,C> table,
              List<Table<R,C>> list)

tableReference

protected Table<R,C> tableReference(String schema,
                        String tablename,
                        String correlationName,
                        Engine<R,C> engine,
                        Deque<List<Table<R,C>>> tableListStack)

whereClause

protected Condition whereClause(Condition condition)

searchCondition

protected Condition searchCondition(Condition expression)

booleanValueExpression

protected Condition booleanValueExpression(Condition term)

booleanValueExpression

protected Condition booleanValueExpression(Condition expression,
                               Condition term)

booleanTerm

protected Condition booleanTerm(Condition factor)

booleanTerm

protected Condition booleanTerm(Condition term,
                    Condition factor)

booleanFactor1

protected Condition booleanFactor1(Condition test)

booleanFactor2

protected Condition booleanFactor2(Condition test)

booleanTest1

protected Condition booleanTest1(Condition primary)

booleanTest2

protected Condition booleanTest2(Condition primary,
                     TruthValue tvl)

booleanTest3

protected Condition booleanTest3(Condition primary,
                     TruthValue tvl)

truthValue

protected TruthValue truthValue(TruthValue tvl)

booleanPrimary

protected Condition booleanPrimary(Condition predicate)

booleanPredicate

protected Condition booleanPredicate(Condition predicate)

parenthesizedBooleanValueExpression

protected Condition parenthesizedBooleanValueExpression(Condition predicate)

predicate

protected abstract Condition predicate(Condition predicate)

comparisonPredicate1

protected Condition comparisonPredicate1(RowValue rv1,
                             RowValue rv2,
                             Deque<List<Table<R,C>>> tableListStack)

comparisonPredicate2

protected Condition comparisonPredicate2(RowValue rv1,
                             RowValue rv2,
                             Deque<List<Table<R,C>>> tableListStack)

comparisonPredicate3

protected Condition comparisonPredicate3(RowValue rv1,
                             RowValue rv2,
                             Deque<List<Table<R,C>>> tableListStack)

comparisonPredicate4

protected Condition comparisonPredicate4(RowValue rv1,
                             RowValue rv2,
                             Deque<List<Table<R,C>>> tableListStack)

comparisonPredicate5

protected Condition comparisonPredicate5(RowValue rv1,
                             RowValue rv2,
                             Deque<List<Table<R,C>>> tableListStack)

comparisonPredicate6

protected Condition comparisonPredicate6(RowValue rv1,
                             RowValue rv2,
                             Deque<List<Table<R,C>>> tableListStack)

newComparisonCondition

protected Condition newComparisonCondition(RowValue rv1,
                               Relation relation,
                               RowValue rv2,
                               List<Table<R,C>> tableList)

rowValuePredicant1

protected RowValue rowValuePredicant1(ColumnReference columnReference)

rowValuePredicant3

protected RowValue rowValuePredicant3(Literal<R,C> literal,
                          Engine<R,C> engine)

betweenPredicate1

protected Condition betweenPredicate1(RowValue rv1,
                          RowValue rv2,
                          RowValue rv3,
                          Deque<List<Table<R,C>>> tableListStack)

betweenPredicate2

protected Condition betweenPredicate2(RowValue rv1,
                          RowValue rv2,
                          RowValue rv3,
                          Deque<List<Table<R,C>>> tableListStack)

inPredicate1

protected Condition inPredicate1(RowValue rv,
                     Collection<RowValue> inValues,
                     Deque<List<Table<R,C>>> tableListStack)

inPredicate2

protected Condition inPredicate2(RowValue rv,
                     Collection<RowValue> inValues,
                     Deque<List<Table<R,C>>> tableListStack)

inPredicateValue1

protected abstract Collection<RowValue> inPredicateValue1(Collection<RowValue> inValues)

inValueList

protected Collection<RowValue> inValueList(RowValue rv)

inValueList

protected Collection<RowValue> inValueList(Collection<RowValue> inValues,
                               RowValue rv)

likePredicate1

protected Condition likePredicate1(RowValue rv,
                       String pattern)

likePredicate2

protected Condition likePredicate2(RowValue rv,
                       String pattern,
                       String escape)

likePredicate3

protected Condition likePredicate3(RowValue rv,
                       String pattern)

likePredicate4

protected Condition likePredicate4(RowValue rv,
                       String pattern,
                       String escape)

nullPredicate1

protected Condition nullPredicate1(RowValue rv)

nullPredicate2

protected Condition nullPredicate2(RowValue rv)

literal

protected abstract Literal<R,C> literal(Literal<R,C> placeholder)

placeholder

protected Literal<R,C> placeholder(String identifier,
                       Class<? extends C> type,
                       Map<String,Placeholder> placeholderMap)

placeholder

protected Literal<R,C> placeholder(String identifier,
                       Literal<R,C> lit,
                       Map<String,Placeholder> placeholderMap)

placeholder

protected Literal<R,C> placeholder(String identifier,
                       Statement query,
                       Map<String,Placeholder> placeholderMap)

placeholderType

protected Class<? extends C> placeholderType(Engine<R,C> engine)

literal

protected Literal<R,C> literal(Number number,
                   Engine<R,C> engine)

literal

protected Literal<R,C> literal(String string,
                   Engine<R,C> engine)

dateLiteral

protected Literal<R,C> dateLiteral(C date,
                       Engine<R,C> engine)

dateValue

protected C dateValue(String string,
          Engine<R,C> engine)

timeValue

protected C timeValue(String string,
          Engine<R,C> engine)

timestampValue

protected C timestampValue(String string,
               Engine<R,C> engine)

currentYearValue

protected C currentYearValue(Engine<R,C> engine)

currentTimestampValue

protected C currentTimestampValue(Engine<R,C> engine)

orderByClause

protected List<SortSpecification> orderByClause(SortSpecification ss,
                                    List<SortSpecification> list)

sortSpecification1

protected SortSpecification sortSpecification1(RowValue rv)

sortSpecification2

protected SortSpecification sortSpecification2(RowValue rv)

sortSpecification3

protected SortSpecification sortSpecification3(RowValue rv)

reservedWords

protected void reservedWords(org.vesalainen.parser.util.InputReader reader,
                 SQLLocator locator)

reservedWords2

protected void reservedWords2(org.vesalainen.parser.util.InputReader reader,
                  SQLLocator locator)

trueL

protected TruthValue trueL(org.vesalainen.parser.util.InputReader reader,
               SQLLocator locator)

falseL

protected TruthValue falseL(org.vesalainen.parser.util.InputReader reader,
                SQLLocator locator)

unknown

protected TruthValue unknown(org.vesalainen.parser.util.InputReader reader,
                 SQLLocator locator)

stringConstant1

protected abstract String stringConstant1(String str)

stringConstant2

protected abstract String stringConstant2(String str)

identifier

protected abstract String identifier(String value)

string

protected String string(String value)

integer

protected Number integer(String value)

decimal

protected Number decimal(String value)

whiteSpace

protected abstract void whiteSpace()

doubleSlashComment

protected void doubleSlashComment(org.vesalainen.parser.util.InputReader reader,
                      SQLLocator locator)

hashComment

protected void hashComment(org.vesalainen.parser.util.InputReader reader,
               SQLLocator locator)

cComment

protected void cComment(org.vesalainen.parser.util.InputReader reader,
            SQLLocator locator)