/*
 * generated by Xtext 2.9.2
 */
package com.justeat.mickeydb.serializer;

import com.google.inject.Inject;
import com.justeat.mickeydb.mickeyLang.ActionStatement;
import com.justeat.mickeydb.mickeyLang.AlterTableAddColumnStatement;
import com.justeat.mickeydb.mickeyLang.AlterTableRenameStatement;
import com.justeat.mickeydb.mickeyLang.Case;
import com.justeat.mickeydb.mickeyLang.CaseExpression;
import com.justeat.mickeydb.mickeyLang.CastExpression;
import com.justeat.mickeydb.mickeyLang.CheckConstraint;
import com.justeat.mickeydb.mickeyLang.CheckTableConstraint;
import com.justeat.mickeydb.mickeyLang.ColumnDef;
import com.justeat.mickeydb.mickeyLang.ColumnSourceRef;
import com.justeat.mickeydb.mickeyLang.ConflictClause;
import com.justeat.mickeydb.mickeyLang.ContentNotificationUri;
import com.justeat.mickeydb.mickeyLang.ContentUri;
import com.justeat.mickeydb.mickeyLang.ContentUriParamSegment;
import com.justeat.mickeydb.mickeyLang.ContentUriQueryParam;
import com.justeat.mickeydb.mickeyLang.ContentUriSegment;
import com.justeat.mickeydb.mickeyLang.CreateIndexStatement;
import com.justeat.mickeydb.mickeyLang.CreateTableStatement;
import com.justeat.mickeydb.mickeyLang.CreateTriggerStatement;
import com.justeat.mickeydb.mickeyLang.CreateViewStatement;
import com.justeat.mickeydb.mickeyLang.CurrentDateLiteral;
import com.justeat.mickeydb.mickeyLang.CurrentTimeLiteral;
import com.justeat.mickeydb.mickeyLang.CurrentTimeStampLiteral;
import com.justeat.mickeydb.mickeyLang.DefaultConstraint;
import com.justeat.mickeydb.mickeyLang.DeleteStatement;
import com.justeat.mickeydb.mickeyLang.DropIndexStatement;
import com.justeat.mickeydb.mickeyLang.DropTableStatement;
import com.justeat.mickeydb.mickeyLang.DropTriggerStatement;
import com.justeat.mickeydb.mickeyLang.DropViewStatement;
import com.justeat.mickeydb.mickeyLang.ExprAdd;
import com.justeat.mickeydb.mickeyLang.ExprAnd;
import com.justeat.mickeydb.mickeyLang.ExprBit;
import com.justeat.mickeydb.mickeyLang.ExprConcat;
import com.justeat.mickeydb.mickeyLang.ExprEqual;
import com.justeat.mickeydb.mickeyLang.ExprMult;
import com.justeat.mickeydb.mickeyLang.ExprOr;
import com.justeat.mickeydb.mickeyLang.ExprRelate;
import com.justeat.mickeydb.mickeyLang.ExpressionDefaultValue;
import com.justeat.mickeydb.mickeyLang.Function;
import com.justeat.mickeydb.mickeyLang.FunctionArg;
import com.justeat.mickeydb.mickeyLang.FunctionArgument;
import com.justeat.mickeydb.mickeyLang.GroupByExpressions;
import com.justeat.mickeydb.mickeyLang.HavingExpressions;
import com.justeat.mickeydb.mickeyLang.IndexedColumn;
import com.justeat.mickeydb.mickeyLang.InsertStatement;
import com.justeat.mickeydb.mickeyLang.IsNull;
import com.justeat.mickeydb.mickeyLang.JoinSource;
import com.justeat.mickeydb.mickeyLang.JoinStatement;
import com.justeat.mickeydb.mickeyLang.Literal;
import com.justeat.mickeydb.mickeyLang.LiteralDefaultValue;
import com.justeat.mickeydb.mickeyLang.MickeyFile;
import com.justeat.mickeydb.mickeyLang.MickeyFunction;
import com.justeat.mickeydb.mickeyLang.MickeyLangPackage;
import com.justeat.mickeydb.mickeyLang.MigrationBlock;
import com.justeat.mickeydb.mickeyLang.NestedExpression;
import com.justeat.mickeydb.mickeyLang.NewColumn;
import com.justeat.mickeydb.mickeyLang.NotNull;
import com.justeat.mickeydb.mickeyLang.NotNullConstraint;
import com.justeat.mickeydb.mickeyLang.NotifyContentUri;
import com.justeat.mickeydb.mickeyLang.NotifyContentUriParamSegment;
import com.justeat.mickeydb.mickeyLang.NotifyContentUriSegment;
import com.justeat.mickeydb.mickeyLang.NullCheckExpression;
import com.justeat.mickeydb.mickeyLang.NullLiteral;
import com.justeat.mickeydb.mickeyLang.NumericLiteral;
import com.justeat.mickeydb.mickeyLang.OldColumn;
import com.justeat.mickeydb.mickeyLang.OrderingTerm;
import com.justeat.mickeydb.mickeyLang.OrderingTermList;
import com.justeat.mickeydb.mickeyLang.PrimaryConstraint;
import com.justeat.mickeydb.mickeyLang.PrimaryKeyColumnConstraint;
import com.justeat.mickeydb.mickeyLang.ResultColumn;
import com.justeat.mickeydb.mickeyLang.SelectCore;
import com.justeat.mickeydb.mickeyLang.SelectExpression;
import com.justeat.mickeydb.mickeyLang.SelectList;
import com.justeat.mickeydb.mickeyLang.SelectStatement;
import com.justeat.mickeydb.mickeyLang.SelectStatementExpression;
import com.justeat.mickeydb.mickeyLang.SingleSourceJoin;
import com.justeat.mickeydb.mickeyLang.SingleSourceSelectStatement;
import com.justeat.mickeydb.mickeyLang.SingleSourceTable;
import com.justeat.mickeydb.mickeyLang.StringLiteral;
import com.justeat.mickeydb.mickeyLang.UniqueConstraint;
import com.justeat.mickeydb.mickeyLang.UniqueTableConstraint;
import com.justeat.mickeydb.mickeyLang.UpdateColumnExpression;
import com.justeat.mickeydb.mickeyLang.UpdateStatement;
import com.justeat.mickeydb.mickeyLang.WhereExpressions;
import com.justeat.mickeydb.services.MickeyLangGrammarAccess;
import java.util.Set;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.xtext.Action;
import org.eclipse.xtext.Parameter;
import org.eclipse.xtext.ParserRule;
import org.eclipse.xtext.serializer.ISerializationContext;
import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;

@SuppressWarnings("all")
public abstract class AbstractMickeyLangSemanticSequencer extends AbstractDelegatingSemanticSequencer {

	@Inject
	private MickeyLangGrammarAccess grammarAccess;
	
	@Override
	public void sequence(ISerializationContext context, EObject semanticObject) {
		EPackage epackage = semanticObject.eClass().getEPackage();
		ParserRule rule = context.getParserRule();
		Action action = context.getAssignedAction();
		Set<Parameter> parameters = context.getEnabledBooleanParameters();
		if (epackage == MickeyLangPackage.eINSTANCE)
			switch (semanticObject.eClass().getClassifierID()) {
			case MickeyLangPackage.ACTION_STATEMENT:
				sequence_ActionStatement(context, (ActionStatement) semanticObject); 
				return; 
			case MickeyLangPackage.ALTER_TABLE_ADD_COLUMN_STATEMENT:
				sequence_AlterTableAddColumnStatement(context, (AlterTableAddColumnStatement) semanticObject); 
				return; 
			case MickeyLangPackage.ALTER_TABLE_RENAME_STATEMENT:
				sequence_AlterTableRenameStatement(context, (AlterTableRenameStatement) semanticObject); 
				return; 
			case MickeyLangPackage.CASE:
				sequence_Case(context, (Case) semanticObject); 
				return; 
			case MickeyLangPackage.CASE_EXPRESSION:
				sequence_PrimaryExpression(context, (CaseExpression) semanticObject); 
				return; 
			case MickeyLangPackage.CAST_EXPRESSION:
				sequence_PrimaryExpression(context, (CastExpression) semanticObject); 
				return; 
			case MickeyLangPackage.CHECK_CONSTRAINT:
				sequence_ColumnConstraint(context, (CheckConstraint) semanticObject); 
				return; 
			case MickeyLangPackage.CHECK_TABLE_CONSTRAINT:
				sequence_CheckTableConstraint(context, (CheckTableConstraint) semanticObject); 
				return; 
			case MickeyLangPackage.COLUMN_DEF:
				sequence_ColumnDef(context, (ColumnDef) semanticObject); 
				return; 
			case MickeyLangPackage.COLUMN_SOURCE_REF:
				sequence_PrimaryExpression(context, (ColumnSourceRef) semanticObject); 
				return; 
			case MickeyLangPackage.CONFLICT_CLAUSE:
				sequence_ConflictClause(context, (ConflictClause) semanticObject); 
				return; 
			case MickeyLangPackage.CONTENT_NOTIFICATION_URI:
				sequence_ContentNotificationUri(context, (ContentNotificationUri) semanticObject); 
				return; 
			case MickeyLangPackage.CONTENT_URI:
				sequence_ContentUri(context, (ContentUri) semanticObject); 
				return; 
			case MickeyLangPackage.CONTENT_URI_PARAM_SEGMENT:
				sequence_ContentUriSegment(context, (ContentUriParamSegment) semanticObject); 
				return; 
			case MickeyLangPackage.CONTENT_URI_QUERY_PARAM:
				sequence_ContentUriQueryParam(context, (ContentUriQueryParam) semanticObject); 
				return; 
			case MickeyLangPackage.CONTENT_URI_SEGMENT:
				sequence_ContentUriSegment(context, (ContentUriSegment) semanticObject); 
				return; 
			case MickeyLangPackage.CREATE_INDEX_STATEMENT:
				sequence_CreateIndexStatement(context, (CreateIndexStatement) semanticObject); 
				return; 
			case MickeyLangPackage.CREATE_TABLE_STATEMENT:
				sequence_CreateTableStatement(context, (CreateTableStatement) semanticObject); 
				return; 
			case MickeyLangPackage.CREATE_TRIGGER_STATEMENT:
				sequence_CreateTriggerStatement(context, (CreateTriggerStatement) semanticObject); 
				return; 
			case MickeyLangPackage.CREATE_VIEW_STATEMENT:
				sequence_CreateViewStatement(context, (CreateViewStatement) semanticObject); 
				return; 
			case MickeyLangPackage.CURRENT_DATE_LITERAL:
				sequence_LiteralValue(context, (CurrentDateLiteral) semanticObject); 
				return; 
			case MickeyLangPackage.CURRENT_TIME_LITERAL:
				sequence_LiteralValue(context, (CurrentTimeLiteral) semanticObject); 
				return; 
			case MickeyLangPackage.CURRENT_TIME_STAMP_LITERAL:
				sequence_LiteralValue(context, (CurrentTimeStampLiteral) semanticObject); 
				return; 
			case MickeyLangPackage.DEFAULT_CONSTRAINT:
				sequence_ColumnConstraint(context, (DefaultConstraint) semanticObject); 
				return; 
			case MickeyLangPackage.DELETE_STATEMENT:
				sequence_DeleteStatement(context, (DeleteStatement) semanticObject); 
				return; 
			case MickeyLangPackage.DROP_INDEX_STATEMENT:
				sequence_DropIndexStatement(context, (DropIndexStatement) semanticObject); 
				return; 
			case MickeyLangPackage.DROP_TABLE_STATEMENT:
				sequence_DropTableStatement(context, (DropTableStatement) semanticObject); 
				return; 
			case MickeyLangPackage.DROP_TRIGGER_STATEMENT:
				sequence_DropTriggerStatement(context, (DropTriggerStatement) semanticObject); 
				return; 
			case MickeyLangPackage.DROP_VIEW_STATEMENT:
				sequence_DropViewStatement(context, (DropViewStatement) semanticObject); 
				return; 
			case MickeyLangPackage.EXPR_ADD:
				sequence_ExprAdd(context, (ExprAdd) semanticObject); 
				return; 
			case MickeyLangPackage.EXPR_AND:
				sequence_ExprAnd(context, (ExprAnd) semanticObject); 
				return; 
			case MickeyLangPackage.EXPR_BIT:
				sequence_ExprBit(context, (ExprBit) semanticObject); 
				return; 
			case MickeyLangPackage.EXPR_CONCAT:
				sequence_ExprConcat(context, (ExprConcat) semanticObject); 
				return; 
			case MickeyLangPackage.EXPR_EQUAL:
				sequence_ExprEqual(context, (ExprEqual) semanticObject); 
				return; 
			case MickeyLangPackage.EXPR_MULT:
				sequence_ExprMult(context, (ExprMult) semanticObject); 
				return; 
			case MickeyLangPackage.EXPR_OR:
				sequence_ExprOr(context, (ExprOr) semanticObject); 
				return; 
			case MickeyLangPackage.EXPR_RELATE:
				sequence_ExprRelate(context, (ExprRelate) semanticObject); 
				return; 
			case MickeyLangPackage.EXPRESSION_DEFAULT_VALUE:
				sequence_DefaultValue(context, (ExpressionDefaultValue) semanticObject); 
				return; 
			case MickeyLangPackage.FUNCTION:
				sequence_PrimaryExpression(context, (Function) semanticObject); 
				return; 
			case MickeyLangPackage.FUNCTION_ARG:
				sequence_FunctionArg(context, (FunctionArg) semanticObject); 
				return; 
			case MickeyLangPackage.FUNCTION_ARGUMENT:
				sequence_PrimaryExpression(context, (FunctionArgument) semanticObject); 
				return; 
			case MickeyLangPackage.GROUP_BY_EXPRESSIONS:
				sequence_GroupByExpressions(context, (GroupByExpressions) semanticObject); 
				return; 
			case MickeyLangPackage.HAVING_EXPRESSIONS:
				sequence_HavingExpressions(context, (HavingExpressions) semanticObject); 
				return; 
			case MickeyLangPackage.INDEXED_COLUMN:
				sequence_IndexedColumn(context, (IndexedColumn) semanticObject); 
				return; 
			case MickeyLangPackage.INSERT_STATEMENT:
				sequence_InsertStatement(context, (InsertStatement) semanticObject); 
				return; 
			case MickeyLangPackage.IS_NULL:
				sequence_NullExpression(context, (IsNull) semanticObject); 
				return; 
			case MickeyLangPackage.JOIN_SOURCE:
				sequence_JoinSource(context, (JoinSource) semanticObject); 
				return; 
			case MickeyLangPackage.JOIN_STATEMENT:
				sequence_JoinStatement(context, (JoinStatement) semanticObject); 
				return; 
			case MickeyLangPackage.LITERAL:
				sequence_PrimaryExpression(context, (Literal) semanticObject); 
				return; 
			case MickeyLangPackage.LITERAL_DEFAULT_VALUE:
				sequence_DefaultValue(context, (LiteralDefaultValue) semanticObject); 
				return; 
			case MickeyLangPackage.MICKEY_FILE:
				sequence_MickeyFile(context, (MickeyFile) semanticObject); 
				return; 
			case MickeyLangPackage.MICKEY_FUNCTION:
				sequence_MickeyFunction(context, (MickeyFunction) semanticObject); 
				return; 
			case MickeyLangPackage.MIGRATION_BLOCK:
				sequence_MigrationBlock(context, (MigrationBlock) semanticObject); 
				return; 
			case MickeyLangPackage.NESTED_EXPRESSION:
				sequence_PrimaryExpression(context, (NestedExpression) semanticObject); 
				return; 
			case MickeyLangPackage.NEW_COLUMN:
				sequence_PrimaryExpression(context, (NewColumn) semanticObject); 
				return; 
			case MickeyLangPackage.NOT_NULL:
				sequence_NullExpression(context, (NotNull) semanticObject); 
				return; 
			case MickeyLangPackage.NOT_NULL_CONSTRAINT:
				sequence_ColumnConstraint(context, (NotNullConstraint) semanticObject); 
				return; 
			case MickeyLangPackage.NOTIFY_CONTENT_URI:
				sequence_NotifyContentUri(context, (NotifyContentUri) semanticObject); 
				return; 
			case MickeyLangPackage.NOTIFY_CONTENT_URI_PARAM_SEGMENT:
				sequence_NotifyContentUriSegment(context, (NotifyContentUriParamSegment) semanticObject); 
				return; 
			case MickeyLangPackage.NOTIFY_CONTENT_URI_SEGMENT:
				sequence_NotifyContentUriSegment(context, (NotifyContentUriSegment) semanticObject); 
				return; 
			case MickeyLangPackage.NULL_CHECK_EXPRESSION:
				sequence_NullCheckExpression(context, (NullCheckExpression) semanticObject); 
				return; 
			case MickeyLangPackage.NULL_LITERAL:
				sequence_LiteralValue(context, (NullLiteral) semanticObject); 
				return; 
			case MickeyLangPackage.NUMERIC_LITERAL:
				sequence_LiteralValue(context, (NumericLiteral) semanticObject); 
				return; 
			case MickeyLangPackage.OLD_COLUMN:
				sequence_PrimaryExpression(context, (OldColumn) semanticObject); 
				return; 
			case MickeyLangPackage.ORDERING_TERM:
				sequence_OrderingTerm(context, (OrderingTerm) semanticObject); 
				return; 
			case MickeyLangPackage.ORDERING_TERM_LIST:
				sequence_OrderingTermList(context, (OrderingTermList) semanticObject); 
				return; 
			case MickeyLangPackage.PRIMARY_CONSTRAINT:
				sequence_PrimaryConstraint(context, (PrimaryConstraint) semanticObject); 
				return; 
			case MickeyLangPackage.PRIMARY_KEY_COLUMN_CONSTRAINT:
				sequence_ColumnConstraint(context, (PrimaryKeyColumnConstraint) semanticObject); 
				return; 
			case MickeyLangPackage.RESULT_COLUMN:
				sequence_ResultColumn(context, (ResultColumn) semanticObject); 
				return; 
			case MickeyLangPackage.SELECT_CORE:
				sequence_SelectCore(context, (SelectCore) semanticObject); 
				return; 
			case MickeyLangPackage.SELECT_EXPRESSION:
				sequence_SelectExpression(context, (SelectExpression) semanticObject); 
				return; 
			case MickeyLangPackage.SELECT_LIST:
				sequence_SelectList(context, (SelectList) semanticObject); 
				return; 
			case MickeyLangPackage.SELECT_STATEMENT:
				sequence_SelectStatement(context, (SelectStatement) semanticObject); 
				return; 
			case MickeyLangPackage.SELECT_STATEMENT_EXPRESSION:
				sequence_PrimaryExpression(context, (SelectStatementExpression) semanticObject); 
				return; 
			case MickeyLangPackage.SINGLE_SOURCE_JOIN:
				sequence_SingleSourceJoin(context, (SingleSourceJoin) semanticObject); 
				return; 
			case MickeyLangPackage.SINGLE_SOURCE_SELECT_STATEMENT:
				sequence_SingleSourceSelectStatement(context, (SingleSourceSelectStatement) semanticObject); 
				return; 
			case MickeyLangPackage.SINGLE_SOURCE_TABLE:
				sequence_SingleSourceTable(context, (SingleSourceTable) semanticObject); 
				return; 
			case MickeyLangPackage.STRING_LITERAL:
				sequence_LiteralValue(context, (StringLiteral) semanticObject); 
				return; 
			case MickeyLangPackage.UNIQUE_CONSTRAINT:
				sequence_ColumnConstraint(context, (UniqueConstraint) semanticObject); 
				return; 
			case MickeyLangPackage.UNIQUE_TABLE_CONSTRAINT:
				sequence_UniqueTableConstraint(context, (UniqueTableConstraint) semanticObject); 
				return; 
			case MickeyLangPackage.UPDATE_COLUMN_EXPRESSION:
				sequence_UpdateColumnExpression(context, (UpdateColumnExpression) semanticObject); 
				return; 
			case MickeyLangPackage.UPDATE_STATEMENT:
				sequence_UpdateStatement(context, (UpdateStatement) semanticObject); 
				return; 
			case MickeyLangPackage.WHERE_EXPRESSIONS:
				sequence_WhereExpressions(context, (WhereExpressions) semanticObject); 
				return; 
			}
		if (errorAcceptor != null)
			errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
	}
	
	/**
	 * Contexts:
	 *     MickeyBlock returns ActionStatement
	 *     ActionStatement returns ActionStatement
	 *
	 * Constraint:
	 *     (
	 *         name=ID 
	 *         uri=ContentUri 
	 *         type=[TableDefinition|QualifiedName] 
	 *         unique?='unique'? 
	 *         params+=ContentUriQueryParam* 
	 *         notifications+=ContentNotificationUri*
	 *     )
	 */
	protected void sequence_ActionStatement(ISerializationContext context, ActionStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     MickeyBlock returns AlterTableAddColumnStatement
	 *     DDLStatement returns AlterTableAddColumnStatement
	 *     AlterTableAddColumnStatement returns AlterTableAddColumnStatement
	 *
	 * Constraint:
	 *     (table=[TableDefinition|ID] columnDef=ColumnDef)
	 */
	protected void sequence_AlterTableAddColumnStatement(ISerializationContext context, AlterTableAddColumnStatement semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.ALTER_TABLE_ADD_COLUMN_STATEMENT__TABLE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.ALTER_TABLE_ADD_COLUMN_STATEMENT__TABLE));
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.ALTER_TABLE_ADD_COLUMN_STATEMENT__COLUMN_DEF) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.ALTER_TABLE_ADD_COLUMN_STATEMENT__COLUMN_DEF));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getAlterTableAddColumnStatementAccess().getTableTableDefinitionIDTerminalRuleCall_2_0_1(), semanticObject.getTable());
		feeder.accept(grammarAccess.getAlterTableAddColumnStatementAccess().getColumnDefColumnDefParserRuleCall_4_0(), semanticObject.getColumnDef());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     MickeyBlock returns AlterTableRenameStatement
	 *     DDLStatement returns AlterTableRenameStatement
	 *     AlterTableRenameStatement returns AlterTableRenameStatement
	 *
	 * Constraint:
	 *     (table=[TableDefinition|ID] name=ID)
	 */
	protected void sequence_AlterTableRenameStatement(ISerializationContext context, AlterTableRenameStatement semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.ALTER_TABLE_RENAME_STATEMENT__TABLE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.ALTER_TABLE_RENAME_STATEMENT__TABLE));
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.TABLE_DEFINITION__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.TABLE_DEFINITION__NAME));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getAlterTableRenameStatementAccess().getTableTableDefinitionIDTerminalRuleCall_3_0_1(), semanticObject.getTable());
		feeder.accept(grammarAccess.getAlterTableRenameStatementAccess().getNameIDTerminalRuleCall_5_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Case returns Case
	 *
	 * Constraint:
	 *     (whenExpression=SqlExpression thenExpression=SqlExpression)
	 */
	protected void sequence_Case(ISerializationContext context, Case semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.CASE__WHEN_EXPRESSION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.CASE__WHEN_EXPRESSION));
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.CASE__THEN_EXPRESSION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.CASE__THEN_EXPRESSION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getCaseAccess().getWhenExpressionSqlExpressionParserRuleCall_1_0(), semanticObject.getWhenExpression());
		feeder.accept(grammarAccess.getCaseAccess().getThenExpressionSqlExpressionParserRuleCall_3_0(), semanticObject.getThenExpression());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     TableConstraint returns CheckTableConstraint
	 *     CheckTableConstraint returns CheckTableConstraint
	 *
	 * Constraint:
	 *     (name=ID? expression=SqlExpression)
	 */
	protected void sequence_CheckTableConstraint(ISerializationContext context, CheckTableConstraint semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     ColumnConstraint returns CheckConstraint
	 *
	 * Constraint:
	 *     expression=SqlExpression
	 */
	protected void sequence_ColumnConstraint(ISerializationContext context, CheckConstraint semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.CHECK_CONSTRAINT__EXPRESSION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.CHECK_CONSTRAINT__EXPRESSION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getColumnConstraintAccess().getExpressionSqlExpressionParserRuleCall_4_3_0(), semanticObject.getExpression());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ColumnConstraint returns DefaultConstraint
	 *
	 * Constraint:
	 *     defaultValue=DefaultValue
	 */
	protected void sequence_ColumnConstraint(ISerializationContext context, DefaultConstraint semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.DEFAULT_CONSTRAINT__DEFAULT_VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.DEFAULT_CONSTRAINT__DEFAULT_VALUE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getColumnConstraintAccess().getDefaultValueDefaultValueParserRuleCall_3_2_0(), semanticObject.getDefaultValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ColumnConstraint returns NotNullConstraint
	 *
	 * Constraint:
	 *     conflictClause=ConflictClause?
	 */
	protected void sequence_ColumnConstraint(ISerializationContext context, NotNullConstraint semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     ColumnConstraint returns PrimaryKeyColumnConstraint
	 *
	 * Constraint:
	 *     ((asc?='asc' | desc?='desc')? autoincrement?='autoincrement'?)
	 */
	protected void sequence_ColumnConstraint(ISerializationContext context, PrimaryKeyColumnConstraint semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     ColumnConstraint returns UniqueConstraint
	 *
	 * Constraint:
	 *     conflictClause=ConflictClause?
	 */
	protected void sequence_ColumnConstraint(ISerializationContext context, UniqueConstraint semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     ColumnDef returns ColumnDef
	 *
	 * Constraint:
	 *     (name=ID type=ColumnType constraints+=ColumnConstraint*)
	 */
	protected void sequence_ColumnDef(ISerializationContext context, ColumnDef semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     ConflictClause returns ConflictClause
	 *
	 * Constraint:
	 *     resolution=ConflictResolution
	 */
	protected void sequence_ConflictClause(ISerializationContext context, ConflictClause semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.CONFLICT_CLAUSE__RESOLUTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.CONFLICT_CLAUSE__RESOLUTION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getConflictClauseAccess().getResolutionConflictResolutionEnumRuleCall_2_0(), semanticObject.getResolution());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ContentNotificationUri returns ContentNotificationUri
	 *
	 * Constraint:
	 *     uri=NotifyContentUri
	 */
	protected void sequence_ContentNotificationUri(ISerializationContext context, ContentNotificationUri semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.CONTENT_NOTIFICATION_URI__URI) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.CONTENT_NOTIFICATION_URI__URI));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getContentNotificationUriAccess().getUriNotifyContentUriParserRuleCall_1_0(), semanticObject.getUri());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ContentUriQueryParam returns ContentUriQueryParam
	 *
	 * Constraint:
	 *     (like?='like'? column=[ColumnSource|ID])
	 */
	protected void sequence_ContentUriQueryParam(ISerializationContext context, ContentUriQueryParam semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     ContentUriSegment returns ContentUriParamSegment
	 *
	 * Constraint:
	 *     param=[ColumnSource|ID]
	 */
	protected void sequence_ContentUriSegment(ISerializationContext context, ContentUriParamSegment semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.CONTENT_URI_PARAM_SEGMENT__PARAM) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.CONTENT_URI_PARAM_SEGMENT__PARAM));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getContentUriSegmentAccess().getParamColumnSourceIDTerminalRuleCall_1_2_0_1(), semanticObject.getParam());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ContentUriSegment returns ContentUriSegment
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_ContentUriSegment(ISerializationContext context, ContentUriSegment semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.CONTENT_URI_SEGMENT__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.CONTENT_URI_SEGMENT__NAME));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getContentUriSegmentAccess().getNameIDTerminalRuleCall_0_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ContentUri returns ContentUri
	 *
	 * Constraint:
	 *     (segments+=ContentUriSegment? segments+=ContentUriSegment*)
	 */
	protected void sequence_ContentUri(ISerializationContext context, ContentUri semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     MickeyBlock returns CreateIndexStatement
	 *     DDLStatement returns CreateIndexStatement
	 *     CreateIndexStatement returns CreateIndexStatement
	 *
	 * Constraint:
	 *     (unique?='unique'? name=ID table=[TableDefinition|ID] columns+=IndexedColumn columns+=IndexedColumn*)
	 */
	protected void sequence_CreateIndexStatement(ISerializationContext context, CreateIndexStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     MickeyBlock returns CreateTableStatement
	 *     DDLStatement returns CreateTableStatement
	 *     CreateTableStatement returns CreateTableStatement
	 *
	 * Constraint:
	 *     (temporary?='temp'? name=ID columnDefs+=ColumnDef columnDefs+=ColumnDef* constraints+=TableConstraint*)
	 */
	protected void sequence_CreateTableStatement(ISerializationContext context, CreateTableStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     MickeyBlock returns CreateTriggerStatement
	 *     DDLStatement returns CreateTriggerStatement
	 *     CreateTriggerStatement returns CreateTriggerStatement
	 *
	 * Constraint:
	 *     (
	 *         temporary?='temp'? 
	 *         name=ID 
	 *         (when='before' | when='after' | when='instead of')? 
	 *         (eventType='delete' | eventType='insert' | (eventType='update' (updateColumnNames+=ID updateColumnNames+=ID*)?)) 
	 *         table=[TableDefinition|ID] 
	 *         forEachRow='for each row'? 
	 *         whenExpression=SqlExpression? 
	 *         (statements+=DMLStatement statements+=DMLStatement*)?
	 *     )
	 */
	protected void sequence_CreateTriggerStatement(ISerializationContext context, CreateTriggerStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     MickeyBlock returns CreateViewStatement
	 *     DDLStatement returns CreateViewStatement
	 *     CreateViewStatement returns CreateViewStatement
	 *
	 * Constraint:
	 *     (temporary?='temp'? name=ID selectStatement=SelectStatement)
	 */
	protected void sequence_CreateViewStatement(ISerializationContext context, CreateViewStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DefaultValue returns ExpressionDefaultValue
	 *
	 * Constraint:
	 *     expression=SqlExpression
	 */
	protected void sequence_DefaultValue(ISerializationContext context, ExpressionDefaultValue semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.EXPRESSION_DEFAULT_VALUE__EXPRESSION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.EXPRESSION_DEFAULT_VALUE__EXPRESSION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDefaultValueAccess().getExpressionSqlExpressionParserRuleCall_1_2_0(), semanticObject.getExpression());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DefaultValue returns LiteralDefaultValue
	 *
	 * Constraint:
	 *     literal=LiteralValue
	 */
	protected void sequence_DefaultValue(ISerializationContext context, LiteralDefaultValue semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.LITERAL_DEFAULT_VALUE__LITERAL) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.LITERAL_DEFAULT_VALUE__LITERAL));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDefaultValueAccess().getLiteralLiteralValueParserRuleCall_0_1_0(), semanticObject.getLiteral());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DMLStatement returns DeleteStatement
	 *     DeleteStatement returns DeleteStatement
	 *
	 * Constraint:
	 *     (table=[TableDefinition|ID] expression=SqlExpression?)
	 */
	protected void sequence_DeleteStatement(ISerializationContext context, DeleteStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     MickeyBlock returns DropIndexStatement
	 *     DDLStatement returns DropIndexStatement
	 *     DropIndexStatement returns DropIndexStatement
	 *
	 * Constraint:
	 *     (ifExists?='if exists'? index=[CreateIndexStatement|ID])
	 */
	protected void sequence_DropIndexStatement(ISerializationContext context, DropIndexStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     MickeyBlock returns DropTableStatement
	 *     DDLStatement returns DropTableStatement
	 *     DropTableStatement returns DropTableStatement
	 *
	 * Constraint:
	 *     (ifExists?='if exists'? table=[TableDefinition|ID])
	 */
	protected void sequence_DropTableStatement(ISerializationContext context, DropTableStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     MickeyBlock returns DropTriggerStatement
	 *     DDLStatement returns DropTriggerStatement
	 *     DropTriggerStatement returns DropTriggerStatement
	 *
	 * Constraint:
	 *     (ifExists?='if exists'? trigger=[CreateTriggerStatement|ID])
	 */
	protected void sequence_DropTriggerStatement(ISerializationContext context, DropTriggerStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     MickeyBlock returns DropViewStatement
	 *     DDLStatement returns DropViewStatement
	 *     DropViewStatement returns DropViewStatement
	 *
	 * Constraint:
	 *     (ifExists?='if exists'? view=[CreateViewStatement|ID])
	 */
	protected void sequence_DropViewStatement(ISerializationContext context, DropViewStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns ExprAdd
	 *     ExprConcat returns ExprAdd
	 *     ExprConcat.ExprConcat_1_0 returns ExprAdd
	 *     ExprMult returns ExprAdd
	 *     ExprMult.ExprMult_1_0 returns ExprAdd
	 *     ExprAdd returns ExprAdd
	 *     ExprAdd.ExprAdd_1_0 returns ExprAdd
	 *
	 * Constraint:
	 *     (left=ExprAdd_ExprAdd_1_0 (op='+' | op='-') right=ExprBit)
	 */
	protected void sequence_ExprAdd(ISerializationContext context, ExprAdd semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns ExprAnd
	 *     ExprConcat returns ExprAnd
	 *     ExprConcat.ExprConcat_1_0 returns ExprAnd
	 *     ExprMult returns ExprAnd
	 *     ExprMult.ExprMult_1_0 returns ExprAnd
	 *     ExprAdd returns ExprAnd
	 *     ExprAdd.ExprAdd_1_0 returns ExprAnd
	 *     ExprBit returns ExprAnd
	 *     ExprBit.ExprBit_1_0 returns ExprAnd
	 *     ExprRelate returns ExprAnd
	 *     ExprRelate.ExprRelate_1_0 returns ExprAnd
	 *     ExprEqual returns ExprAnd
	 *     ExprEqual.ExprEqual_1_0 returns ExprAnd
	 *     ExprAnd returns ExprAnd
	 *     ExprAnd.ExprAnd_1_0 returns ExprAnd
	 *
	 * Constraint:
	 *     (left=ExprAnd_ExprAnd_1_0 op='and' right=ExprOr)
	 */
	protected void sequence_ExprAnd(ISerializationContext context, ExprAnd semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.EXPR_AND__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.EXPR_AND__LEFT));
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.EXPR_AND__OP) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.EXPR_AND__OP));
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.EXPR_AND__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.EXPR_AND__RIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getExprAndAccess().getExprAndLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getExprAndAccess().getOpAndKeyword_1_1_0(), semanticObject.getOp());
		feeder.accept(grammarAccess.getExprAndAccess().getRightExprOrParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns ExprBit
	 *     ExprConcat returns ExprBit
	 *     ExprConcat.ExprConcat_1_0 returns ExprBit
	 *     ExprMult returns ExprBit
	 *     ExprMult.ExprMult_1_0 returns ExprBit
	 *     ExprAdd returns ExprBit
	 *     ExprAdd.ExprAdd_1_0 returns ExprBit
	 *     ExprBit returns ExprBit
	 *     ExprBit.ExprBit_1_0 returns ExprBit
	 *
	 * Constraint:
	 *     (left=ExprBit_ExprBit_1_0 (op='<<' | op='>>' | op='&' | op='|') right=ExprRelate)
	 */
	protected void sequence_ExprBit(ISerializationContext context, ExprBit semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns ExprConcat
	 *     ExprConcat returns ExprConcat
	 *     ExprConcat.ExprConcat_1_0 returns ExprConcat
	 *
	 * Constraint:
	 *     (left=ExprConcat_ExprConcat_1_0 op='||' right=ExprMult)
	 */
	protected void sequence_ExprConcat(ISerializationContext context, ExprConcat semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.EXPR_CONCAT__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.EXPR_CONCAT__LEFT));
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.EXPR_CONCAT__OP) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.EXPR_CONCAT__OP));
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.EXPR_CONCAT__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.EXPR_CONCAT__RIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getExprConcatAccess().getExprConcatLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getExprConcatAccess().getOpVerticalLineVerticalLineKeyword_1_1_0(), semanticObject.getOp());
		feeder.accept(grammarAccess.getExprConcatAccess().getRightExprMultParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns ExprEqual
	 *     ExprConcat returns ExprEqual
	 *     ExprConcat.ExprConcat_1_0 returns ExprEqual
	 *     ExprMult returns ExprEqual
	 *     ExprMult.ExprMult_1_0 returns ExprEqual
	 *     ExprAdd returns ExprEqual
	 *     ExprAdd.ExprAdd_1_0 returns ExprEqual
	 *     ExprBit returns ExprEqual
	 *     ExprBit.ExprBit_1_0 returns ExprEqual
	 *     ExprRelate returns ExprEqual
	 *     ExprRelate.ExprRelate_1_0 returns ExprEqual
	 *     ExprEqual returns ExprEqual
	 *     ExprEqual.ExprEqual_1_0 returns ExprEqual
	 *
	 * Constraint:
	 *     (
	 *         left=ExprEqual_ExprEqual_1_0 
	 *         (
	 *             op='=' | 
	 *             op='==' | 
	 *             op='!=' | 
	 *             op='<>' | 
	 *             op='is' | 
	 *             op='is not' | 
	 *             op='in' | 
	 *             op='not in' | 
	 *             op='like' | 
	 *             op='glob' | 
	 *             op='match' | 
	 *             op='regexp'
	 *         ) 
	 *         right=ExprAnd
	 *     )
	 */
	protected void sequence_ExprEqual(ISerializationContext context, ExprEqual semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns ExprMult
	 *     ExprConcat returns ExprMult
	 *     ExprConcat.ExprConcat_1_0 returns ExprMult
	 *     ExprMult returns ExprMult
	 *     ExprMult.ExprMult_1_0 returns ExprMult
	 *
	 * Constraint:
	 *     (left=ExprMult_ExprMult_1_0 (op='*' | op='/' | op='%') right=ExprAdd)
	 */
	protected void sequence_ExprMult(ISerializationContext context, ExprMult semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns ExprOr
	 *     ExprConcat returns ExprOr
	 *     ExprConcat.ExprConcat_1_0 returns ExprOr
	 *     ExprMult returns ExprOr
	 *     ExprMult.ExprMult_1_0 returns ExprOr
	 *     ExprAdd returns ExprOr
	 *     ExprAdd.ExprAdd_1_0 returns ExprOr
	 *     ExprBit returns ExprOr
	 *     ExprBit.ExprBit_1_0 returns ExprOr
	 *     ExprRelate returns ExprOr
	 *     ExprRelate.ExprRelate_1_0 returns ExprOr
	 *     ExprEqual returns ExprOr
	 *     ExprEqual.ExprEqual_1_0 returns ExprOr
	 *     ExprAnd returns ExprOr
	 *     ExprAnd.ExprAnd_1_0 returns ExprOr
	 *     ExprOr returns ExprOr
	 *     ExprOr.ExprOr_1_0 returns ExprOr
	 *
	 * Constraint:
	 *     (left=ExprOr_ExprOr_1_0 op='or' right=NullCheckExpression)
	 */
	protected void sequence_ExprOr(ISerializationContext context, ExprOr semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.EXPR_OR__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.EXPR_OR__LEFT));
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.EXPR_OR__OP) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.EXPR_OR__OP));
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.EXPR_OR__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.EXPR_OR__RIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getExprOrAccess().getExprOrLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getExprOrAccess().getOpOrKeyword_1_1_0(), semanticObject.getOp());
		feeder.accept(grammarAccess.getExprOrAccess().getRightNullCheckExpressionParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns ExprRelate
	 *     ExprConcat returns ExprRelate
	 *     ExprConcat.ExprConcat_1_0 returns ExprRelate
	 *     ExprMult returns ExprRelate
	 *     ExprMult.ExprMult_1_0 returns ExprRelate
	 *     ExprAdd returns ExprRelate
	 *     ExprAdd.ExprAdd_1_0 returns ExprRelate
	 *     ExprBit returns ExprRelate
	 *     ExprBit.ExprBit_1_0 returns ExprRelate
	 *     ExprRelate returns ExprRelate
	 *     ExprRelate.ExprRelate_1_0 returns ExprRelate
	 *
	 * Constraint:
	 *     (left=ExprRelate_ExprRelate_1_0 (op='<' | op='<=' | op='>' | op='>=') right=ExprEqual)
	 */
	protected void sequence_ExprRelate(ISerializationContext context, ExprRelate semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FunctionArg returns FunctionArg
	 *
	 * Constraint:
	 *     (type=ColumnType name=ID)
	 */
	protected void sequence_FunctionArg(ISerializationContext context, FunctionArg semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.FUNCTION_ARG__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.FUNCTION_ARG__TYPE));
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.FUNCTION_ARG__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.FUNCTION_ARG__NAME));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFunctionArgAccess().getTypeColumnTypeEnumRuleCall_0_0(), semanticObject.getType());
		feeder.accept(grammarAccess.getFunctionArgAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     GroupByExpressions returns GroupByExpressions
	 *
	 * Constraint:
	 *     (groupByExpressions+=SqlExpression groupByExpressions+=SqlExpression*)
	 */
	protected void sequence_GroupByExpressions(ISerializationContext context, GroupByExpressions semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     HavingExpressions returns HavingExpressions
	 *
	 * Constraint:
	 *     expression=SqlExpression
	 */
	protected void sequence_HavingExpressions(ISerializationContext context, HavingExpressions semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.HAVING_EXPRESSIONS__EXPRESSION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.HAVING_EXPRESSIONS__EXPRESSION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getHavingExpressionsAccess().getExpressionSqlExpressionParserRuleCall_0(), semanticObject.getExpression());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     IndexedColumn returns IndexedColumn
	 *
	 * Constraint:
	 *     (columnReference=[ColumnDef|ID] collationName=ID? (asc?='asc' | desc?='desc')?)
	 */
	protected void sequence_IndexedColumn(ISerializationContext context, IndexedColumn semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DMLStatement returns InsertStatement
	 *     InsertStatement returns InsertStatement
	 *
	 * Constraint:
	 *     (
	 *         conflictResolution=ConflictResolution? 
	 *         table=[TableDefinition|ID] 
	 *         (columnNames+=[ColumnDef|ID] columnNames+=[ColumnDef|ID]*)? 
	 *         ((expressions+=SqlExpression expressions+=SqlExpression*) | selectStatement=SelectStatement)?
	 *     )
	 */
	protected void sequence_InsertStatement(ISerializationContext context, InsertStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     JoinSource returns JoinSource
	 *
	 * Constraint:
	 *     (source=SingleSource joinStatements+=JoinStatement*)
	 */
	protected void sequence_JoinSource(ISerializationContext context, JoinSource semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     JoinStatement returns JoinStatement
	 *
	 * Constraint:
	 *     (natural?='natural'? ((left?='left' outer?='outer'?) | inner?='inner' | cross?='cross')? singleSource=SingleSource expression=SqlExpression)
	 */
	protected void sequence_JoinStatement(ISerializationContext context, JoinStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     LiteralValue returns CurrentDateLiteral
	 *
	 * Constraint:
	 *     literal='current_date'
	 */
	protected void sequence_LiteralValue(ISerializationContext context, CurrentDateLiteral semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.CURRENT_DATE_LITERAL__LITERAL) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.CURRENT_DATE_LITERAL__LITERAL));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLiteralValueAccess().getLiteralCurrent_dateKeyword_4_1_0(), semanticObject.getLiteral());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LiteralValue returns CurrentTimeLiteral
	 *
	 * Constraint:
	 *     literal='current_time'
	 */
	protected void sequence_LiteralValue(ISerializationContext context, CurrentTimeLiteral semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.CURRENT_TIME_LITERAL__LITERAL) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.CURRENT_TIME_LITERAL__LITERAL));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLiteralValueAccess().getLiteralCurrent_timeKeyword_3_1_0(), semanticObject.getLiteral());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LiteralValue returns CurrentTimeStampLiteral
	 *
	 * Constraint:
	 *     literal='current_timestamp'
	 */
	protected void sequence_LiteralValue(ISerializationContext context, CurrentTimeStampLiteral semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.CURRENT_TIME_STAMP_LITERAL__LITERAL) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.CURRENT_TIME_STAMP_LITERAL__LITERAL));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLiteralValueAccess().getLiteralCurrent_timestampKeyword_5_1_0(), semanticObject.getLiteral());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LiteralValue returns NullLiteral
	 *
	 * Constraint:
	 *     literal='null'
	 */
	protected void sequence_LiteralValue(ISerializationContext context, NullLiteral semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.NULL_LITERAL__LITERAL) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.NULL_LITERAL__LITERAL));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLiteralValueAccess().getLiteralNullKeyword_2_1_0(), semanticObject.getLiteral());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LiteralValue returns NumericLiteral
	 *
	 * Constraint:
	 *     number=SignedNumber
	 */
	protected void sequence_LiteralValue(ISerializationContext context, NumericLiteral semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.NUMERIC_LITERAL__NUMBER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.NUMERIC_LITERAL__NUMBER));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLiteralValueAccess().getNumberSignedNumberParserRuleCall_0_1_0(), semanticObject.getNumber());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LiteralValue returns StringLiteral
	 *
	 * Constraint:
	 *     literal=STRING
	 */
	protected void sequence_LiteralValue(ISerializationContext context, StringLiteral semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.STRING_LITERAL__LITERAL) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.STRING_LITERAL__LITERAL));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLiteralValueAccess().getLiteralSTRINGTerminalRuleCall_1_1_0(), semanticObject.getLiteral());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     MickeyFile returns MickeyFile
	 *
	 * Constraint:
	 *     (databaseName=QualifiedName blocks+=MickeyBlock*)
	 */
	protected void sequence_MickeyFile(ISerializationContext context, MickeyFile semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     MickeyBlock returns MickeyFunction
	 *     MickeyFunction returns MickeyFunction
	 *
	 * Constraint:
	 *     (name=ID (args+=FunctionArg args+=FunctionArg*)? type=[TableDefinition|QualifiedName]? statements+=DMLStatement*)
	 */
	protected void sequence_MickeyFunction(ISerializationContext context, MickeyFunction semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     MickeyBlock returns MigrationBlock
	 *     MigrationBlock returns MigrationBlock
	 *
	 * Constraint:
	 *     (name=ID from=[MigrationBlock|QualifiedName]? statements+=DDLStatement*)
	 */
	protected void sequence_MigrationBlock(ISerializationContext context, MigrationBlock semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     NotifyContentUriSegment returns NotifyContentUriParamSegment
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_NotifyContentUriSegment(ISerializationContext context, NotifyContentUriParamSegment semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.NOTIFY_CONTENT_URI_SEGMENT__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.NOTIFY_CONTENT_URI_SEGMENT__NAME));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getNotifyContentUriSegmentAccess().getNameIDTerminalRuleCall_1_2_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     NotifyContentUriSegment returns NotifyContentUriSegment
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_NotifyContentUriSegment(ISerializationContext context, NotifyContentUriSegment semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.NOTIFY_CONTENT_URI_SEGMENT__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.NOTIFY_CONTENT_URI_SEGMENT__NAME));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getNotifyContentUriSegmentAccess().getNameIDTerminalRuleCall_0_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     NotifyContentUri returns NotifyContentUri
	 *
	 * Constraint:
	 *     (segments+=NotifyContentUriSegment? segments+=NotifyContentUriSegment*)
	 */
	protected void sequence_NotifyContentUri(ISerializationContext context, NotifyContentUri semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns NullCheckExpression
	 *     ExprConcat returns NullCheckExpression
	 *     ExprConcat.ExprConcat_1_0 returns NullCheckExpression
	 *     ExprMult returns NullCheckExpression
	 *     ExprMult.ExprMult_1_0 returns NullCheckExpression
	 *     ExprAdd returns NullCheckExpression
	 *     ExprAdd.ExprAdd_1_0 returns NullCheckExpression
	 *     ExprBit returns NullCheckExpression
	 *     ExprBit.ExprBit_1_0 returns NullCheckExpression
	 *     ExprRelate returns NullCheckExpression
	 *     ExprRelate.ExprRelate_1_0 returns NullCheckExpression
	 *     ExprEqual returns NullCheckExpression
	 *     ExprEqual.ExprEqual_1_0 returns NullCheckExpression
	 *     ExprAnd returns NullCheckExpression
	 *     ExprAnd.ExprAnd_1_0 returns NullCheckExpression
	 *     ExprOr returns NullCheckExpression
	 *     ExprOr.ExprOr_1_0 returns NullCheckExpression
	 *     NullCheckExpression returns NullCheckExpression
	 *
	 * Constraint:
	 *     (left=NullCheckExpression_NullCheckExpression_1_0 right=NullExpression)
	 */
	protected void sequence_NullCheckExpression(ISerializationContext context, NullCheckExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.NULL_CHECK_EXPRESSION__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.NULL_CHECK_EXPRESSION__LEFT));
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.NULL_CHECK_EXPRESSION__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.NULL_CHECK_EXPRESSION__RIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getNullCheckExpressionAccess().getNullCheckExpressionLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getNullCheckExpressionAccess().getRightNullExpressionParserRuleCall_1_1_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     NullExpression returns IsNull
	 *
	 * Constraint:
	 *     {IsNull}
	 */
	protected void sequence_NullExpression(ISerializationContext context, IsNull semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     NullExpression returns NotNull
	 *
	 * Constraint:
	 *     {NotNull}
	 */
	protected void sequence_NullExpression(ISerializationContext context, NotNull semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     OrderingTermList returns OrderingTermList
	 *
	 * Constraint:
	 *     (orderingTerms+=OrderingTerm orderingTerms+=OrderingTerm*)
	 */
	protected void sequence_OrderingTermList(ISerializationContext context, OrderingTermList semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     OrderingTerm returns OrderingTerm
	 *
	 * Constraint:
	 *     (expression=SqlExpression (asc?='asc' | desc?='desc')?)
	 */
	protected void sequence_OrderingTerm(ISerializationContext context, OrderingTerm semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     TableConstraint returns PrimaryConstraint
	 *     PrimaryConstraint returns PrimaryConstraint
	 *
	 * Constraint:
	 *     (name=ID? columns+=IndexedColumn columns+=IndexedColumn* conflictClause=ConflictClause)
	 */
	protected void sequence_PrimaryConstraint(ISerializationContext context, PrimaryConstraint semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns CaseExpression
	 *     ExprConcat returns CaseExpression
	 *     ExprConcat.ExprConcat_1_0 returns CaseExpression
	 *     ExprMult returns CaseExpression
	 *     ExprMult.ExprMult_1_0 returns CaseExpression
	 *     ExprAdd returns CaseExpression
	 *     ExprAdd.ExprAdd_1_0 returns CaseExpression
	 *     ExprBit returns CaseExpression
	 *     ExprBit.ExprBit_1_0 returns CaseExpression
	 *     ExprRelate returns CaseExpression
	 *     ExprRelate.ExprRelate_1_0 returns CaseExpression
	 *     ExprEqual returns CaseExpression
	 *     ExprEqual.ExprEqual_1_0 returns CaseExpression
	 *     ExprAnd returns CaseExpression
	 *     ExprAnd.ExprAnd_1_0 returns CaseExpression
	 *     ExprOr returns CaseExpression
	 *     ExprOr.ExprOr_1_0 returns CaseExpression
	 *     NullCheckExpression returns CaseExpression
	 *     NullCheckExpression.NullCheckExpression_1_0 returns CaseExpression
	 *     PrimaryExpression returns CaseExpression
	 *
	 * Constraint:
	 *     (caseExpression=SqlExpression? cases+=Case+ elseExpression=SqlExpression?)
	 */
	protected void sequence_PrimaryExpression(ISerializationContext context, CaseExpression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns CastExpression
	 *     ExprConcat returns CastExpression
	 *     ExprConcat.ExprConcat_1_0 returns CastExpression
	 *     ExprMult returns CastExpression
	 *     ExprMult.ExprMult_1_0 returns CastExpression
	 *     ExprAdd returns CastExpression
	 *     ExprAdd.ExprAdd_1_0 returns CastExpression
	 *     ExprBit returns CastExpression
	 *     ExprBit.ExprBit_1_0 returns CastExpression
	 *     ExprRelate returns CastExpression
	 *     ExprRelate.ExprRelate_1_0 returns CastExpression
	 *     ExprEqual returns CastExpression
	 *     ExprEqual.ExprEqual_1_0 returns CastExpression
	 *     ExprAnd returns CastExpression
	 *     ExprAnd.ExprAnd_1_0 returns CastExpression
	 *     ExprOr returns CastExpression
	 *     ExprOr.ExprOr_1_0 returns CastExpression
	 *     NullCheckExpression returns CastExpression
	 *     NullCheckExpression.NullCheckExpression_1_0 returns CastExpression
	 *     PrimaryExpression returns CastExpression
	 *
	 * Constraint:
	 *     (expression=SqlExpression type=SqliteDataType)
	 */
	protected void sequence_PrimaryExpression(ISerializationContext context, CastExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.CAST_EXPRESSION__EXPRESSION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.CAST_EXPRESSION__EXPRESSION));
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.CAST_EXPRESSION__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.CAST_EXPRESSION__TYPE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getPrimaryExpressionAccess().getExpressionSqlExpressionParserRuleCall_8_3_0(), semanticObject.getExpression());
		feeder.accept(grammarAccess.getPrimaryExpressionAccess().getTypeSqliteDataTypeEnumRuleCall_8_5_0(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns ColumnSourceRef
	 *     ExprConcat returns ColumnSourceRef
	 *     ExprConcat.ExprConcat_1_0 returns ColumnSourceRef
	 *     ExprMult returns ColumnSourceRef
	 *     ExprMult.ExprMult_1_0 returns ColumnSourceRef
	 *     ExprAdd returns ColumnSourceRef
	 *     ExprAdd.ExprAdd_1_0 returns ColumnSourceRef
	 *     ExprBit returns ColumnSourceRef
	 *     ExprBit.ExprBit_1_0 returns ColumnSourceRef
	 *     ExprRelate returns ColumnSourceRef
	 *     ExprRelate.ExprRelate_1_0 returns ColumnSourceRef
	 *     ExprEqual returns ColumnSourceRef
	 *     ExprEqual.ExprEqual_1_0 returns ColumnSourceRef
	 *     ExprAnd returns ColumnSourceRef
	 *     ExprAnd.ExprAnd_1_0 returns ColumnSourceRef
	 *     ExprOr returns ColumnSourceRef
	 *     ExprOr.ExprOr_1_0 returns ColumnSourceRef
	 *     NullCheckExpression returns ColumnSourceRef
	 *     NullCheckExpression.NullCheckExpression_1_0 returns ColumnSourceRef
	 *     PrimaryExpression returns ColumnSourceRef
	 *
	 * Constraint:
	 *     (source=[SelectSource|ID] | (source=[SelectSource|ID] (all?='*' | column=[ColumnSource|ID])) | column=[ColumnSource|ID])
	 */
	protected void sequence_PrimaryExpression(ISerializationContext context, ColumnSourceRef semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns Function
	 *     ExprConcat returns Function
	 *     ExprConcat.ExprConcat_1_0 returns Function
	 *     ExprMult returns Function
	 *     ExprMult.ExprMult_1_0 returns Function
	 *     ExprAdd returns Function
	 *     ExprAdd.ExprAdd_1_0 returns Function
	 *     ExprBit returns Function
	 *     ExprBit.ExprBit_1_0 returns Function
	 *     ExprRelate returns Function
	 *     ExprRelate.ExprRelate_1_0 returns Function
	 *     ExprEqual returns Function
	 *     ExprEqual.ExprEqual_1_0 returns Function
	 *     ExprAnd returns Function
	 *     ExprAnd.ExprAnd_1_0 returns Function
	 *     ExprOr returns Function
	 *     ExprOr.ExprOr_1_0 returns Function
	 *     NullCheckExpression returns Function
	 *     NullCheckExpression.NullCheckExpression_1_0 returns Function
	 *     PrimaryExpression returns Function
	 *
	 * Constraint:
	 *     (name=ID (all?='*' | (arguments+=SqlExpression arguments+=SqlExpression*)))
	 */
	protected void sequence_PrimaryExpression(ISerializationContext context, Function semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns FunctionArgument
	 *     ExprConcat returns FunctionArgument
	 *     ExprConcat.ExprConcat_1_0 returns FunctionArgument
	 *     ExprMult returns FunctionArgument
	 *     ExprMult.ExprMult_1_0 returns FunctionArgument
	 *     ExprAdd returns FunctionArgument
	 *     ExprAdd.ExprAdd_1_0 returns FunctionArgument
	 *     ExprBit returns FunctionArgument
	 *     ExprBit.ExprBit_1_0 returns FunctionArgument
	 *     ExprRelate returns FunctionArgument
	 *     ExprRelate.ExprRelate_1_0 returns FunctionArgument
	 *     ExprEqual returns FunctionArgument
	 *     ExprEqual.ExprEqual_1_0 returns FunctionArgument
	 *     ExprAnd returns FunctionArgument
	 *     ExprAnd.ExprAnd_1_0 returns FunctionArgument
	 *     ExprOr returns FunctionArgument
	 *     ExprOr.ExprOr_1_0 returns FunctionArgument
	 *     NullCheckExpression returns FunctionArgument
	 *     NullCheckExpression.NullCheckExpression_1_0 returns FunctionArgument
	 *     PrimaryExpression returns FunctionArgument
	 *
	 * Constraint:
	 *     arg=[FunctionArg|ID]
	 */
	protected void sequence_PrimaryExpression(ISerializationContext context, FunctionArgument semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.FUNCTION_ARGUMENT__ARG) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.FUNCTION_ARGUMENT__ARG));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getPrimaryExpressionAccess().getArgFunctionArgIDTerminalRuleCall_9_2_0_1(), semanticObject.getArg());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns Literal
	 *     ExprConcat returns Literal
	 *     ExprConcat.ExprConcat_1_0 returns Literal
	 *     ExprMult returns Literal
	 *     ExprMult.ExprMult_1_0 returns Literal
	 *     ExprAdd returns Literal
	 *     ExprAdd.ExprAdd_1_0 returns Literal
	 *     ExprBit returns Literal
	 *     ExprBit.ExprBit_1_0 returns Literal
	 *     ExprRelate returns Literal
	 *     ExprRelate.ExprRelate_1_0 returns Literal
	 *     ExprEqual returns Literal
	 *     ExprEqual.ExprEqual_1_0 returns Literal
	 *     ExprAnd returns Literal
	 *     ExprAnd.ExprAnd_1_0 returns Literal
	 *     ExprOr returns Literal
	 *     ExprOr.ExprOr_1_0 returns Literal
	 *     NullCheckExpression returns Literal
	 *     NullCheckExpression.NullCheckExpression_1_0 returns Literal
	 *     PrimaryExpression returns Literal
	 *
	 * Constraint:
	 *     literalValue=LiteralValue
	 */
	protected void sequence_PrimaryExpression(ISerializationContext context, Literal semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.LITERAL__LITERAL_VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.LITERAL__LITERAL_VALUE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getPrimaryExpressionAccess().getLiteralValueLiteralValueParserRuleCall_3_1_0(), semanticObject.getLiteralValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns NestedExpression
	 *     ExprConcat returns NestedExpression
	 *     ExprConcat.ExprConcat_1_0 returns NestedExpression
	 *     ExprMult returns NestedExpression
	 *     ExprMult.ExprMult_1_0 returns NestedExpression
	 *     ExprAdd returns NestedExpression
	 *     ExprAdd.ExprAdd_1_0 returns NestedExpression
	 *     ExprBit returns NestedExpression
	 *     ExprBit.ExprBit_1_0 returns NestedExpression
	 *     ExprRelate returns NestedExpression
	 *     ExprRelate.ExprRelate_1_0 returns NestedExpression
	 *     ExprEqual returns NestedExpression
	 *     ExprEqual.ExprEqual_1_0 returns NestedExpression
	 *     ExprAnd returns NestedExpression
	 *     ExprAnd.ExprAnd_1_0 returns NestedExpression
	 *     ExprOr returns NestedExpression
	 *     ExprOr.ExprOr_1_0 returns NestedExpression
	 *     NullCheckExpression returns NestedExpression
	 *     NullCheckExpression.NullCheckExpression_1_0 returns NestedExpression
	 *     PrimaryExpression returns NestedExpression
	 *
	 * Constraint:
	 *     expression=SqlExpression
	 */
	protected void sequence_PrimaryExpression(ISerializationContext context, NestedExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.NESTED_EXPRESSION__EXPRESSION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.NESTED_EXPRESSION__EXPRESSION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getPrimaryExpressionAccess().getExpressionSqlExpressionParserRuleCall_4_2_0(), semanticObject.getExpression());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns NewColumn
	 *     ExprConcat returns NewColumn
	 *     ExprConcat.ExprConcat_1_0 returns NewColumn
	 *     ExprMult returns NewColumn
	 *     ExprMult.ExprMult_1_0 returns NewColumn
	 *     ExprAdd returns NewColumn
	 *     ExprAdd.ExprAdd_1_0 returns NewColumn
	 *     ExprBit returns NewColumn
	 *     ExprBit.ExprBit_1_0 returns NewColumn
	 *     ExprRelate returns NewColumn
	 *     ExprRelate.ExprRelate_1_0 returns NewColumn
	 *     ExprEqual returns NewColumn
	 *     ExprEqual.ExprEqual_1_0 returns NewColumn
	 *     ExprAnd returns NewColumn
	 *     ExprAnd.ExprAnd_1_0 returns NewColumn
	 *     ExprOr returns NewColumn
	 *     ExprOr.ExprOr_1_0 returns NewColumn
	 *     NullCheckExpression returns NewColumn
	 *     NullCheckExpression.NullCheckExpression_1_0 returns NewColumn
	 *     PrimaryExpression returns NewColumn
	 *
	 * Constraint:
	 *     column=[ColumnSource|ID]
	 */
	protected void sequence_PrimaryExpression(ISerializationContext context, NewColumn semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.NEW_COLUMN__COLUMN) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.NEW_COLUMN__COLUMN));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceIDTerminalRuleCall_0_2_0_1(), semanticObject.getColumn());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns OldColumn
	 *     ExprConcat returns OldColumn
	 *     ExprConcat.ExprConcat_1_0 returns OldColumn
	 *     ExprMult returns OldColumn
	 *     ExprMult.ExprMult_1_0 returns OldColumn
	 *     ExprAdd returns OldColumn
	 *     ExprAdd.ExprAdd_1_0 returns OldColumn
	 *     ExprBit returns OldColumn
	 *     ExprBit.ExprBit_1_0 returns OldColumn
	 *     ExprRelate returns OldColumn
	 *     ExprRelate.ExprRelate_1_0 returns OldColumn
	 *     ExprEqual returns OldColumn
	 *     ExprEqual.ExprEqual_1_0 returns OldColumn
	 *     ExprAnd returns OldColumn
	 *     ExprAnd.ExprAnd_1_0 returns OldColumn
	 *     ExprOr returns OldColumn
	 *     ExprOr.ExprOr_1_0 returns OldColumn
	 *     NullCheckExpression returns OldColumn
	 *     NullCheckExpression.NullCheckExpression_1_0 returns OldColumn
	 *     PrimaryExpression returns OldColumn
	 *
	 * Constraint:
	 *     column=[ColumnSource|ID]
	 */
	protected void sequence_PrimaryExpression(ISerializationContext context, OldColumn semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.OLD_COLUMN__COLUMN) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.OLD_COLUMN__COLUMN));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceIDTerminalRuleCall_1_2_0_1(), semanticObject.getColumn());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     SqlExpression returns SelectStatementExpression
	 *     ExprConcat returns SelectStatementExpression
	 *     ExprConcat.ExprConcat_1_0 returns SelectStatementExpression
	 *     ExprMult returns SelectStatementExpression
	 *     ExprMult.ExprMult_1_0 returns SelectStatementExpression
	 *     ExprAdd returns SelectStatementExpression
	 *     ExprAdd.ExprAdd_1_0 returns SelectStatementExpression
	 *     ExprBit returns SelectStatementExpression
	 *     ExprBit.ExprBit_1_0 returns SelectStatementExpression
	 *     ExprRelate returns SelectStatementExpression
	 *     ExprRelate.ExprRelate_1_0 returns SelectStatementExpression
	 *     ExprEqual returns SelectStatementExpression
	 *     ExprEqual.ExprEqual_1_0 returns SelectStatementExpression
	 *     ExprAnd returns SelectStatementExpression
	 *     ExprAnd.ExprAnd_1_0 returns SelectStatementExpression
	 *     ExprOr returns SelectStatementExpression
	 *     ExprOr.ExprOr_1_0 returns SelectStatementExpression
	 *     NullCheckExpression returns SelectStatementExpression
	 *     NullCheckExpression.NullCheckExpression_1_0 returns SelectStatementExpression
	 *     PrimaryExpression returns SelectStatementExpression
	 *
	 * Constraint:
	 *     (not?='not'? exists?='exists'? select=SelectStatement)
	 */
	protected void sequence_PrimaryExpression(ISerializationContext context, SelectStatementExpression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     ResultColumn returns ResultColumn
	 *
	 * Constraint:
	 *     (expression=SqlExpression name=ID?)
	 */
	protected void sequence_ResultColumn(ISerializationContext context, ResultColumn semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SelectCore returns SelectCore
	 *     SelectCore.SelectCore_1_0 returns SelectCore
	 *
	 * Constraint:
	 *     (left=SelectCore_SelectCore_1_0 op=CompoundOperator right=SelectExpression)
	 */
	protected void sequence_SelectCore(ISerializationContext context, SelectCore semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.SELECT_CORE__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.SELECT_CORE__LEFT));
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.SELECT_CORE__OP) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.SELECT_CORE__OP));
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.SELECT_CORE__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.SELECT_CORE__RIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getSelectCoreAccess().getSelectCoreLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getSelectCoreAccess().getOpCompoundOperatorEnumRuleCall_1_1_0(), semanticObject.getOp());
		feeder.accept(grammarAccess.getSelectCoreAccess().getRightSelectExpressionParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     SelectCore returns SelectExpression
	 *     SelectCore.SelectCore_1_0 returns SelectExpression
	 *     SelectExpression returns SelectExpression
	 *
	 * Constraint:
	 *     (
	 *         (distinct?='distinct' | all?='all')? 
	 *         (allColumns?='*' | selectList=SelectList) 
	 *         source=JoinSource? 
	 *         where=WhereExpressions? 
	 *         groupBy=GroupByExpressions? 
	 *         having=HavingExpressions?
	 *     )
	 */
	protected void sequence_SelectExpression(ISerializationContext context, SelectExpression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SelectList returns SelectList
	 *
	 * Constraint:
	 *     (resultColumns+=ResultColumn resultColumns+=ResultColumn*)
	 */
	protected void sequence_SelectList(ISerializationContext context, SelectList semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SelectStatement returns SelectStatement
	 *     DMLStatement returns SelectStatement
	 *
	 * Constraint:
	 *     (core=SelectCore orderby=OrderingTermList? (limit=SqlExpression limitOffset=SqlExpression?)?)
	 */
	protected void sequence_SelectStatement(ISerializationContext context, SelectStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SingleSource returns SingleSourceJoin
	 *     SingleSourceJoin returns SingleSourceJoin
	 *
	 * Constraint:
	 *     joinSource=JoinSource
	 */
	protected void sequence_SingleSourceJoin(ISerializationContext context, SingleSourceJoin semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.SINGLE_SOURCE_JOIN__JOIN_SOURCE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.SINGLE_SOURCE_JOIN__JOIN_SOURCE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getSingleSourceJoinAccess().getJoinSourceJoinSourceParserRuleCall_1_0(), semanticObject.getJoinSource());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     SingleSource returns SingleSourceSelectStatement
	 *     SingleSourceSelectStatement returns SingleSourceSelectStatement
	 *
	 * Constraint:
	 *     (selectStatement=SelectStatement name=ID?)
	 */
	protected void sequence_SingleSourceSelectStatement(ISerializationContext context, SingleSourceSelectStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SingleSource returns SingleSourceTable
	 *     SingleSourceTable returns SingleSourceTable
	 *
	 * Constraint:
	 *     (tableReference=[TableDefinition|QualifiedName] name=ID?)
	 */
	protected void sequence_SingleSourceTable(ISerializationContext context, SingleSourceTable semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     TableConstraint returns UniqueTableConstraint
	 *     UniqueTableConstraint returns UniqueTableConstraint
	 *
	 * Constraint:
	 *     (name=ID? columns+=IndexedColumn columns+=IndexedColumn* conflictClause=ConflictClause)
	 */
	protected void sequence_UniqueTableConstraint(ISerializationContext context, UniqueTableConstraint semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UpdateColumnExpression returns UpdateColumnExpression
	 *
	 * Constraint:
	 *     (columnName=[ColumnDef|ID] expression=SqlExpression)
	 */
	protected void sequence_UpdateColumnExpression(ISerializationContext context, UpdateColumnExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.UPDATE_COLUMN_EXPRESSION__COLUMN_NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.UPDATE_COLUMN_EXPRESSION__COLUMN_NAME));
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.UPDATE_COLUMN_EXPRESSION__EXPRESSION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.UPDATE_COLUMN_EXPRESSION__EXPRESSION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getUpdateColumnExpressionAccess().getColumnNameColumnDefIDTerminalRuleCall_0_0_1(), semanticObject.getColumnName());
		feeder.accept(grammarAccess.getUpdateColumnExpressionAccess().getExpressionSqlExpressionParserRuleCall_2_0(), semanticObject.getExpression());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DMLStatement returns UpdateStatement
	 *     UpdateStatement returns UpdateStatement
	 *
	 * Constraint:
	 *     (
	 *         conflictResolution=ConflictResolution? 
	 *         table=[TableDefinition|ID] 
	 *         updateColumnExpressions+=UpdateColumnExpression 
	 *         updateColumnExpressions+=UpdateColumnExpression* 
	 *         whereExpression=SqlExpression?
	 *     )
	 */
	protected void sequence_UpdateStatement(ISerializationContext context, UpdateStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     WhereExpressions returns WhereExpressions
	 *
	 * Constraint:
	 *     expression=SqlExpression
	 */
	protected void sequence_WhereExpressions(ISerializationContext context, WhereExpressions semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, MickeyLangPackage.Literals.WHERE_EXPRESSIONS__EXPRESSION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MickeyLangPackage.Literals.WHERE_EXPRESSIONS__EXPRESSION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getWhereExpressionsAccess().getExpressionSqlExpressionParserRuleCall_0(), semanticObject.getExpression());
		feeder.finish();
	}
	
	
}
