protected override void VisitDropTableStatement(DropTableStatement statement)
{
State.Write(Symbols.DROP);
State.Write(Symbols.TABLE);
if (statement.CheckExists)
{
State.Write(Symbols.IF);
State.Write(Symbols.EXISTS);
}
VisitNameToken(statement.Name);
}
public override void ExplicitVisit(DropTableStatement node)
{
PgExpressionVisitor expressionVisitor = new PgExpressionVisitor(_buffer);
for (int index = 0, count = node.Objects.Count - 1; index <= count; ++index)
{
_buffer.Append("drop table");
if (node.IsIfExists)
{
_buffer.Append(" if exists");
}
_buffer.Append(" ");
node.Objects[index].Accept(expressionVisitor);
_buffer.AppendLine(";");
}
}
protected override void VisitDropTableStatement(DropTableStatement statement)
{
//DROP TABLE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
State.Write(Symbols.DROP);
State.Write(Symbols.TABLE);
if (statement.CheckExists)
{
State.Write(Symbols.IF);
State.Write(Symbols.EXISTS);
}
State.Write(statement.Name.GetFullName(this.IdentifierOpenQuote, this.IdentifierCloseQuote));
if (statement.IsCascade.HasValue)
{
if (statement.IsCascade.Value)
{
State.Write(Symbols.CASCADE);
}
else
{
State.Write(Symbols.RESTRICT);
}
}
}
public override void ExplicitVisit(DropTableStatement node)
{
Warnings.Add(String.Format("Found a drop table statement at startLine {0} and startColumn {1}",
node.StartLine, node.StartColumn));//drop is not yet supported
base.Visit(node);
}
public override void Visit(DropTableStatement node)
{
DDLStatementFound = true;
}
public override void Visit(DropTableStatement node) { this.action(node); }
protected override void VisitMerge(MergeStatement statement)
{
VisitStatement(Sql.BeginTransaction());
State.WriteStatementTerminator();
bool isTop = false;
string prefixToAlias = "alias_";
IList <string> tempUpdateAliases = new List <string>();
string targetTable = statement.Into.GetFullName();
string targetAlias = (String.IsNullOrWhiteSpace(statement.Into.Alias)) ? prefixToAlias + statement.Into.LastPart : statement.Into.Alias;
string sourceTable = ((Name)statement.Using).GetFullName();
string sourceAlias = (String.IsNullOrWhiteSpace(((Name)statement.Using).Alias)) ? prefixToAlias + ((Name)statement.Using).LastPart : ((Name)statement.Using).Alias;
string targetColumnOn = string.Empty;
string sourceColumnOn = string.Empty;
string firstOn = ((Name)((BinaryToken)statement.On).First).FirstPart;
if ((firstOn).Equals(targetTable) || (firstOn).Equals(targetAlias))
{
targetColumnOn = ((Name)((BinaryToken)statement.On).First).LastPart;
sourceColumnOn = ((Name)((BinaryToken)statement.On).Second).LastPart;
}
else
{
sourceColumnOn = ((Name)((BinaryToken)statement.On).First).LastPart;
targetColumnOn = ((Name)((BinaryToken)statement.On).Second).LastPart;
}
((BinaryToken)statement.On).First = Sql.Name(targetAlias, targetColumnOn);
((BinaryToken)statement.On).Second = Sql.Name(sourceAlias, sourceColumnOn);
if (statement.Top != null)
{
CreateTableStatement createTable = Sql.CreateTemporaryTable(Sql.Name(TopAlias), true).As(Sql.Select.Output(Sql.Name(targetColumnOn)).From(Sql.Name(targetTable)).Top(((int)((Scalar)statement.Top.Value).Value), statement.Top.Percent));
isTop = true;
VisitStatement(createTable);
State.WriteStatementTerminator();
}
VisitWhenMatchedUpdateToken(statement
, tempUpdateAliases
, targetAlias
, targetTable
, targetColumnOn
, sourceAlias
, sourceTable
, sourceColumnOn
, isTop);
VisitWhenMatchedDeleteToken(statement
, targetAlias
, targetTable
, targetColumnOn
, sourceAlias
, sourceTable
, sourceColumnOn
, isTop);
VisitWhenNotMatchedBySourceToken(statement
, targetAlias
, targetTable
, targetColumnOn
, sourceAlias
, sourceTable
, sourceColumnOn
, isTop);
VisitWhenNotMatchedThenInsertToken(statement
, tempUpdateAliases
, targetAlias
, targetColumnOn
, targetTable
, sourceAlias
, sourceTable
, sourceColumnOn);
if (tempUpdateAliases.Count != 0)
{
foreach (string tempTable in tempUpdateAliases)
{
DropTableStatement dropTable = Sql.DropTemporaryTable(tempTable, true);
VisitStatement(dropTable);
State.WriteStatementTerminator();
}
}
if (isTop)
{
DropTableStatement dropTable = Sql.DropTemporaryTable(TopAlias, true);
VisitStatement(dropTable);
State.WriteStatementTerminator();
}
VisitStatement(Sql.CommitTransaction());
}
public override void ExplicitVisit(DropTableStatement fragment)
{
_fragments.Add(fragment);
}
public override void ExplicitVisit(DropTableStatement node)
{
this.DropTableStatements.Add(node);
}
protected abstract void VisitDropTableStatement(DropTableStatement statement);
private IList <DbObjectTableSource> GetAvailTables(GrammarNode node)
{
IList <DbObjectTableSource> ret = new List <DbObjectTableSource>();
if (node is UpdateStatement)
{
UpdateStatement upd = (UpdateStatement)node;
dynamic ts = upd.TableSource;
AddAvailTable(ts, ret);
AddAvailTables(upd.FromClause, ret);
}
if (node is DeleteStatement)
{
dynamic ts = ((DeleteStatement)node).Table;
AddAvailTable(ts, ret);
}
if (node is InsertStatement)
{
InsertStatement insert = (InsertStatement)node;
if (insert.InsertTarget is DbObjectInsertTarget)
{
AddAvailTable(((DbObjectInsertTarget)insert.InsertTarget).TableSource, ret);
}
}
if (node is CreateIndexStatement)
{
CreateIndexStatement stmt = (CreateIndexStatement)node;
if (stmt.IndexTarget is DbObjectIndexTarget)
{
AddAvailTable(stmt.IndexTarget.TableSource, ret);
}
}
if (node is DropIndexStatement)
{
DropIndexStatement stmt = (DropIndexStatement)node;
foreach (DropIndexAction action in stmt.Actions)
{
if (action.TableSource != null)
{
AddAvailTable(action.TableSource, ret);
}
}
}
if (node is AlterIndexStatement)
{
AlterIndexStatement stmt = (AlterIndexStatement)node;
if (stmt.TableSource != null)
{
// It will be removed in Modifier, so probably useless code
AddAvailTable(stmt.TableSource, ret);
}
}
if (node is AlterTableStatement)
{
AlterTableStatement stmt = (AlterTableStatement)node;
if (stmt.TableSource != null)
{
AddAvailTable(stmt.TableSource, ret);
}
}
if (node is DropTableStatement)
{
DropTableStatement stmt = (DropTableStatement)node;
foreach (DbObjectTableSource tableSource in stmt.TableSources)
{
if (tableSource != null)
{
AddAvailTable(tableSource, ret);
}
}
}
TrimTables(ref ret);
return((ret.Count == 0) ? null : ret);
}
public override IDbStatement Visit(DropTableStatement item)
{
writer.Write("DROP TABLE ");
Visit(item.Table);
return item;
}
/// <summary>
/// Parse the SQL string and return a Statement
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static IStatement Parse(string value)
{
IStatement result = null;
foreach (KeyValuePair <QAStatementType, string[]> kv in Clauses)
{
string[] splitters = kv.Value;
if (!value.StartsWith(splitters[0], StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
List <KeyValue> clauses = ParseStatement(value, splitters);
CheckRequiredClause(clauses, kv.Key);
#region Return strong-type statements
switch (kv.Key)
{
#region DML Statements
case QAStatementType.Select:
result = new SelectStatement(clauses);
break;
case QAStatementType.Insert:
result = new InsertStatement(clauses);
break;
case QAStatementType.Update:
result = new UpdateStatement(clauses);
break;
#endregion
#region DDL Statements
case QAStatementType.Delete:
result = new DeleteStatement(clauses);
break;
case QAStatementType.CreateTable:
result = new CreateTableStatement(clauses);
break;
case QAStatementType.DropTable:
result = new DropTableStatement(clauses);
break;
#endregion
#region QueryAnything Statements
case QAStatementType.OpenFile:
result = new OpenStatement(clauses);
break;
case QAStatementType.OpenDatabase:
result = new OpenDatabaseStatement(clauses);
break;
case QAStatementType.SaveDataSet:
result = new SaveDataSetStatement(clauses);
break;
case QAStatementType.SaveDataTable:
result = new SaveDataTableStatement(clauses);
break;
case QAStatementType.Commit:
result = new CommitStatement(clauses);
break;
case QAStatementType.Rollback:
result = new RollbackStatement(clauses);
break;
case QAStatementType.Clear:
result = new ClearStatement(clauses);
break;
case QAStatementType.List:
result = new ListStatement(clauses);
break;
case QAStatementType.ViewDataSet:
result = new ViewDataSet(clauses);
break;
#endregion
default:
throw new ArgumentOutOfRangeException("key=" + kv.Key);
}
#endregion
if (result != null)
{
break;
}
}
return(result);
}
public override void Visit(DropTableStatement node)
{
Drops++;
DropTables.AddRange(node.Objects.Select(o => o.BaseIdentifier.Value));
}
