private void NodeAction(TSqlFragment node) { List<ISkimmer<SqlFileContext>> skimmersList; if (node == null) { return; } if (this.typeToSkimmersMap.TryGetValue(node.GetType(), out skimmersList)) { foreach (ISqlSkimmer skimmer in skimmersList) { this.context.Fragment = node; try { skimmer.Analyze(this.context); } catch (Exception ex) { RuntimeErrors |= AnalyzeCommand.LogUnhandledRuleExceptionAnalyzingTarget( this.disabledSkimmers, this.context, skimmer, ex); } } } }
private TableNameDeclareCheckVisitor visitTSql(string tsql) { TSqlParser parser = new TSql100Parser(false); IList <ParseError> errors; TextReader reader = new StringReader(tsql); TSqlFragment parsed = parser.Parse(reader, out errors); if (errors.Count != 0) { string errorMessage = ""; foreach (ParseError error in errors) { errorMessage = errorMessage + "\n" + error.Line + " : " + error.Message; } throw new Exception("パース失敗\n" + errorMessage); } TableNameDeclareCheckVisitor visitor = new TableNameDeclareCheckVisitor(); parsed.Accept(visitor); return(visitor); }
private void ParseDelete(string query) { TSqlFragment tree = InitiateTSql110Parser(query); if (SyntaxError) { return; } if (tree is TSqlScript) { TSqlScript tSqlScript = tree as TSqlScript; foreach (TSqlBatch sqlBatch in tSqlScript.Batches) { foreach (TSqlStatement sqlStatement in sqlBatch.Statements) { ParseSqlDeleteStatement(sqlStatement); } } } RbacTSqlFragmentVisitor rbacTSqlFragmentVisitor = new RbacTSqlFragmentVisitor(); tree.Accept(rbacTSqlFragmentVisitor); this.Warnings.AddRange(rbacTSqlFragmentVisitor.Warnings); TablesReferred = new List <RbacTable>(TablesReferred.DistinctBy(t => t.Name)); IsParsed = true; }
private WSqlFragment ConvertFragment(TSqlFragment fragment) { var tscript = fragment as TSqlScript; var wscript = new WSqlScript { FirstTokenIndex = tscript.FirstTokenIndex, LastTokenIndex = tscript.LastTokenIndex, Batches = tscript.Batches == null ? null : new List<WSqlBatch>(tscript.Batches.Count), }; foreach (var tbatch in tscript.Batches) { var wbatch = new WSqlBatch { FirstTokenIndex = tbatch.FirstTokenIndex, LastTokenIndex = tbatch.LastTokenIndex, Statements = new List<WSqlStatement>(tbatch.Statements.Count), }; foreach (var wstat in tbatch.Statements.Select(ParseStatement)) { wbatch.Statements.Add(wstat); } wscript.Batches.Add(wbatch); } return wscript; }
public static void Accept(this TSqlFragment fragment, params TSqlFragmentVisitor[] visitors) { foreach (var visitor in visitors) { fragment.Accept(visitor); } }
/// <summary> /// Scripts the fragment to a string /// </summary> /// <param name="fragment"></param> /// <returns></returns> public static string GetScript(this TSqlFragment fragment) { var generator = new Sql140ScriptGenerator(); generator.GenerateScript(fragment, out string sql); return(sql); }
public static int GetNodeColumnPosition(TSqlFragment node) { var line = string.Empty; var nodeStartLine = node.StartLine; var nodeLastLine = node.ScriptTokenStream[node.LastTokenIndex].Line; for (var tokenIndex = 0; tokenIndex <= node.LastTokenIndex; tokenIndex++) { var token = node.ScriptTokenStream[tokenIndex]; if (token.Line >= nodeStartLine && token.Line <= nodeLastLine) { line += token.Text; } } var positionOfNodeOnLine = line.LastIndexOf(node.ScriptTokenStream[node.FirstTokenIndex].Text, StringComparison.Ordinal); var charactersBeforeNode = line.Substring(0, positionOfNodeOnLine); var offSet = 0; if (charactersBeforeNode.IndexOf(" ", StringComparison.Ordinal) != -1) { offSet = 1; } var tabCount = CountTabs(charactersBeforeNode); var totalTabLentgh = tabCount * Constants.TabWidth; var nodePosition = totalTabLentgh + (charactersBeforeNode.Length - tabCount) + offSet; return(nodePosition); }
private void NodeAction(TSqlFragment node) { List <ISkimmer <SqlFileContext> > skimmersList; if (node == null) { return; } if (this.typeToSkimmersMap.TryGetValue(node.GetType(), out skimmersList)) { foreach (ISqlSkimmer skimmer in skimmersList) { this.context.Fragment = node; try { skimmer.Analyze(this.context); } catch (Exception ex) { RuntimeErrors |= AnalyzeCommand.LogUnhandledRuleExceptionAnalyzingTarget( this.disabledSkimmers, this.context, skimmer, ex); } } } }
protected string GenerateScript(TSqlFragment fragment) { string script; var generator = new Sql120ScriptGenerator(SavedSettings.Get().GeneratorOptions); generator.GenerateScript(fragment, out script); return script; }
private void AnalyzeQueries(IList <SqlRuleProblem> problems, TSqlFragment fragment, SqlRuleExecutionContext ruleExecutionContext) { // Find all queries in current checking fragment. var visitor = new GetQuerySpecificationsVisitor(); fragment.Accept(visitor); foreach (var querySpecification in visitor.Queries) { // Get the specified tables in the query. var unspecifiedPartitions = CollectFromClause(ruleExecutionContext, querySpecification); // If the query isn't querying a partition table, we don't need to check it. if (unspecifiedPartitions.Count > 0) { // Get all constraints in the query. if (querySpecification.WhereClause != null) { SearchConstraints(querySpecification.WhereClause, unspecifiedPartitions); } } // If there are any unspecified partitions left, these are considered problems. foreach (var unspecifiedPartition in unspecifiedPartitions) { SqlRuleProblem problem = CreateProblem(ruleExecutionContext, unspecifiedPartition); problems.Add(problem); } AnalyzeJoins(problems, ruleExecutionContext, querySpecification); } }
public static CodeExpression BuildFromCheckConstraintDefinition(string schemaName, DataTable table, string check_name, string check_definition, out bool hasError, out string errorText) { string select_statement = "SELECT colx = IIF((" + check_definition + "), 1, 0) FROM " + schemaName + ".[" + table.TableName + "] WHERE " + check_definition; TSqlFragment sqlF = ScriptDomFacade.Parse(select_statement); IIFVisitor iif_visitor = new IIFVisitor(); sqlF.Accept(iif_visitor); if (iif_visitor.result == null) { throw new NotSupportedException("Expression 'IIF' could not be found:" + sqlF.AsText()); } BooleanExpression iif_predicate = iif_visitor.result.Predicate; //if (iif_visitor != null) //{ // //return null; // comment out if it needed //} //Console.WriteLine(""); //Console.WriteLine("==== " + check_name + " ============"); //Console.WriteLine(ScriptDomFacade.GenerateScript(iif_predicate)); //Console.WriteLine("-------------------------------------------"); //Console.WriteLine(""); var databaseMetadata = new DatabaseMetadataOnTable(table); hasError = false; errorText = null; return(BooleanExpressionGeneratorVisitor.TryBuildFromFragment(databaseMetadata, iif_predicate, ref hasError, ref errorText)); }
private void ProcessSelectSetFragment(TSqlFragment Expression, string VarName) { string ElemType = FragmentTypeParser.GetFragmentType(Expression); switch (ElemType) { case "BinaryExpression": var BinaryExpression = (BinaryExpression) Expression; ProcessSelectSetFragment(BinaryExpression.FirstExpression, VarName); ProcessSelectSetFragment(BinaryExpression.SecondExpression, VarName); break; case "VariableReference": ProcessVariableReference((VariableReference) Expression, VarName); break; case "FunctionCall": var Func = (FunctionCall) Expression; foreach (TSqlFragment Parameter in Func.Parameters) { ProcessSelectSetFragment(Parameter, VarName); } break; case "CastCall": var Cast = (CastCall) Expression; if (FragmentTypeParser.GetFragmentType(Cast.Parameter) == "VariableReference") { ProcessVariableReference((VariableReference) Cast.Parameter, VarName); } break; case "StringLiteral": break; } }
public IList<ParseError> TryGetTSqlFragment(out TSqlFragment fragment) { IList<ParseError> errors; if (this.tsqlFragment != null) { fragment = this.tsqlFragment; return null; } errors = null; fragment = null; lock (this.lockObject) { if (this.tsqlFragment == null) { var parser = new TSql120Parser(initialQuotedIdentifiers: false); using (StringReader reader = new StringReader(File.ReadAllText(TargetUri.LocalPath))) { this.tsqlFragment = parser.Parse(reader, out errors); } } } fragment = this.tsqlFragment; return errors; }
protected override IList <SqlRuleProblem> ElicitProblems(TSqlFragment fragment, RuleDescriptor ruleDescriptor, string elementName, TSqlObject modelElement) { var visitor = new AvoidUsingGlobalVariableForIdentityVisitor(); fragment.Accept(visitor); return(this.CreateProblemsAsError(ruleDescriptor, elementName, modelElement, visitor.InvalidVariables)); }
public static IList <SelectStatement> VisitSelectStatements(TSqlFragment fragment) { TSqlSelectVisitor visitor = new TSqlSelectVisitor(); fragment.Accept(visitor); return(visitor.SelectStatements); }
public ISyntaxNode Visit(TSqlFragment node, TSqlFragment parent, string sourceProperty, ISyntaxNode result) { UpdateSpecification update = node as UpdateSpecification; if (update == null) { return(result); } StatementNode statement = new StatementNode() { Parent = result, Fragment = node, ParentFragment = parent, TargetProperty = sourceProperty }; if (result is ScriptNode script) { if (parent is UpdateStatement) { script.Statements.Add(statement); return(statement); } } return(result); }
public override void ExplicitVisit(CreateTableStatement table) { if (IsSupportedForCurrentType(table.GetType())) { Name = table.SchemaObjectName; } }
public override void ExplicitVisit(CreateFunctionStatement func) { if (IsSupportedForCurrentType(func.GetType())) { Name = func.Name; } }
public override void ExplicitVisit(AlterViewStatement view) { if (IsSupportedForCurrentType(view.GetType())) { Name = view.SchemaObjectName; } }
public override void ExplicitVisit(AlterIndexStatement index) { if (IsSupportedForCurrentType(index.GetType())) { Name = index.Name; } }
protected override IList <SqlRuleProblem> ElicitProblems(TSqlFragment fragment, RuleDescriptor ruleDescriptor, string elementName, TSqlObject modelElement) { var visitor = new HintsVisitor(); fragment.Accept(visitor); return(this.CreateProblemsAsError(ruleDescriptor, elementName, modelElement, visitor.Hints)); }
private static string ScriptFragment(SqlScriptGenerator sg, TSqlFragment fragment) { string resultString; sg.GenerateScript(fragment, out resultString); return(resultString); }
//Script formater only for parsing the query public string SQLScriptFormater(string sqlScript, bool onlyParse) { try { string strFormattedSQL = string.Empty; using (TextReader rdr = new StringReader(sqlScript)) { TSql130Parser parser = new TSql130Parser(true); IList <ParseError> errors = null; TSqlFragment tree = parser.Parse(rdr, out errors); if (errors.Count > 0) { foreach (ParseError err in errors) { strFormattedSQL = strFormattedSQL + err.Message + "\r\n"; } return(strFormattedSQL); } else { return("true"); } } } catch (Exception) { throw; } }
private void ChangeNewDatabaseLocation(DeploymentPlanContributorContext context, string databasePath, string logPath) { DeploymentStep nextStep = context.PlanHandle.Head; // Loop through all steps in the deployment plan bool finished = false; while (nextStep != null && !finished) { // Increment the step pointer, saving both the current and next steps DeploymentStep currentStep = nextStep; // Only interrogate up to BeginPreDeploymentScriptStep - setvars must be done before that if (currentStep is BeginPreDeploymentScriptStep) { finished = true; break; } SqlCreateDatabaseStep createDbStep = currentStep as SqlCreateDatabaseStep; if (createDbStep != null) { TSqlFragment fragment = createDbStep.Script; CreateDatabaseStatementVisitor visitor = new CreateDatabaseStatementVisitor(databasePath, logPath); fragment.Accept(visitor); finished = true; } nextStep = currentStep.Next; } }
public static void ParseSQL() { var sql = @"select AreaId = A.mcw_areaId, SurrogateKey = A.AreaKey, Code = S.statecode, Name = S.statename From CRM.dim_Area as A inner join CRM.dim_AreaState as S ON A.statecode = S.statecode ; DELET blogs SET url = 'aaa' where url='dasfds'"; //@"select p.firstname, p.lastname, p.custid FROM persons as p ; //SELECT id, name FROM companies; //select s.test from (select 'hello' as test) as s; "; TSqlParser parser = new TSql120Parser(true); IList <ParseError> parseErrors; var tReader = new StringReader(sql); TSqlFragment sqlFragment = parser.Parse(tReader, out parseErrors); var queryTokens = parser.GetTokenStream(tReader, out parseErrors); if (parseErrors.Count > 0) { Console.WriteLine("Errors:"); } parseErrors.Select(e => e.Message.Indent(2)).ToList().ForEach(Console.WriteLine); OwnVisitor visitor = new OwnVisitor(); sqlFragment.Accept(visitor); // sqlFragment.AcceptChildren(visitor); Console.WriteLine("Done."); Console.ReadKey(); }
public static IList <CreateTableStatement> VisitCreateTableStatements(TSqlFragment fragment) { TSqlSelectVisitor visitor = new TSqlSelectVisitor(); fragment.Accept(visitor); return(visitor.CreateTableStatements); }
static void Main(string[] args) { TextReader txtRdr = new StringReader(@"select AreaId = A.mcw_areaId, SurrogateKey = A.AreaKey, Code = S.statecode, Name = S.statename From CRM.dim_Area as A inner join CRM.dim_AreaState as S ON A.statecode = S.statecode ; DELET FROM blogs where url='dasfds'"); //TextReader txtRdr = new StreamReader("myscriptfile.sql"); TSql120Parser parser = new TSql120Parser(true); IList <ParseError> errors; TSqlFragment sqlFragment = parser.Parse(txtRdr, out errors); foreach (var err in errors) { Console.WriteLine(err.Message); } SQLVisitor myVisitor = new SQLVisitor(); sqlFragment.Accept(myVisitor); myVisitor.DumpStatistics(); ParseSQL(); Console.ReadKey(); }
public static IList <ProcedureParameter> VisitProcedureParameters(TSqlFragment fragment) { TSqlSelectVisitor visitor = new TSqlSelectVisitor(); fragment.Accept(visitor); return(visitor.ProcedureParameters); }
/// <summary> /// Checks if an object is: /// - Named /// - Starts with a letter or digit. This filters our parameters starting with '@', but may filter out other /// objects you wish to test for. This is where you would extend the logic for more advanced cases /// - The first letter is not uppercase. /// </summary> private void CheckIfCapitalized(TSqlObject tSqlObject, List <SqlRuleProblem> problems) { ObjectIdentifier name = tSqlObject.Name; if (name != null && name.HasName && name.Parts.Count > 0) // This check is equivalent to name.HasHame, including in case you don't trust the framework and want to verify yourself { string actualName = name.Parts[name.Parts.Count - 1]; if (!string.IsNullOrEmpty(actualName) && Char.IsLetterOrDigit(actualName[0]) && !Char.IsUpper(actualName[0])) { string description = string.Format(CultureInfo.CurrentCulture, RuleResources.CapitalizedNames_ProblemDescription, _model.DisplayServices.GetElementName(tSqlObject, ElementNameStyle.EscapedFullyQualifiedName)); // Name fragment would have more precise location information than the overall object. // This can be null, in which case the object's position will be used. // note that the current implementation does not work for non-top level types as it // relies on the TSqlModelUtils.TryGetFragmentForAnalysis() method which doesn't support these. TSqlFragment nameFragment = TsqlScriptDomUtils.LookupSchemaObjectName(tSqlObject); problems.Add(new SqlRuleProblem(description, tSqlObject, nameFragment)); } } }
public static string GenerateTSql(TSqlFragment script) { var generator = new Sql130ScriptGenerator(Settings.SavedSettings.Get().GeneratorOptions); var builder = new StringBuilder(); generator.GenerateScript(script, new StringWriter(builder)); return builder.ToString(); }
public static string GetFragmentType(TSqlFragment Statement) { String Type = Statement.ToString(); String[] TypeSplit = Type.Split('.'); String StmtType = TypeSplit[TypeSplit.Length - 1]; return (StmtType); }
protected override IList <SqlRuleProblem> ElicitProblems(TSqlFragment fragment, RuleDescriptor ruleDescriptor, string elementName, TSqlObject modelElement) { var sb = new StringBuilder(); foreach (var scriptTokenStreamFragment in fragment.ScriptTokenStream) { sb.Append(scriptTokenStreamFragment.Text); } var fullScript = sb.ToString(); var isHeaderPresent = true; foreach (var knownHeaderItem in this.KnownHeaderItems) { if (fullScript.IndexOf(knownHeaderItem, StringComparison.OrdinalIgnoreCase) == -1) { isHeaderPresent = false; } } if (!isHeaderPresent) { return(this.CreateProblemsAsError(ruleDescriptor, elementName, modelElement, new List <TSqlFragment> { fragment })); } return(null); }
public string PrepareScript(string script, out IList <ParseError> errors) { if (MetadataService.CurrentDatabase == null) { throw new InvalidOperationException("Current database is not defined!"); } TSqlFragment fragment = Parser.Parse(new StringReader(script), out errors); if (errors.Count > 0) { return(script); } ScriptNode result = new ScriptNode() { InfoBase = MetadataService.CurrentDatabase }; SyntaxTreeVisitor visitor = new SyntaxTreeVisitor(MetadataService); visitor.Visit(fragment, result); Generator.GenerateScript(fragment, out string sql); return(sql); }
private void SaveScriptSourceCode() { IScriptingService scripting = Services.GetService <IScriptingService>(); TSqlFragment syntaxTree = scripting.ParseScript(ScriptCode, out IList <ParseError> errors); if (errors.Count > 0) { ShowParseErrors(errors); throw new InvalidOperationException("Saving script failed: incorrect syntax."); } ScriptingController controller = Services.GetService <ScriptingController>(); string catalogName = controller.GetScriptsCatalogName(MyServer, MyDatabase, ScriptType); if (controller.ScriptFileExists(catalogName, Name)) { controller.SaveScriptFile(catalogName, Name, ScriptCode); } else { if (controller.GetScriptTreeNodeByName(MyServer, MyDatabase, ScriptType, Name) != null) { throw new InvalidOperationException($"Script node \"{Name}\" already exists!"); } controller.SaveScriptFile(catalogName, Name, ScriptCode); } MainWindowViewModel mainWindow = Services.GetService <MainWindowViewModel>(); TreeNodeViewModel treeNode = mainWindow.GetTreeNodeByPayload(mainWindow.MainTreeRegion.TreeNodes, this); if (treeNode == null) { controller.CreateScriptTreeNode(this); } }
public SubroutineDataType(string name, TSqlFragment sqlFragment, IEnumerable <Parameter> parameters) { _name = name; _sqlFragment = sqlFragment; _parameters = parameters; _parameterDictionaryLazy = new Lazy <Dictionary <string, Parameter> >(() => _parameters.ToDictionary(it => it.Name.ToLower())); }
public IList <ParseError> TryGetTSqlFragment(out TSqlFragment fragment) { IList <ParseError> errors; if (this.tsqlFragment != null) { fragment = this.tsqlFragment; return(null); } errors = null; fragment = null; lock (this.lockObject) { if (this.tsqlFragment == null) { var parser = new TSql120Parser(initialQuotedIdentifiers: false); using (StringReader reader = new StringReader(File.ReadAllText(TargetUri.LocalPath))) { this.tsqlFragment = parser.Parse(reader, out errors); } } } fragment = this.tsqlFragment; return(errors); }
private IEnumerable <PartitionedColumn> CollectFromTableReference(SqlRuleExecutionContext ruleExecutionContext, TSqlFragment fragment, TableReference tableReference) { if (!(tableReference is NamedTableReference namedTableReference)) { return(new List <PartitionedColumn>()); } // Resolve the table from its name. var table = ResolveTable(ruleExecutionContext.SchemaModel, namedTableReference.SchemaObject); if (table == null) { return(new List <PartitionedColumn>()); } // In the tabe object, find all columns that are a partition column, and save them. var partitionColumns = table.GetReferenced(Table.PartitionColumn, DacQueryScopes.All); var allowedTableNames = new HashSet <string>(); allowedTableNames.Add(namedTableReference.SchemaObject.BaseIdentifier.Value); if (namedTableReference.Alias != null) { allowedTableNames.Add(namedTableReference.Alias.Value); } return(partitionColumns .Select(x => new PartitionedColumn( allowedTableNames, x.Name.Parts.Last(), fragment))); }
protected override void DisplayScript(TSqlFragment rootFragment) { TreeNode rootTreeNode = CreateNewTreeNodeForFragment(rootFragment); tvwFragmentTree.Nodes.Add(rootTreeNode); AddTreeNodeChildren(rootTreeNode); ExpandTreeNode(rootTreeNode); }
public List<TSqlFragment> GetFragmentChildren(TSqlFragment parentFragment) { oVisitorAll visitor = new oVisitorAll(); parentFragment.AcceptChildren(visitor); return visitor.Fragments; }
private TreeNode CreateNewTreeNodeForFragment(TSqlFragment fragment) { TreeNode tn = new TreeNode(); tn.Text = ScriptParser.GetFragmentTypeName(fragment); tn.Tag = fragment; return tn; }
protected override void DisplayScript(TSqlFragment rootFragment) { List<oIssue> issuesFound = new List<oIssue>(); oSQLStandardsChecker sqlStandardsChecker = new oSQLStandardsChecker(ScriptParser, rootFragment); issuesFound.AddRange(sqlStandardsChecker.CheckProcedureName()); issuesFound.AddRange(sqlStandardsChecker.CheckProcedureSchemaPrefixes()); issuesFound.AddRange(sqlStandardsChecker.CheckTableVariableCharacterColumnCollations()); issuesFound.AddRange(sqlStandardsChecker.CheckTemporaryTableCharacterColumnCollations()); DisplayIssues(issuesFound); }
public string GetFragmentSQL(TSqlFragment fragment) { StringBuilder sql = new StringBuilder(); if (fragment.FirstTokenIndex != -1) { for (int counter = fragment.FirstTokenIndex; counter <= fragment.LastTokenIndex; counter++) { sql.Append(fragment.ScriptTokenStream[counter].Text); //sql.Append(" "); } } return sql.ToString().Trim(); }
public List<Replacements> GetReplacements(List<QuerySpecification> queries) { foreach (var select in queries) { _currentFragment = select; if (select.WhereClause != null) { Search(select.WhereClause.SearchCondition); } if (select.FromClause != null) { foreach (var reference in select.FromClause.TableReferences) { if (reference is QualifiedJoin) { var join = reference as QualifiedJoin; Search(join.SearchCondition); } } } } var distinctor = new Dictionary<string, Replacements>(); foreach (var p in _replacementsToMake) { distinctor[p.Original + ":" + p.OriginalLength + ":" + p.OriginalOffset] = p; } //remove duplicates _replacementsToMake = distinctor.Values.ToList(); for (var i = 0; i < _replacementsToMake.Count; i++) { var rep = _replacementsToMake[i]; if (!rep.Original.Contains("\r\n") && rep.Replacement.Contains("\r\n")) { rep.Replacement = rep.Replacement.Replace("\r\n", ""); _replacementsToMake[i] = rep; } } return _replacementsToMake; }
public List<TSqlFragment> GetFragmentChildren(TSqlFragment parentFragment, oVisitorBase visitor, bool recurseChildren = false) { parentFragment.AcceptChildren(visitor); List<TSqlFragment> children = visitor.Fragments; List<TSqlFragment> grandChildren; if (recurseChildren) { foreach (TSqlFragment f in children) { grandChildren = GetFragmentChildren(f, visitor, recurseChildren); if ((grandChildren != null) && (grandChildren.Count > 0)) children.AddRange(grandChildren); } } return children; }
public override void ExplicitVisit(AlterProcedureStatement proc) { if (IsSupportedForCurrentType(proc.GetType()) && proc.ProcedureReference != null) { Name = proc.ProcedureReference.Name; } }
/// <summary> /// Checks if a fragment represents the body of a subroutine, a view, /// or a trigger. These have similar characteristics, for instance the ability to /// include select statements against tables. /// </summary> /// <param name="fragment"> /// <see cref="TSqlFragment"/> representing part of a TSQL object definition /// </param> /// <returns>true if this is a subroutine, a view or a trigger body</returns> public static bool IsSubroutineViewOrTrigger(TSqlFragment fragment) { return fragment is ProcedureStatementBodyBase || fragment is ViewStatementBody || fragment is TriggerStatementBody; }
public void SendFeedBack(int errorNum, TSqlFragment errorFrg) { if (errorNum != _iRule) return; ResourceManager rm = Resources.ResourceManager; string lookup = "TSQLSmell_RuleName" + errorNum.ToString("D2"); string Out = rm.GetString(lookup); _problems.Add(new SqlRuleProblem(Out, _modelElement, errorFrg)); }
//void ProcessSelectElements( public void ProcessTsqlFragment(TSqlFragment fragment) { String stmtType = FragmentTypeParser.GetFragmentType(fragment); //Console.WriteLine(StmtType); switch (stmtType) { case "DeclareCursorStatement": _cursorProcessor.ProcessCursorStatement((DeclareCursorStatement) fragment); break; case "BeginEndBlockStatement": _beginEndBlockProcessor.ProcessBeginEndBlockStatement((BeginEndBlockStatement) fragment); break; case "CreateFunctionStatement": case "AlterFunctionStatement": _functionStatementBodyProcessor.ProcessFunctionStatementBody((FunctionStatementBody) fragment); break; case "SelectFunctionReturnType": _selectFunctionReturnTypeProcessor.ProcessSelectFunctionReturnType((SelectFunctionReturnType) fragment); return; case "ScalarFunctionReturnType": _scalarFunctionReturnTypeProcessor.ProcessScalarFunctionReturnType((ScalarFunctionReturnType) fragment); break; case "SetTransactionIsolationLevelStatement": _setTransactionIsolationLevelProcessor.ProcessSetTransactionIolationLevelStatement((SetTransactionIsolationLevelStatement) fragment); break; case "WhileStatement": _whileProcessor.ProcessWhileStatement((WhileStatement) fragment); break; case "InsertStatement": InsertProcessor.Process((InsertStatement) fragment); break; case "SelectStatement": _selectStatementProcessor.Process((SelectStatement) fragment, "RG", true); break; case "SetRowCountStatement": SendFeedBack(42, fragment); break; case "IfStatement": _ifStatementProcessor.ProcessIfStatement((IfStatement) fragment); break; case "PredicateSetStatement": _predicateSetProcessor.ProcessPredicateSetStatement((PredicateSetStatement) fragment); break; case "ExecuteStatement": ExecutableEntityProcessor.ProcessExecuteStatement((ExecuteStatement) fragment); break; case "SetIdentityInsertStatement": SendFeedBack(22, fragment); break; case "SetCommandStatement": _setProcessor.ProcessSetStatement((SetCommandStatement) fragment); break; case "CreateTableStatement": _createTableProcessor.ProcessCreateTable((CreateTableStatement) fragment); break; case "CreateProcedureStatement": case "AlterProcedureStatement": ProcedureStatementBodyProcessor.ProcessProcedureStatementBody((ProcedureStatementBody) fragment); _assignmentList.Clear(); break; case "CreateViewStatement": case "AlterViewStatement": _viewStatementProcessor.ProcessViewStatementBody((ViewStatementBody) fragment); break; case "TSqlBatch": var batch = (TSqlBatch) fragment; foreach (TSqlStatement innerFragment in batch.Statements) { ProcessTsqlFragment(innerFragment); } break; case "TSqlScript": var script = (TSqlScript) fragment; foreach (TSqlBatch innerBatch in script.Batches) { ProcessTsqlFragment(innerBatch); } break; case "BooleanParenthesisExpression": var expression = (BooleanParenthesisExpression) fragment; ProcessTsqlFragment(expression.Expression); break; case "BooleanComparisonExpression": var bcExpression = (BooleanComparisonExpression) fragment; ProcessTsqlFragment(bcExpression.FirstExpression); ProcessTsqlFragment(bcExpression.SecondExpression); break; case "ScalarSubquery": var scalarSubquery = (ScalarSubquery) fragment; ProcessQueryExpression(scalarSubquery.QueryExpression, "RG"); break; case "ReturnStatement": _returnStatementProcessor.ProcessReturnStatement((ReturnStatement) fragment); break; case "IntegerLiteral": break; case "DeclareVariableStatement": _declareVariableProcessor.ProcessDeclareVariableStatement((DeclareVariableStatement) fragment); break; case "DeclareVariableElement": _declareVariableProcessor.ProcessDeclareVariableElement((DeclareVariableElement) fragment); break; case "PrintStatement": break; case "SqlDataTypeReference": _sqlDataTypeProcessor.ProcessSqlDataTypeReference((SqlDataTypeReference) fragment); break; case "DeclareTableVariableStatement": _tableVariableProcessor.ProcessTableVariableStatement((DeclareTableVariableStatement) fragment); break; case "TableValuedFunctionReturnType": _tableVariableProcessor.ProcessTableValuedFunctionReturnType((TableValuedFunctionReturnType) fragment); break; case "DeclareTableVariableBody": _tableVariableProcessor.ProcessTableVariableBody((DeclareTableVariableBody) fragment); break; case "VariableReference": //ProcessVariableReference((VariableReference)Fragment); break; case "ExistsPredicate": _tableVariableProcessor.ProcessExistsPredicate((ExistsPredicate) fragment); break; case "ColumnDefinition": _columnDefinitionProcessor.ProcessColumnDefinition((ColumnDefinition)fragment); break; } }
public WSqlUnknownStatement(TSqlFragment statement) { TokenStream = new List<TSqlParserToken>(statement.LastTokenIndex - statement.FirstTokenIndex + 1); for (var pos = statement.FirstTokenIndex; pos <= statement.LastTokenIndex; pos++) { TokenStream.Add(statement.ScriptTokenStream[pos]); } }
private static List<TableReference> FindTableReferences(TSqlFragment statement) { var nodeType = statement.ToString().Split(' ')[0]; var t = ScriptDomCode.GetType(nodeType, false, true); var tables = new List<TableReference>(); foreach (var p in t.GetProperties()) { var value = TryGetValue(p, statement); if(value == null) continue; if (value is List<TableReference>) { tables.AddRange(value as List<TableReference>); continue; } if (value is TableReference) { tables.Add(value as TableReference); continue; } //don't move this before is List<TableReference> as they are also TSqlFragments which causes hilarity if (value is IEnumerable<TSqlFragment>) { foreach (var fragment in value as IEnumerable<TSqlFragment>) { tables.AddRange(FindTableReferences(fragment)); } continue; } if (value is TSqlFragment) { tables.AddRange(FindTableReferences(value as TSqlFragment)); continue; } } return tables; }
internal void UpdateTokenInfo(TSqlFragment fragment) { if (fragment == null) return; UpdateTokenInfo(fragment.FirstTokenIndex, fragment.LastTokenIndex); }
private static IEnumerable<QuerySpecification> SearchChildren(TSqlFragment fragment) { if (fragment is InsertStatement) { return SearchChildren((fragment as InsertStatement).InsertSpecification.InsertSource); } if (fragment is SelectInsertSource) { return SearchChildren((fragment as SelectInsertSource).Select); } var children = new List<QuerySpecification>(); if (fragment is BinaryQueryExpression) { var expression = fragment as BinaryQueryExpression; children.AddRange(SearchChildren(expression.FirstQueryExpression)); children.AddRange(SearchChildren(expression.SecondQueryExpression)); } if (fragment is QueryParenthesisExpression) { var expression = fragment as QueryParenthesisExpression; children.AddRange(SearchChildren(expression.QueryExpression)); } if (fragment is BooleanBinaryExpression) { var expression = fragment as BooleanBinaryExpression; children.AddRange(SearchChildren(expression.FirstExpression)); children.AddRange(SearchChildren(expression.SecondExpression)); } if (fragment is BooleanComparisonExpression) { var expression = fragment as BooleanComparisonExpression; children.AddRange(SearchChildren(expression.FirstExpression)); children.AddRange(SearchChildren(expression.SecondExpression)); } if (fragment is ScalarSubquery) { var query = fragment as ScalarSubquery; children.AddRange(SearchChildren(query.QueryExpression)); } if (fragment is QuerySpecification) { var spec = fragment as QuerySpecification; children.Add(spec); foreach (var select in spec.SelectElements) { children.AddRange(SearchChildren(select)); } if (spec.WhereClause != null) { children.AddRange(SearchChildren(spec.WhereClause.SearchCondition)); } if (spec.FromClause != null) { foreach (var table in spec.FromClause.TableReferences) { children.AddRange(SearchChildren(table)); } } } if (fragment is SelectStatement) { if ((fragment as SelectStatement).QueryExpression != null) { if ((fragment as SelectStatement).QueryExpression is BinaryQueryExpression) { var expression = (fragment as SelectStatement).QueryExpression as BinaryQueryExpression; children.AddRange(SearchChildren(expression.FirstQueryExpression)); children.AddRange(SearchChildren(expression.SecondQueryExpression)); } } if ((fragment as SelectStatement).QueryExpression != null) { if ((fragment as SelectStatement).QueryExpression is QuerySpecification) { var expression = (fragment as SelectStatement).QueryExpression as QuerySpecification; children.Add(expression); } } } return children; }
public string GetFragmentTypeName(TSqlFragment fragment) { return fragment.GetType().Name; }
private TSqlFragment GetTag(TSqlFragment sqlFragment) { return sqlFragment; }
protected IList<TSqlParserToken> GetTokens(TSqlFragment fragment) { return _generator.GenerateTokens(fragment); }
protected string GenerateScript(TSqlFragment fragment) { string script; _generator.GenerateScript(fragment, out script); return script; }
protected IList<TSqlParserToken> GetTokens(TSqlFragment fragment) { var generator = new Sql120ScriptGenerator(SavedSettings.Get().GeneratorOptions); return generator.GenerateTokens(fragment); }