private void ParseSqlCommand(DbAccessorContext context)
        {
            SqlCommand cmd = new SqlCommand();
            cmd.DbAccessor = context.DbAccessor;
            foreach (DbParameter p in context.DbCommand.Parameters)
            {
                cmd.Parameters.Add(p);
            }
            cmd.Text = context.DbCommand.CommandText;

            IList<ISqlCommandParser> parsers = new List<ISqlCommandParser>();
            parsers.Add(new NormalParameterParser());
            parsers.Add(new ValueParameterParser());
            parsers.Add(new EnvValParameterParser(true));
            parsers.Add(new EnvValParameterParser(false));
            parsers.Add(new DynamicClauseParser());

            foreach (var p in parsers)
            {
                p.Parse(cmd);
            }

            context.DbCommand.CommandText = cmd.Text;

        }
        private void ParseSqlCommand(DbAccessorContext context)
        {
            SqlCommand cmd = new SqlCommand();

            cmd.DbAccessor = context.DbAccessor;
            foreach (DbParameter p in context.DbCommand.Parameters)
            {
                cmd.Parameters.Add(p);
            }
            cmd.Text = context.DbCommand.CommandText;

            IList <ISqlCommandParser> parsers = new List <ISqlCommandParser>();

            parsers.Add(new NormalParameterParser());
            parsers.Add(new ValueParameterParser());
            parsers.Add(new EnvValParameterParser(true));
            parsers.Add(new EnvValParameterParser(false));
            parsers.Add(new DynamicClauseParser());

            foreach (var p in parsers)
            {
                p.Parse(cmd);
            }

            context.DbCommand.CommandText = cmd.Text;
        }
        public void HandleExecute(DbAccessorContext context)
        {
            RetrieveSqlCommand(context);

            ParseParameterName(context);

            ParseReplacement(context);

            ParseDynamicClause(context);
        }
        private void ParseParameterName(DbAccessorContext context)
        {
            SqlCommand cmd = new SqlCommand();

            cmd.DbAccessor = context.DbAccessor;
            cmd.Text       = context.DbCommand.CommandText;
            new ParameterNameParser().Parse(cmd);

            context.DbCommand.CommandText = cmd.Text;
        }
        private void ParseParameterName(DbAccessorContext context)
        {
            SqlCommand cmd = new SqlCommand();

            cmd.DbAccessor = context.DbAccessor;
            cmd.Text = context.DbCommand.CommandText;
            new ParameterNameParser().Parse(cmd);

            context.DbCommand.CommandText = cmd.Text;
        }
        public void HandleExecute(DbAccessorContext context)
        {
            RetrieveSqlCommand(context);

            ParseParameterName(context);

            ParseReplacement(context);

            ParseDynamicClause(context);

        }
 public void RetrieveSqlCommand(DbAccessorContext context)
 {
     if (!context.DbCommand.CommandText.Trim().Contains(" "))
     {
         SqlCommand sqlCmd = SqlCommandRepository.Instance.GetSqlCommand(context.DbCommand.CommandText);
         if (sqlCmd != null)
         {
             context.DbCommand.CommandText = sqlCmd.Text;
         }
     }
 }
        private void RetrieveSqlCommand(DbAccessorContext context)
        {
            if (!context.DbCommand.CommandText.Trim().Contains(" "))
            {
                SqlCommand sqlCmd = SqlCommandRepository.Instance.GetSqlCommand(context.DbCommand.CommandText);
                if (sqlCmd != null)
                {
                    context.DbCommand.CommandText = sqlCmd.Text;
                }
            }

        }
        private void ParseReplacement(DbAccessorContext context)
        {
            SqlCommand cmd = new SqlCommand();

            cmd.DbAccessor = context.DbAccessor;
            foreach (DbParameter p in context.DbCommand.Parameters)
            {
                cmd.Parameters.Add(p);
            }

            cmd.Text = context.DbCommand.CommandText;
            new ReplacementParser().Parse(cmd);

            context.DbCommand.CommandText = cmd.Text;
        }
        private void ParseReplacement(DbAccessorContext context)
        {
            SqlCommand cmd = new SqlCommand();

            cmd.DbAccessor = context.DbAccessor;
            foreach (DbParameter p in context.DbCommand.Parameters)
            {
                cmd.Parameters.Add(p);
            }

            cmd.Text = context.DbCommand.CommandText;
            new ReplacementParser().Parse(cmd);

            context.DbCommand.CommandText = cmd.Text;
        }
Beispiel #11
0
        private void ParseDynamicClause(DbAccessorContext context)
        {

            if (!DynamicClauseParser.IsCanParse(context.DbCommand.CommandText)) return;

            SqlCommand cmd = new SqlCommand();

            cmd.DbAccessor = context.DbAccessor;
            cmd.Text = context.DbCommand.CommandText;
            foreach (DbParameter p in context.DbCommand.Parameters)
            {
                cmd.Parameters.Add(p);
            }
            var parser = new DynamicClauseParser();
            cmd = parser.Parse(cmd);
            context.DbCommand.CommandText = cmd.Text;
        }
        private void RemoveUnnecessary(DbAccessorContext context)
        {
            var dbParameters = context.DbCommand.Parameters;
            IList<string> unnecessaryParameterNames = new List<string>();
            foreach (DbParameter p in dbParameters)
            {
                if (!SqlUtil.ContainsParameterName(context.DbCommand.CommandText,p.ParameterName))
                {
                    unnecessaryParameterNames.Add(p.ParameterName);
                }
            }

            foreach (string unnecessaryParameterName in unnecessaryParameterNames)
            {
                dbParameters.RemoveAt(unnecessaryParameterName);
            }
        }
        public void RemoveUnnecessary(DbAccessorContext context)
        {
            var            dbParameters = context.DbCommand.Parameters;
            IList <string> unnecessaryParameterNames = new List <string>();

            foreach (DbParameter p in dbParameters)
            {
                if (!SqlUtil.ContainsParameterName(context.DbCommand.CommandText, p.ParameterName))
                {
                    unnecessaryParameterNames.Add(p.ParameterName);
                }
            }

            foreach (string unnecessaryParameterName in unnecessaryParameterNames)
            {
                dbParameters.RemoveAt(unnecessaryParameterName);
            }
        }
        public void HandleDBNull(DbAccessorContext context)
        {
            var dbParameters = context.DbCommand.Parameters;

            if (dbParameters != null)
            {
                foreach (DbParameter p in dbParameters)
                {
                    if (p != null)
                    {
                        // 检查未分配值的输出参数,将其分配以DBNull.Value.
                        if ((p.Direction == ParameterDirection.InputOutput || p.Direction == ParameterDirection.Input) &&
                            (p.Value == null))
                        {
                            p.Value = DBNull.Value;
                        }
                    }
                }
            }
        }
        private void ParseDynamicClause(DbAccessorContext context)
        {
            if (!DynamicClauseParser.IsCanParse(context.DbCommand.CommandText))
            {
                return;
            }

            SqlCommand cmd = new SqlCommand();

            cmd.DbAccessor = context.DbAccessor;
            cmd.Text       = context.DbCommand.CommandText;
            foreach (DbParameter p in context.DbCommand.Parameters)
            {
                cmd.Parameters.Add(p);
            }
            var parser = new DynamicClauseParser();

            cmd = parser.Parse(cmd);
            context.DbCommand.CommandText = cmd.Text;
        }
        private void HandleDBNull(DbAccessorContext context)
        {
            var dbParameters = context.DbCommand.Parameters;

            if (dbParameters != null)
            {
                foreach (DbParameter p in dbParameters)
                {
                    if (p != null)
                    {
                        // 检查未分配值的输出参数,将其分配以DBNull.Value. 
                        if ((p.Direction == ParameterDirection.InputOutput || p.Direction == ParameterDirection.Input) &&
                            (p.Value == null))
                        {
                            p.Value = DBNull.Value;
                        }
                    }
                }

            }
        }
        public void HandleExecute(DbAccessorContext context)
        {
            RetrieveSqlCommand(context);

            ParseSqlCommand(context);
        }
 private void RetrieveSqlCommand(DbAccessorContext context)
 {
     context.DbCommand.CommandText = SqlUtil.RetrieveSql(context.DbCommand.CommandText);
 }
        public void HandleExecute(DbAccessorContext context)
        {
            RetrieveSqlCommand(context);

            ParseSqlCommand(context);
        }
 public void HandleExecute(DbAccessorContext context)
 {
     RemoveUnnecessary(context);
     HandleDBNull(context);
 }
Beispiel #21
0
 public void HandleExecute(DbAccessorContext context)
 {
     PrintSqlByConsole(context);
 }
Beispiel #22
0
 public void PrintSqlByConsole(DbAccessorContext context)
 {
     Console.WriteLine("--<<<------------------------------------------------------------------------------------------------------");
     Console.WriteLine(SqlUtil.GetSqlFromDbCommand(context.DbCommand));
     Console.WriteLine("------------------------------------------------------------------------------------------------------>>>--");
 }
 public void HandleExecute(DbAccessorContext context)
 {
     RemoveUnnecessary(context);
     HandleDBNull(context);
 }
 private void RetrieveSqlCommand(DbAccessorContext context)
 {
     context.DbCommand.CommandText = SqlUtil.RetrieveSql(context.DbCommand.CommandText);
 }