void ProcessComplexStatement(TSQLUnknownStatement complexStatement, int update, ref bool started)
        {
            var tokens = complexStatement.Tokens;

            for (int i = 0; i < complexStatement.Tokens.Count; i++)
            {
                if (i == 1 && tokens[i].Type.ToString() == "Identifier" && (tokens[i - 1].Text.ToUpper() == "TABLE"))
                {
                    ProcessCreateTableStatement(complexStatement);
                }
                if (tokens[i].Type.ToString() == "Keyword" && (tokens[i].Text.ToUpper() == "UPDATE"))
                {
                    ProcessUpdateStatement(complexStatement, update, ref started);
                }
                if (tokens[i].Type.ToString() == "Keyword" && (tokens[i].Text.ToUpper() == "DELETE"))
                {
                    ProcessUpdateStatement(complexStatement, update, ref started);
                }
                if (tokens[i].Type.ToString() == "Keyword" && (tokens[i].Text.ToUpper() == "INSERT"))
                {
                    ProcessUpdateStatement(complexStatement, update, ref started);
                }
                if (tokens[i].Type.ToString() == "Identifier" && (tokens[i].Text.ToUpper() == "REPLACE"))
                {
                    ProcessUpdateStatement(complexStatement, update, ref started);
                }
            }
        }
        public TSQLUnknownStatement Parse(ITSQLTokenizer tokenizer)
        {
            TSQLUnknownStatement statement = new TSQLUnknownStatement();

            statement.Tokens.Add(tokenizer.Current);

            while (
                tokenizer.MoveNext() &&
                !(
                    tokenizer.Current is TSQLCharacter &&
                    tokenizer.Current.AsCharacter.Character == TSQLCharacters.Semicolon
                    ))
            {
                statement.Tokens.Add(tokenizer.Current);
            }

            if (
                tokenizer.Current != null &&
                tokenizer.Current is TSQLCharacter &&
                tokenizer.Current.AsCharacter.Character == TSQLCharacters.Semicolon)
            {
                statement.Tokens.Add(tokenizer.Current);
            }

            return(statement);
        }
        void ProcessCreateTableStatement(TSQLUnknownStatement complexStatement)
        {
            var recordset = new DataTable();

            recordset.Columns.Add("records_affected", typeof(int));
            recordset.Rows.Add(AdvancedRecordset.ExecuteNonQuery(AdvancedRecordset.ReturnSql(complexStatement.Tokens)));
            var outputName = Outputs.FirstOrDefault(e => e.MappedFrom == "records_affected").MappedTo;

            AdvancedRecordset.ApplyScalarResultToEnvironment(outputName, int.Parse(recordset.Rows[0].ItemArray[0].ToString()));
        }
        void ProcessUpdateStatement(TSQLUnknownStatement complexStatement, int update, ref bool started)
        {
            var tokens = complexStatement.Tokens;
            var outputRecordsetName = "";

            for (int i = 0; i < complexStatement.Tokens.Count; i++)
            {
                if (i == 1 && tokens[i].Type.ToString() == "Identifier" && (tokens[i - 1].Text.ToUpper() == "UPDATE"))
                {
                    outputRecordsetName = tokens[i].Text;
                }
                if (tokens[i].Type.ToString() == "Keyword" && (tokens[i].Text.ToUpper() == "INSERT"))
                {
                    outputRecordsetName = tokens[i + 2].Text;
                }
                if (tokens[i].Type.ToString() == "Identifier" && (tokens[i].Text.ToUpper() == "REPLACE"))
                {
                    outputRecordsetName = tokens[i + 2].Text;
                }
                if (tokens[i].Type.ToString() == "Keyword" && (tokens[i].Text.ToUpper() == "DELETE"))
                {
                    outputRecordsetName = tokens[i + 2].Text;
                }
            }

            var sqlQuery = AdvancedRecordset.UpdateSqlWithHashCodes(complexStatement);

            var recordset = new DataTable();

            recordset.Columns.Add("records_affected", typeof(int));
            recordset.Rows.Add(AdvancedRecordset.ExecuteNonQuery(sqlQuery));
            object sumObject;

            sumObject         = recordset.Compute("Sum(records_affected)", "");
            _recordsAffected += Convert.ToInt16(sumObject.ToString());
            var mapping = Outputs.FirstOrDefault(e => e.MappedFrom == "records_affected");


            if (mapping != null)
            {
                AdvancedRecordset.ApplyScalarResultToEnvironment(mapping.MappedTo, _recordsAffected);
            }
            var results = AdvancedRecordset.ExecuteQuery("SELECT * FROM " + AdvancedRecordset.HashedRecSets.FirstOrDefault(x => x.recSet == outputRecordsetName).hashCode);

            foreach (DataTable dt in results.Tables)
            {
                AdvancedRecordset.ApplyResultToEnvironment(outputRecordsetName, Outputs, dt.Rows.Cast <DataRow>().ToList(), true, update, ref started);
            }
        }
        public TSQLUnknownStatement Parse(TSQLTokenizer tokenizer)
        {
            TSQLUnknownStatement statement = new TSQLUnknownStatement();

            while (
                tokenizer.Read() &&
                !(
                    tokenizer.Current is TSQLCharacter &&
                    tokenizer.Current.AsCharacter.Character == TSQLCharacters.Semicolon
                ))
            {
                statement.Tokens.Add(tokenizer.Current);
            }

            if (
                tokenizer.Current != null &&
                tokenizer.Current is TSQLCharacter &&
                tokenizer.Current.AsCharacter.Character == TSQLCharacters.Semicolon)
            {
                statement.Tokens.Add(tokenizer.Current);
            }

            return statement;
        }
 /// <summary>
 ///
 /// </summary>
 /// <param name="statement"></param>
 /// <returns></returns>
 private static bool StatementContainsGo(TSQLUnknownStatement statement)
 => statement.Tokens.Any(token => TokenContainsGo(token));