একটি এসকিউএলকম্যান্ড অবজেক্ট থেকে উত্পন্ন এসকিউএল বিবৃতি পাবেন?

Question

আমার কাছে নিম্নলিখিত কোড রয়েছে:

Using cmd As SqlCommand = Connection.CreateCommand
    cmd.CommandText = "UPDATE someTable SET Value = @Value"
    cmd.CommandText &= " WHERE Id = @Id"
    cmd.Parameters.AddWithValue("@Id", 1234)
    cmd.Parameters.AddWithValue("@Value", "myValue")
    cmd.ExecuteNonQuery
End Using

আমি অবাক হয়েছি যদি স্ট্রিং হিসাবে চূড়ান্ত এসকিউএল স্ট্যাটেনশন পাওয়ার কোনও উপায় থাকে, যা দেখতে এটির মতো হওয়া উচিত:

UPDATE someTable SET Value = "myValue" WHERE Id = 1234

যদি কেউ আশ্চর্য হয় তবে আমি কেন এটি করব:

• লগিং (ব্যর্থ) বিবৃতি জন্য
• পরীক্ষার উদ্দেশ্যে এটি এন্টারপ্রাইজ ম্যানেজারের কাছে অনুলিপি করে আটকানোর সম্ভাবনা থাকার কারণে

Comments

কেন আপনি উত্তর স্ট্যাকওভারফ্লো.com/a/265261/206730 চিহ্নিত করেছেন যদি বিভিন্ন ডেটাটাইপস, এসকিউএল ইনজেকশন, প্যারামিটারের নামগুলির অনুরূপ (সমস্যাটি প্রতিস্থাপন করুন) এর মধ্যে পার্থক্য না করে ...?

— কিকিনেট

@ কিকিনেট আমি শপথ করতে পারতাম, আমি চেষ্টা করেছিলাম তবে তা আমাকে দেয়নি। এখন এটা কাজ করছে. এই জন্য আপনাকে ধন্যবাদ.

— ডামি

আপনি যদি চালিত এসকিউএল সঠিকভাবে উত্পন্ন করতে চান তবে টিডিএসপারসার.টিডিএসএক্সেকিউটআরপিসি ( github.com/Mic Microsoft/ references स्त्रोत / ব্লব / মাস্টার / সিস্টেমে.ডাটা/… ) দেখুন এবং কিছুটা ভয় পান।

— ররি

Answer 1

নিখুঁত না হলেও, এখানে টিএসকিউএল-এর জন্য আমি নক করলাম এমন কিছু এখানে - অন্য স্বাদের জন্য সহজেই চিহ্নিত করা যেতে পারে ... অন্য কিছু না হলে এটি আপনাকে আপনার নিজস্ব উন্নতির জন্য একটি সূচনা পয়েন্ট দেবে :)

এটি এসএসএমএসে "চালিত সঞ্চিত পদ্ধতি" ব্যবহারের অনুরূপ ডেটা ধরণের এবং আউটপুট প্যারামিটার ইত্যাদির উপর ঠিকঠাক কাজ করে। আমরা বেশিরভাগ এসপি ব্যবহার করেছি তাই "পাঠ্য" কমান্ড প্যারামিটার ইত্যাদির জন্য অ্যাকাউন্ট করে না

    public static String ParameterValueForSQL(this SqlParameter sp)
    {
        String retval = "";

        switch (sp.SqlDbType)
        {
            case SqlDbType.Char:
            case SqlDbType.NChar:
            case SqlDbType.NText:
            case SqlDbType.NVarChar:
            case SqlDbType.Text:
            case SqlDbType.Time:
            case SqlDbType.VarChar:
            case SqlDbType.Xml:
            case SqlDbType.Date:
            case SqlDbType.DateTime:
            case SqlDbType.DateTime2:
            case SqlDbType.DateTimeOffset:
                retval = "'" + sp.Value.ToString().Replace("'", "''") + "'";
                break;

            case SqlDbType.Bit:
                retval = (sp.Value.ToBooleanOrDefault(false)) ? "1" : "0";
                break;

            default:
                retval = sp.Value.ToString().Replace("'", "''");
                break;
        }

        return retval;
    }

    public static String CommandAsSql(this SqlCommand sc)
    {
        StringBuilder sql = new StringBuilder();
        Boolean FirstParam = true;

        sql.AppendLine("use " + sc.Connection.Database + ";");
        switch (sc.CommandType)
        {
            case CommandType.StoredProcedure:
                sql.AppendLine("declare @return_value int;");

                foreach (SqlParameter sp in sc.Parameters)
                {
                    if ((sp.Direction == ParameterDirection.InputOutput) || (sp.Direction == ParameterDirection.Output))
                    {
                        sql.Append("declare " + sp.ParameterName + "\t" + sp.SqlDbType.ToString() + "\t= ");

                        sql.AppendLine(((sp.Direction == ParameterDirection.Output) ? "null" : sp.ParameterValueForSQL()) + ";");

                    }
                }

                sql.AppendLine("exec [" + sc.CommandText + "]");

                foreach (SqlParameter sp in sc.Parameters)
                {
                    if (sp.Direction != ParameterDirection.ReturnValue)
                    {
                        sql.Append((FirstParam) ? "\t" : "\t, ");

                        if (FirstParam) FirstParam = false;

                        if (sp.Direction == ParameterDirection.Input)
                            sql.AppendLine(sp.ParameterName + " = " + sp.ParameterValueForSQL());
                        else

                            sql.AppendLine(sp.ParameterName + " = " + sp.ParameterName + " output");
                    }
                }
                sql.AppendLine(";");

                sql.AppendLine("select 'Return Value' = convert(varchar, @return_value);");

                foreach (SqlParameter sp in sc.Parameters)
                {
                    if ((sp.Direction == ParameterDirection.InputOutput) || (sp.Direction == ParameterDirection.Output))
                    {
                        sql.AppendLine("select '" + sp.ParameterName + "' = convert(varchar, " + sp.ParameterName + ");");
                    }
                }
                break;
            case CommandType.Text:
                sql.AppendLine(sc.CommandText);
                break;
        }

        return sql.ToString();
    }

এটি এই লাইন বরাবর আউটপুট উত্পন্ন করে ...

use dbMyDatabase;
declare @return_value int;
declare @OutTotalRows   BigInt  = null;
exec [spMyStoredProc]
    @InEmployeeID = 1000686
    , @InPageSize = 20
    , @InPage = 1
    , @OutTotalRows = @OutTotalRows output
;
select 'Return Value' = convert(varchar, @return_value);
select '@OutTotalRows' = convert(varchar, @OutTotalRows);

Comments

চমৎকার কাজটি এখানে সমস্যাটি সমাধান করার চেষ্টা করছে, একা চেষ্টা করার পক্ষে আপ-ভোট দিয়েছে।

— অ্যাডাম টলি

আপনার "টুবুলিয়ানআরডিফল্ট (মিথ্যা)" পদ্ধতিটি কী হবে?

— Benoittr

@ বেনোইত্র, আপনি ToBooleanOrDefaultএখানে একটি বাস্তবায়ন দেখতে পাচ্ছেন : প্রশ্ন # 3244850

— আলেকজান্ডার

ব্লাফ ক্ষেত্র বা বাইট অ্যারে সম্পর্কে @ ফ্ল্যাপার

— স্মিথ

কিছু ছোটখাটো সামঞ্জস্য তৈরি করে টেবিলের মান পরামিতি যুক্ত করা। এটি সবই গিটহাব এবং একটি নেট স্ট্যান্ডার্ড 2.0 নুয়েট প্যাকেজ github.com/jphellemons/CommandAsSQL এর জন্য রয়েছে ফ্ল্যাপারকে ধন্যবাদ! আমি কি আপনাকে সহযোগী হিসাবে যুক্ত করতে পারি?

— জেপি হেলিমন্স

Answer 2

লগিংয়ের উদ্দেশ্যে, আমি ভয় করি যে স্ট্রিংটি নিজেই তৈরি করা ছাড়া এটি করার কোনও ভাল উপায় নেই:

string query = cmd.CommandText;

foreach (SqlParameter p in cmd.Parameters)
{
    query = query.Replace(p.ParameterName, p.Value.ToString());
}

Comments

আমি যদি এটি করি তবে আমাকে বিভিন্ন ডেটাটাইপের মধ্যে পার্থক্য করতে হবে। তারপরে আমি সমস্ত এক সাথে প্যারামিটারাইজড ক্যোয়ারিটি এড়িয়ে যেতে পারি এবং এটি সম্পাদন করতে পারি।

— নকল

ডামি: আসলে না। যদি আপনি একটি প্রস্তুত বিবৃতি কার্যকর করেন, আপনি স্কয়ার ইনজেকশন আক্রমণের ঝুঁকিতে রয়েছেন। উত্তরের জন্য +1।

— সানি মাইলেনভ

এখানে একটি গেটচা আছে। যদি আমার কাছে "পরম", এবং "পরামিতিগুলি" হিসাবে "আলাদা আলাদা" থাকে তবে এটি পৃথক পারমকে অকার্যকর করে তোলে কারণ এটি "ভ্যালুপ্রাম" এ প্রতিস্থাপন করে। পরম = মান ধরে নেওয়া।

— অলোক

প্রশ্ন ডিফেন্সিভ কোডিং কৌশলগুলি নিয়ে কাজ করে না, সুতরাং নাল রেফারেন্স চেকগুলি উত্তরের অংশ নয়। এটি বাস্তবায়িত হওয়া উচিত এই বিষয়টি নিহিত, অতএব আমি এটিকে গঠনমূলক মন্তব্য হিসাবে দেখছি না।

— কন

@ অলোক দ্বারা নির্দেশিত অনুরূপ পরম নামগুলির সাথে সমস্যাটি দূর করতে কিছুটা ভাল পদ্ধতির পংক্তিতে প্যারামগুলি query = Regex.Replace(query, @"\b" + p.ParameterName + @"\b", p.Value.ToString());প্রতিস্থাপনের জন্য ব্যবহার করতে হতে পারে । এটি 'পুরো শব্দ' প্রতিস্থাপন করবে। এটি সর্বজনীন সমাধান হতে পারে না যদিও \ b শব্দের সাথে একটি অক্ষর এবং একটি শব্দহীন চরিত্রের মধ্যে একটি অবস্থান চিহ্নিত করে তাই আপনার পরামিতিগুলির নামগুলি @ এর সাথে শুরু হয়, আপনার p.ParameterName + @"\b"ক্যোয়ারী স্ট্রিংয়ে পরম প্রতিস্থাপনের জন্য ব্যবহার করা উচিত ।

— stambikk

Answer 3

আপনি পারবেন না, কারণ এটি কোনও এসকিউএল উত্পন্ন করে না।

প্যারামিটারাইজড ক্যোয়ারী (এর মধ্যে একটি) CommandText ) এসকিউএল সার্ভারে প্রস্তুত বিবৃতিটির সমতুল্য হিসাবে প্রেরণ করা হয়। আপনি যখন কমান্ডটি কার্যকর করেন, প্যারামিটারগুলি এবং ক্যোয়ারী পাঠ্য পৃথকভাবে বিবেচনা করা হয়। কোনও সময়েই একটি সম্পূর্ণ এসকিউএল স্ট্রিং উত্পন্ন হয়।

পর্দার আড়ালে নজর রাখতে আপনি এসকিউএল প্রোফাইলার ব্যবহার করতে পারেন।

Comments

এসকিউএল উত্পন্ন হয় - প্রোফাইলার দেখুন - লগিংয়ের উদ্দেশ্যে আমি যে পাঠ্যটি চাই

— kpkpkp

এসকিউএল প্রোফাইলার বাদে (কিছুটা এমএস মন্তব্য সঠিকভাবে বুঝতে

— পারলে

Answer 4

আরও ভার্বোজ লগিংয়ের জন্য আমার স্ট্রিং ট্রান্সফরমারের অনুরূপ কমান্ডের প্রয়োজন ছিল, তাই আমি এটি লিখেছিলাম। এটি আউটপুট প্যারামিটার এবং কাঠামোগত পরামিতি সহ নতুন অধিবেশনে কমান্ডটি পুনরায় কার্যকর করতে প্রয়োজনীয় পাঠ্য তৈরি করবে। এটি হালকাভাবে পরীক্ষিত, তবে ক্যাভেট এমপোটর।

উদাহরণ:

SqlCommand cmd = new SqlCommand("GetEntity", con);
cmd.Parameters.AddWithValue("@foobar", 1);
cmd.Parameters.Add(new SqlParameter(){
    ParameterName = "@outParam",
    Direction = ParameterDirection.Output,
    SqlDbType = System.Data.SqlDbType.Int
});
cmd.Parameters.Add(new SqlParameter(){
    Direction = ParameterDirection.ReturnValue
});
cmd.CommandType = CommandType.StoredProcedure;

উত্পাদন করবে:

-- BEGIN COMMAND
DECLARE @foobar INT = 1;
DECLARE @outParam INT = NULL;
DECLARE @returnValue INT;
-- END PARAMS
EXEC @returnValue = GetEntity @foobar = @foobar, @outParam = @outParam OUTPUT
-- RESULTS
SELECT 1 as Executed, @returnValue as ReturnValue, @outParam as [@outParam];
-- END COMMAND

বাস্তবায়ন:

public class SqlCommandDumper
{
    public static string GetCommandText(SqlCommand sqc)
    {
        StringBuilder sbCommandText = new StringBuilder();

        sbCommandText.AppendLine("-- BEGIN COMMAND");

        // params
        for (int i = 0; i < sqc.Parameters.Count; i++)
            logParameterToSqlBatch(sqc.Parameters[i], sbCommandText);
        sbCommandText.AppendLine("-- END PARAMS");

        // command
        if (sqc.CommandType == CommandType.StoredProcedure)
        {
            sbCommandText.Append("EXEC ");

            bool hasReturnValue = false;
            for (int i = 0; i < sqc.Parameters.Count; i++)
            {
                if (sqc.Parameters[i].Direction == ParameterDirection.ReturnValue)
                    hasReturnValue = true;
            }
            if (hasReturnValue)
            {
                sbCommandText.Append("@returnValue = ");
            }

            sbCommandText.Append(sqc.CommandText);

            bool hasPrev = false;
            for (int i = 0; i < sqc.Parameters.Count; i++)
            {
                var cParam = sqc.Parameters[i];
                if (cParam.Direction != ParameterDirection.ReturnValue)
                {
                    if (hasPrev)
                        sbCommandText.Append(", ");

                    sbCommandText.Append(cParam.ParameterName);
                    sbCommandText.Append(" = ");
                    sbCommandText.Append(cParam.ParameterName);

                    if (cParam.Direction.HasFlag(ParameterDirection.Output))
                        sbCommandText.Append(" OUTPUT");

                    hasPrev = true;
                }
            }
        }
        else
        {
            sbCommandText.AppendLine(sqc.CommandText);
        }

        sbCommandText.AppendLine("-- RESULTS");
        sbCommandText.Append("SELECT 1 as Executed");
        for (int i = 0; i < sqc.Parameters.Count; i++)
        {
            var cParam = sqc.Parameters[i];

            if (cParam.Direction == ParameterDirection.ReturnValue)
            {
                sbCommandText.Append(", @returnValue as ReturnValue");
            }
            else if (cParam.Direction.HasFlag(ParameterDirection.Output))
            {
                sbCommandText.Append(", ");
                sbCommandText.Append(cParam.ParameterName);
                sbCommandText.Append(" as [");
                sbCommandText.Append(cParam.ParameterName);
                sbCommandText.Append(']');
            }
        }
        sbCommandText.AppendLine(";");

        sbCommandText.AppendLine("-- END COMMAND");
        return sbCommandText.ToString();
    }

    private static void logParameterToSqlBatch(SqlParameter param, StringBuilder sbCommandText)
    {
        sbCommandText.Append("DECLARE ");
        if (param.Direction == ParameterDirection.ReturnValue)
        {
            sbCommandText.AppendLine("@returnValue INT;");
        }
        else
        {
            sbCommandText.Append(param.ParameterName);

            sbCommandText.Append(' ');
            if (param.SqlDbType != SqlDbType.Structured)
            {
                logParameterType(param, sbCommandText);
                sbCommandText.Append(" = ");
                logQuotedParameterValue(param.Value, sbCommandText);

                sbCommandText.AppendLine(";");
            }
            else
            {
                logStructuredParameter(param, sbCommandText);
            }
        }
    }

    private static void logStructuredParameter(SqlParameter param, StringBuilder sbCommandText)
    {
        sbCommandText.AppendLine(" {List Type};");
        var dataTable = (DataTable)param.Value;

        for (int rowNo = 0; rowNo < dataTable.Rows.Count; rowNo++)
        {
            sbCommandText.Append("INSERT INTO ");
            sbCommandText.Append(param.ParameterName);
            sbCommandText.Append(" VALUES (");

            bool hasPrev = false;
            for (int colNo = 0; colNo < dataTable.Columns.Count; colNo++)
            {
                if (hasPrev)
                {
                    sbCommandText.Append(", ");
                }
                logQuotedParameterValue(dataTable.Rows[rowNo].ItemArray[colNo], sbCommandText);
                hasPrev = true;
            }
            sbCommandText.AppendLine(");");
        }
    }

    const string DATETIME_FORMAT_ROUNDTRIP = "o";
    private static void logQuotedParameterValue(object value, StringBuilder sbCommandText)
    {
        try
        {
            if (value == null)
            {
                sbCommandText.Append("NULL");
            }
            else
            {
                value = unboxNullable(value);

                if (value is string
                    || value is char
                    || value is char[]
                    || value is System.Xml.Linq.XElement
                    || value is System.Xml.Linq.XDocument)
                {
                    sbCommandText.Append("N'");
                    sbCommandText.Append(value.ToString().Replace("'", "''"));
                    sbCommandText.Append('\'');
                }
                else if (value is bool)
                {
                    // True -> 1, False -> 0
                    sbCommandText.Append(Convert.ToInt32(value));
                }
                else if (value is sbyte
                    || value is byte
                    || value is short
                    || value is ushort
                    || value is int
                    || value is uint
                    || value is long
                    || value is ulong
                    || value is float
                    || value is double
                    || value is decimal)
                {
                    sbCommandText.Append(value.ToString());
                }
                else if (value is DateTime)
                {
                    // SQL Server only supports ISO8601 with 3 digit precision on datetime,
                    // datetime2 (>= SQL Server 2008) parses the .net format, and will 
                    // implicitly cast down to datetime.
                    // Alternatively, use the format string "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffK"
                    // to match SQL server parsing
                    sbCommandText.Append("CAST('");
                    sbCommandText.Append(((DateTime)value).ToString(DATETIME_FORMAT_ROUNDTRIP));
                    sbCommandText.Append("' as datetime2)");
                }
                else if (value is DateTimeOffset)
                {
                    sbCommandText.Append('\'');
                    sbCommandText.Append(((DateTimeOffset)value).ToString(DATETIME_FORMAT_ROUNDTRIP));
                    sbCommandText.Append('\'');
                }
                else if (value is Guid)
                {
                    sbCommandText.Append('\'');
                    sbCommandText.Append(((Guid)value).ToString());
                    sbCommandText.Append('\'');
                }
                else if (value is byte[])
                {
                    var data = (byte[])value;
                    if (data.Length == 0)
                    {
                        sbCommandText.Append("NULL");
                    }
                    else
                    {
                        sbCommandText.Append("0x");
                        for (int i = 0; i < data.Length; i++)
                        {
                            sbCommandText.Append(data[i].ToString("h2"));
                        }
                    }
                }
                else
                {
                    sbCommandText.Append("/* UNKNOWN DATATYPE: ");
                    sbCommandText.Append(value.GetType().ToString());
                    sbCommandText.Append(" *" + "/ N'");
                    sbCommandText.Append(value.ToString());
                    sbCommandText.Append('\'');
                }
            }
        }

        catch (Exception ex)
        {
            sbCommandText.AppendLine("/* Exception occurred while converting parameter: ");
            sbCommandText.AppendLine(ex.ToString());
            sbCommandText.AppendLine("*/");
        }
    }

    private static object unboxNullable(object value)
    {
        var typeOriginal = value.GetType();
        if (typeOriginal.IsGenericType
            && typeOriginal.GetGenericTypeDefinition() == typeof(Nullable<>))
        {
            // generic value, unboxing needed
            return typeOriginal.InvokeMember("GetValueOrDefault",
                System.Reflection.BindingFlags.Public |
                System.Reflection.BindingFlags.Instance |
                System.Reflection.BindingFlags.InvokeMethod,
                null, value, null);
        }
        else
        {
            return value;
        }
    }

    private static void logParameterType(SqlParameter param, StringBuilder sbCommandText)
    {
        switch (param.SqlDbType)
        {
            // variable length
            case SqlDbType.Char:
            case SqlDbType.NChar:
            case SqlDbType.Binary:
                {
                    sbCommandText.Append(param.SqlDbType.ToString().ToUpper());
                    sbCommandText.Append('(');
                    sbCommandText.Append(param.Size);
                    sbCommandText.Append(')');
                }
                break;
            case SqlDbType.VarChar:
            case SqlDbType.NVarChar:
            case SqlDbType.VarBinary:
                {
                    sbCommandText.Append(param.SqlDbType.ToString().ToUpper());
                    sbCommandText.Append("(MAX /* Specified as ");
                    sbCommandText.Append(param.Size);
                    sbCommandText.Append(" */)");
                }
                break;
            // fixed length
            case SqlDbType.Text:
            case SqlDbType.NText:
            case SqlDbType.Bit:
            case SqlDbType.TinyInt:
            case SqlDbType.SmallInt:
            case SqlDbType.Int:
            case SqlDbType.BigInt:
            case SqlDbType.SmallMoney:
            case SqlDbType.Money:
            case SqlDbType.Decimal:
            case SqlDbType.Real:
            case SqlDbType.Float:
            case SqlDbType.Date:
            case SqlDbType.DateTime:
            case SqlDbType.DateTime2:
            case SqlDbType.DateTimeOffset:
            case SqlDbType.UniqueIdentifier:
            case SqlDbType.Image:
                {
                    sbCommandText.Append(param.SqlDbType.ToString().ToUpper());
                }
                break;
            // Unknown
            case SqlDbType.Timestamp:
            default:
                {
                    sbCommandText.Append("/* UNKNOWN DATATYPE: ");
                    sbCommandText.Append(param.SqlDbType.ToString().ToUpper());
                    sbCommandText.Append(" *" + "/ ");
                    sbCommandText.Append(param.SqlDbType.ToString().ToUpper());
                }
                break;
        }
    }
}

Comments

এর জন্য ধন্যবাদ, এটি বেশ বিস্তৃত! :-)

— অ্যালাস্টার মউ

ঠিক আমি যা খুঁজছিলাম, ধন্যবাদ

— শিলমিকি

আমি এটির কোনও সংস্করণের প্রারম্ভিক পয়েন্ট হিসাবে এটি ব্যবহার করেছি যা পৃথক পৃথকভাবে ভেরিয়েবলগুলি ঘোষণার পরিবর্তে একক বিবৃতিতে পরামিতিগুলি পরিচালনা করতে sp_executesql ব্যবহার করে। এই কোডটি সত্যই সমস্ত ক্লান্তিকর কাজের যত্ন নিয়েছে এবং আমাকে কেবল টুকরোগুলি পুনর্বিন্যাস করতে হয়েছিল। অনেক ধন্যবাদ!

— পেটিস

এসকিউএল স্ট্রিং লিটারালগুলির জন্য এটির জন্য "এন" উপসর্গের দরকার নেই? অন্যথায় আপনি অনেক "?" এস পেতে পারেন। চুপি। খারাপ। (কমপক্ষে এসকিউএল সার্ভারের সাথে 2005 - কম প্রাচীন সংস্করণ দিয়ে পরীক্ষা করা হয়নি))

— পল গ্রোক

পলগ্রোক, ভাল ক্যাচ আমি Nউপসর্গ অন্তর্ভুক্ত আপডেট করেছি ।

— মিচ 0 '

Answer 5

আমারও এই সমস্যাটি ছিল যেখানে কিছু প্যারামিটারাইজড কোয়েরি বা এসপি আমাকে একটি স্কেলএক্সেপশন দেয় (বেশিরভাগ স্ট্রিং বা বাইনারি ডেটা কেটে ফেলা হত), এবং যে বিবৃতিগুলি ডিবাগ করা শক্ত (যতদূর আমি জানি যে বর্তমানে কোনও স্কল-প্রোফাইলার সমর্থন নেই) এসকিউএল অ্যাজুরে)

আমি এখানে প্রতিক্রিয়াগুলিতে প্রচুর সিমুলার কোড দেখতে পাচ্ছি। আমি ভবিষ্যতের ব্যবহারের জন্য আমার সমাধানটি একটি স্ক্যেল-লাইব্রেরি প্রকল্পে রেখেছি।

জেনারেটরটি এখানে উপলভ্য: https://github.com/jeroenpot/SqlHelper/blob/master/Source/Mirabeau.MsSql.Library/SQL

এটি কমান্ডটাইপ.টেক্সট এবং কমান্ডটাইপ.স্টোরডপ্রসেসার উভয় সমর্থন করে

এবং আপনি যদি নুগেট-প্যাকেজটি ইনস্টল করেন তবে আপনি এই বিবৃতি দিয়ে এটি তৈরি করতে পারেন:

SqlDebugHelper.CreateExecutableSqlStatement(sql, parameters);

Comments

খুব খারাপ নয়, এটি প্রতিটি প্যারামের জন্য অন্তত মানগুলি তালিকাভুক্ত করে, তবে এখনও এটি মানগুলি পূরণ করে না। অন্তত আমি নিজে এটি করতে নোটপ্যাড ব্যবহার করতে পারি, ধন্যবাদ!

— হার্ভে লিন

Answer 6

আপনি যদি এসকিউএল সার্ভার ব্যবহার করে থাকেন তবে আপনি কার্যনির্বাহিত কমান্ড স্ট্রিংটি দেখতে আপনি এসকিউএল সার্ভার প্রোফাইলার (যদি আপনার কাছে থাকে) ব্যবহার করতে পারেন। এটি অনুলিপি / পেস্ট পরীক্ষার জন্য কার্যকর হবে তবে লগিংয়ের জন্য নয় আমি ভীত।

Answer 7

দেরী উত্তর, আমি জানি কিন্তু আমিও এটি চেয়েছিলাম যাতে এসকিউএল লগ করতে পারি। নিম্নলিখিতটি সংক্ষিপ্ত এবং আমার প্রয়োজনগুলি পূরণ করে।

নিম্নলিখিতটি এসকিউএল উত্পাদন করে আপনি এসএসএমএসে অনুলিপি / পেস্ট করতে পারেন (এটি মানগুলির সাথে পরামিতিগুলি যথাযথভাবে প্রতিস্থাপন করে)। আপনি আরও প্রকারের যোগ করতে পারেন তবে এই ক্ষেত্রে আমি সমস্ত ব্যবহার করি।

    private static void LogSQL(SqlCommand cmd)
        {
            string query = cmd.CommandText;

            foreach (SqlParameter prm in cmd.Parameters)
            {
                switch (prm.SqlDbType)
                {
                    case SqlDbType.Bit:
                        int boolToInt = (bool)prm.Value ? 1 : 0;
                        query = query.Replace(prm.ParameterName, string.Format("{0}", (bool)prm.Value ? 1 : 0));
                        break;
                    case SqlDbType.Int:
                        query = query.Replace(prm.ParameterName, string.Format("{0}", prm.Value));
                        break;
                    case SqlDbType.VarChar:
                        query = query.Replace(prm.ParameterName, string.Format("'{0}'", prm.Value));
                        break;
                    default:
                        query = query.Replace(prm.ParameterName, string.Format("'{0}'", prm.Value));
                        break;
                }
            }

            // the following is my how I write to my log - your use will vary
            logger.Debug("{0}", query);

            return;
        }

এখন আমি এসকিউএল এটি সম্পাদন করার ঠিক আগে লগ করতে পারি:

LogSQL(queryCmd)
queryCmd.ExecuteNonQuery()

Answer 8

প্রোফাইলার আপনার সেরা বিকল্পটি হাতছাড়া করছে is

জড়িত প্রস্তুতি + কার্যকর করার পদক্ষেপের কারণে আপনাকে প্রোফাইলার থেকে বিবৃতিগুলির একটি সেট অনুলিপি করতে হতে পারে।

Answer 9

আমার একই একই প্রশ্ন ছিল এবং এই প্রতিক্রিয়াগুলি পড়ার পরে ভুল করে সিদ্ধান্ত নিয়েছে যে সঠিক ফলাফলের ক্যোয়ারী পাওয়া সম্ভব নয়। আমি ভৃল ছিলাম.

সমাধান: ওপেন Activity Monitorমধ্যে SQL Server Management Studio, লগইন ব্যবহারকারীর নাম, ডাটাবেজ বা অ্যাপ্লিকেশন নামের প্রসেস অধ্যায় আপনার আবেদন সংযোগ স্ট্রিং ব্যবহার করছে সংকীর্ণ। ডিবিতে কল করা হলে রিফ্রেশ Activity Monitor। আপনি যখন প্রক্রিয়াটি দেখেন, এটিতে ডান ক্লিক করুন এবং View Details।

দ্রষ্টব্য, ব্যস্ত ডিবি-র জন্য এটি কোনও কার্যকর বিকল্প নয়। তবে আপনার এই পদক্ষেপগুলি ব্যবহার করে ফলাফলটি সঙ্কুচিত করতে সক্ষম হওয়া উচিত।

Answer 10

আমার সলিউশনের জন্য ফ্ল্যাপারসের কোডটির একটি অংশ ব্যবহৃত হয়েছে , যা এমএস এসকিউএল এসএমএসে চলার জন্য প্যারামিটার মান সহ পুরো এসকিউএল স্ট্রিং প্রদান করে।

public string ParameterValueForSQL(SqlParameter sp)
    {
        string retval = "";

        switch (sp.SqlDbType)
        {
            case SqlDbType.Char:
            case SqlDbType.NChar:
            case SqlDbType.NText:
            case SqlDbType.NVarChar:
            case SqlDbType.Text:
            case SqlDbType.Time:
            case SqlDbType.VarChar:
            case SqlDbType.Xml:
            case SqlDbType.Date:
            case SqlDbType.DateTime:
            case SqlDbType.DateTime2:
            case SqlDbType.DateTimeOffset:
                if (sp.Value == DBNull.Value)
                {
                    retval = "NULL";
                }
                else
                {
                    retval = "'" + sp.Value.ToString().Replace("'", "''") + "'";
                }
                break;

            case SqlDbType.Bit:
                if (sp.Value == DBNull.Value)
                {
                    retval = "NULL";
                }
                else
                {
                    retval = ((bool)sp.Value == false) ? "0" : "1";
                }
                break;

            default:
                if (sp.Value == DBNull.Value)
                {
                    retval = "NULL";
                }
                else
                {
                    retval = sp.Value.ToString().Replace("'", "''");
                }
                break;
        }

        return retval;
    }


    public string CommandAsSql(SqlCommand sc)
    {
        string sql = sc.CommandText;

        sql = sql.Replace("\r\n", "").Replace("\r", "").Replace("\n", "");
        sql = System.Text.RegularExpressions.Regex.Replace(sql, @"\s+", " ");

        foreach (SqlParameter sp in sc.Parameters)
        {
            string spName = sp.ParameterName;
            string spValue = ParameterValueForSQL(sp);
            sql = sql.Replace(spName, spValue);
        }

        sql = sql.Replace("= NULL", "IS NULL");
        sql = sql.Replace("!= NULL", "IS NOT NULL");
        return sql;
    }

Comments

আপনার 'সমাধান' কাজ করে না। আপনি should r এবং \ n "" এর সাথে প্রতিস্থাপন করেছেন যখন আপনার "" ব্যবহার করা উচিত ছিল। এরপরে, আপনার কাছে @ @ p1 'প্রতিস্থাপনের পরে 9 টিরও বেশি পরামিতি থাকলে' @ p1 'এবং' @ p10 'উভয় ধরণের উন্মাদ ফলাফলের পরিবর্তে এটি কাজ করে না। প্যারামিটার তালিকাটি অনুলিপি করা এবং এটির বিপরীত করা আমি যা করছি তার জন্য দ্রুত সমাধান fix

— বিএইচ

এছাড়াও, 'কোড নাল' প্রতিস্থাপনের কারণে আপনার কোড আপডেট কমান্ডের জন্য কাজ করবে না।

— বিএইচ

প্রকৃতপক্ষে ফ্ল্যাপারের কোডটি ডিবিএনকে হ্যান্ডেল করে না, কমান্ডএএসএসকিউএল লাইব্রেরির উপর ভিত্তি করে এখানে একটি সমস্যা রয়েছে: github.com/jphellemons/CommandAsql/issues/1

— জর্জ বীরবিলিস

Answer 11

আমার সমাধান:

public static class DbHelper
{
    public static string ToString(this DbParameterCollection parameters, string sqlQuery)
    {
        return parameters.Cast<DbParameter>().Aggregate(sqlQuery, (current, p) => current.Replace(p.ParameterName, p.Value.ToString()));
    }
}

Answer 12

আমি এই পদ্ধতিটি আমার জন্য লিখেছি। আমি ব্রুনো রত্নিক্সের কোডের কিছু অংশ ব্যবহার করি । এটি কারও কাজে লাগে।

 public static string getQueryFromCommand(SqlCommand cmd)
    {
        StringBuilder CommandTxt = new StringBuilder();
        CommandTxt.Append("DECLARE ");
        List<string> paramlst = new List<string>();
        foreach (SqlParameter parms in cmd.Parameters)
        {
            paramlst.Add(parms.ParameterName);
            CommandTxt.Append(parms.ParameterName + " AS ");
            CommandTxt.Append(parms.SqlDbType.ToString());
            CommandTxt.Append(",");
        }

        if (CommandTxt.ToString().Substring(CommandTxt.Length-1, 1) == ",")
            CommandTxt.Remove(CommandTxt.Length-1, 1);
        CommandTxt.AppendLine();
        int rownr = 0;
        foreach (SqlParameter parms in cmd.Parameters)
        {
            string val = String.Empty;
            if (parms.DbType.Equals(DbType.String) || parms.DbType.Equals(DbType.DateTime))
                val = "'" + Convert.ToString(parms.Value).Replace(@"\", @"\\").Replace("'", @"\'") + "'";
            if (parms.DbType.Equals(DbType.Int16) || parms.DbType.Equals(DbType.Int32) || parms.DbType.Equals(DbType.Int64) || parms.DbType.Equals(DbType.Decimal) || parms.DbType.Equals(DbType.Double))
                val = Convert.ToString(parms.Value);

            CommandTxt.AppendLine();
            CommandTxt.Append("SET " + paramlst[rownr].ToString() + " = " + val.ToString());
            rownr += 1;
        }
        CommandTxt.AppendLine();
        CommandTxt.AppendLine();
        CommandTxt.Append(cmd.CommandText);
        return CommandTxt.ToString();
    }

Answer 13

ফলাফলের ক্যোয়ারীতে কোনও প্যারামিটার কীভাবে ফর্ম্যাট করা হয়েছে তা যদি কেবল তা পরীক্ষা করে দেখা যায় তবে বেশিরভাগ ডিবিএমএস-এর কিছুতেই আক্ষরিক অনুসন্ধানের অনুমতি দেওয়া হবে। এভাবে:

Using cmd As SqlCommand = Connection.CreateCommand
    cmd.CommandText = "SELECT @Value"
    cmd.Parameters.AddWithValue("@Value", "myValue")
    Return cmd.ExecuteScalar
End Using

আপনি কোটগুলি দ্বিগুণ করা ইত্যাদি দেখতে পারেন etc.

Answer 14

এটি আমি ডিবাগ কনসোলটিতে সঞ্চিত পদ্ধতির জন্য প্যারামিটার তালিকা আউটপুট করতে ব্যবহার করি:

string query = (from SqlParameter p in sqlCmd.Parameters where p != null where p.Value != null select string.Format("Param: {0} = {1},  ", p.ParameterName, p.Value.ToString())).Aggregate(sqlCmd.CommandText, (current, parameter) => current + parameter);
Debug.WriteLine(query);

এটি এতে কনসোল আউটপুট সিমলার উত্পন্ন করবে:

Customer.prGetCustomerDetails: @Offset = 1,  Param: @Fetch = 10,  Param: @CategoryLevel1ID = 3,  Param: @VehicleLineID = 9,  Param: @SalesCode1 = bce,  

আমি এই কোডটি ডিবাগ করতে ইচ্ছুক যে কোনও পদ্ধতির নীচে সরাসরি রাখি এবং এটি স্কিল প্রোফাইলার সেশনের মতো তবে সি # তে।

Answer 15

কন এর উত্তরের পরিবর্তিত সংস্করণ হিসাবে এটি কেবল একইভাবে নামযুক্ত পরামিতিগুলির সাথে আংশিকভাবে কাজ করে। স্ট্রিং রিপ্লেস ফাংশনটি ব্যবহার করার নীচের দিক। তার বাইরে আমি সমাধানটির পুরো কৃতিত্ব দিচ্ছি।

private string GetActualQuery(SqlCommand sqlcmd)
{
    string query = sqlcmd.CommandText;
    string parameters = "";
    string[] strArray = System.Text.RegularExpressions.Regex.Split(query, " VALUES ");

    //Reconstructs the second half of the SQL Command
    parameters = "(";

    int count = 0;
    foreach (SqlParameter p in sqlcmd.Parameters)
    {
        if (count == (sqlcmd.Parameters.Count - 1))
        {
            parameters += p.Value.ToString();
        }
        else
        {
            parameters += p.Value.ToString() + ", ";
        }
        count++;
    }

    parameters += ")";

    //Returns the string recombined.
    return strArray[0] + " VALUES " + parameters;
}

Answer 16

এই সমাধানটি এখনই আমার পক্ষে কাজ করে। কারও কাছে এটি উপকারী। সমস্ত অপ্রয়োজনীয় ক্ষমা করুন।

    Public Shared Function SqlString(ByVal cmd As SqlCommand) As String
    Dim sbRetVal As New System.Text.StringBuilder()
    For Each item As SqlParameter In cmd.Parameters
        Select Case item.DbType
            Case DbType.String
                sbRetVal.AppendFormat("DECLARE {0} AS VARCHAR(255)", item.ParameterName)
                sbRetVal.AppendLine()
                sbRetVal.AppendFormat("SET {0} = '{1}'", item.ParameterName, item.Value)
                sbRetVal.AppendLine()

            Case DbType.DateTime
                sbRetVal.AppendFormat("DECLARE {0} AS DATETIME", item.ParameterName)
                sbRetVal.AppendLine()
                sbRetVal.AppendFormat("SET {0} = '{1}'", item.ParameterName, item.Value)
                sbRetVal.AppendLine()

            Case DbType.Guid
                sbRetVal.AppendFormat("DECLARE {0} AS UNIQUEIDENTIFIER", item.ParameterName)
                sbRetVal.AppendLine()
                sbRetVal.AppendFormat("SET {0} = '{1}'", item.ParameterName, item.Value)
                sbRetVal.AppendLine()

            Case DbType.Int32
                sbRetVal.AppendFormat("DECLARE {0} AS int", item.ParameterName)
                sbRetVal.AppendLine()
                sbRetVal.AppendFormat("SET {0} = {1}", item.ParameterName, item.Value)
                sbRetVal.AppendLine()

            Case Else
                Stop

        End Select
    Next

    sbRetVal.AppendLine("")
    sbRetVal.AppendLine(cmd.CommandText)

    Return sbRetVal.ToString()
End Function

Answer 17

@PkExec এবং @Alk উল্লিখিত হিসাবে, প্রতিস্থাপন ব্যবহার 100% ক্ষেত্রে কাজ করে না। আমি আমাদের ডালে এটি সমাধান করে যা কেবলমাত্র "পুরো শব্দটির সাথে মেলে" এবং ডেটাটাইপগুলি সঠিকভাবে ফর্ম্যাট করতে RegExp ব্যবহার করে। সুতরাং উত্পাদিত এসকিউএল সরাসরি মাইএসকিউএল ওয়ার্কবেঞ্চে (বা এসকিউএলএসএমএস ইত্যাদি) পরীক্ষা করা যায় :) :)

(ব্যবহৃত ডিবিএমএস অনুসারে মাইএসকিউএলহেলপার.একটিপ স্ট্রিং () ফাংশনটি প্রতিস্থাপন করুন))

Dim query As String = cmd.CommandText
query = query.Replace("SET", "SET" & vbNewLine)
query = query.Replace("WHERE", vbNewLine & "WHERE")
query = query.Replace("GROUP BY", vbNewLine & "GROUP BY")
query = query.Replace("ORDER BY", vbNewLine & "ORDER BY")
query = query.Replace("INNER JOIN", vbNewLine & "INNER JOIN")
query = query.Replace("LEFT JOIN", vbNewLine & "LEFT JOIN")
query = query.Replace("RIGHT JOIN", vbNewLine & "RIGHT JOIN")
If query.Contains("UNION ALL") Then
    query = query.Replace("UNION ALL", vbNewLine & "UNION ALL" & vbNewLine)
ElseIf query.Contains("UNION DISTINCT") Then
    query = query.Replace("UNION DISTINCT", vbNewLine & "UNION DISTINCT" & vbNewLine)
Else
    query = query.Replace("UNION", vbNewLine & "UNION" & vbNewLine)
End If

For Each par In cmd.Parameters
    If par.Value Is Nothing OrElse IsDBNull(par.Value) Then
        query = RegularExpressions.Regex.Replace(query, par.ParameterName & "\b", "NULL")
    ElseIf TypeOf par.Value Is Date Then
        query = RegularExpressions.Regex.Replace(query, par.ParameterName & "\b", "'" & Format(par.Value, "yyyy-MM-dd HH:mm:ss") & "'")
    ElseIf TypeOf par.Value Is TimeSpan Then
        query = RegularExpressions.Regex.Replace(query, par.ParameterName & "\b", "'" & par.Value.ToString & "'")
    ElseIf TypeOf par.Value Is Double Or TypeOf par.Value Is Decimal Or TypeOf par.Value Is Single Then
        query = RegularExpressions.Regex.Replace(query, par.ParameterName & "\b", Replace(par.Value.ToString, ",", "."))
    ElseIf TypeOf par.Value Is Integer Or TypeOf par.Value Is UInteger Or TypeOf par.Value Is Long Or TypeOf par.Value Is ULong Then
        query = RegularExpressions.Regex.Replace(query, par.ParameterName & "\b", par.Value.ToString)
    Else
        query = RegularExpressions.Regex.Replace(query, par.ParameterName & "\b", "'" & MySqlHelper.EscapeString(CStr(par.Value)) & "'")
    End If
Next

উদাহরণ:

SELECT * FROM order WHERE order_status = @order_status AND order_date = @order_date

উত্পন্ন হবে:

SELECT * FROM order WHERE order_status = 'C' AND order_date = '2015-01-01 00:00:00'

Answer 18

sql কমান্ড কোয়েরিগুলি exec sp_executesql দিয়ে সম্পাদন করা হবে, সুতরাং স্ট্রিং হিসাবে এই স্টেটমেন্টটি পাওয়ার জন্য এখানে আরও একটি উপায় রয়েছে (এসকিউএলকম্যান্ড এক্সটেনশন পদ্ধতি):

public static string ToSqlStatement(this SqlCommand cmd)
{
    return $@"EXECUTE sp_executesql N'{cmd.CommandText.Replace("'", "''")}'{cmd.Parameters.ToSqlParameters()}";
}

private static string ToSqlParameters(this SqlParameterCollection col)
{
    if (col.Count == 0)
        return string.Empty;
    var parameters = new List<string>();
    var parameterValues = new List<string>();
    foreach (SqlParameter param in col)
    {
        parameters.Add($"{param.ParameterName}{param.ToSqlParameterType()}");
        parameterValues.Add($"{param.ParameterName} = {param.ToSqlParameterValue()}");
    }
    return $",N\'{string.Join(",", parameters)}\',{string.Join(",", parameterValues)}";
}

private static object ToSqlParameterType(this SqlParameter param)
{
    var paramDbType = param.SqlDbType.ToString().ToLower();
    if (param.Precision != 0 && param.Scale != 0)
        return $"{paramDbType}({param.Precision},{param.Scale})";
    if (param.Precision != 0)
        return $"{paramDbType}({param.Precision})";
    switch (param.SqlDbType)
    {
        case SqlDbType.VarChar:
        case SqlDbType.NVarChar:
            string s = param.SqlValue?.ToString() ?? string.Empty;
            return paramDbType + (s.Length > 0 ? $"({s.Length})" : string.Empty);
        default:
            return paramDbType;
    }
}

private static string ToSqlParameterValue(this SqlParameter param)
{
    switch (param.SqlDbType)
    {
        case SqlDbType.Char:
        case SqlDbType.Date:
        case SqlDbType.DateTime:
        case SqlDbType.DateTime2:
        case SqlDbType.DateTimeOffset:
        case SqlDbType.NChar:
        case SqlDbType.NText:
        case SqlDbType.NVarChar:
        case SqlDbType.Text:
        case SqlDbType.Time:
        case SqlDbType.VarChar:
        case SqlDbType.Xml:
            return $"\'{param.SqlValue.ToString().Replace("'", "''")}\'";
        case SqlDbType.Bit:
            return param.SqlValue.ToBooleanOrDefault() ? "1" : "0";
        default:
            return param.SqlValue.ToString().Replace("'", "''");
    }
}

public static bool ToBooleanOrDefault(this object o, bool defaultValue = false)
{
    if (o == null)
        return defaultValue;
    string value = o.ToString().ToLower();
    switch (value)
    {
        case "yes":
        case "true":
        case "ok":
        case "y":
            return true;
        case "no":
        case "false":
        case "n":
            return false;
        default:
            bool b;
            if (bool.TryParse(o.ToString(), out b))
                return b;
            break;
    }
    return defaultValue;
}

Answer 19

স্টোরবিহীন পদ্ধতিগুলিও কভার করার দরকার ছিল তাই আমি এই যুক্তি দিয়ে কমান্ডএএসএসএল লাইব্রেরি (উপরে @ ফ্ল্যাপারের উত্তরের নীচে মন্তব্যগুলি দেখুন) বাড়িয়েছি:

    private static void CommandAsSql_Text(this SqlCommand command, System.Text.StringBuilder sql)
    {
        string query = command.CommandText;

        foreach (SqlParameter p in command.Parameters)
            query = Regex.Replace(query, "\\B" + p.ParameterName + "\\b", p.ParameterValueForSQL()); //the first one is \B, the 2nd one is \b, since ParameterName starts with @ which is a non-word character in RegEx (see https://stackoverflow.com/a/2544661)

        sql.AppendLine(query);
    }

টানার অনুরোধটি এখানে রয়েছে: https://github.com/jphellemons/CommandAsSql/pull/3/commits/527d696dc6055c5bcf858b9700b83dc863f04896

রেজেক্স ধারণাটি @ স্টাম্বিকস এবং ইওজেডের উপরের মন্তব্য এবং "আপডেট:" বিভাগের উপর ভিত্তি করে ছিল https://stackoverflow.com/a/2544661/903783 "নেতিবাচক চেহারা-পিছনে দাবী" উল্লেখ করেছে। নিয়মিত অভিব্যক্তিটির শুরুতে শব্দের সীমানা সনাক্তকরণের জন্য of বি এর পরিবর্তে of বি ব্যবহার করা হয় কারণ p.parameterName সর্বদা একটি "@" দিয়ে শুরু হবে যা কোনও শব্দ বর্ণ নয় character

নোট করুন যে প্যারামিটারভ্যালিউফোর্এসএসকিউএল () হ'ল একক-উদ্ধৃতি স্ট্রিং প্যারামিটার মান ইত্যাদির মতো সমস্যাগুলি পরিচালনা করতে কমান্ডএএসএসএল লাইব্রেরিতে সংজ্ঞায়িত করা একটি এক্সটেনশন পদ্ধতি is

Comments

বিটিডব্লিউ, অন্যান্য প্রতিশ্রুতিবদ্ধ কোডটি github.com/jeroenpot/SqlHelper/blob/master/Source/… (এই থ্রেডের উত্তরে উল্লিখিত) এ রয়েছে। সম্ভবত এসকিউএলকম্যান্ড এবং এসকিএলজেইনরেটর থেকে কোডটি একত্রিত করতে পারে যদি আপনি কিছু বা

— অন্যটিতে

... শেষ মন্তব্যে এসকিউএলকম্যান্ডের পরিবর্তে কমান্ডএএসএসকিউএল লাইব্রেরি বলতে চাইছেন

— জর্জ বীরবিলিস

Answer 20

আপনি যদি কমান্ডটেক্সটকে রূপান্তর করবেন:

Private Function ConvToNonParm(ByRef Cmd As SqlClient.SqlCommand) As String
    For myCnt As Int16 = 1 To Cmd.Parameters.Count
        Dim myVal As String = Cmd.Parameters(myCnt - 1).Value
        Select Case Cmd.Parameters(myCnt - 1).SqlDbType
            Case SqlDbType.Char, SqlDbType.NChar, SqlDbType.VarChar, SqlDbType.NChar, SqlDbType.NVarChar 'and so on
                myVal = "'" & myVal & "'"
                'Case "others...."

            Case Else
                'please assing
        End Select
        Cmd.CommandText = Replace(Cmd.CommandText, Cmd.Parameters(myCnt - 1).ToString, myVal)
    Next
    Cmd.Parameters.Clear()
    Return Cmd.CommandText
End Function

এখন আপনি নিম্নরূপ পরামিতি কমান্ডটেক্সট পেতে পারেন:

    myCmd.CommandText = "UPDATE someTable SET Value = @Value"
    myCmd.CommandText &= " WHERE Id = @Id"
    myCmd.Parameters.AddWithValue("@Id", 1234)
    myCmd.Parameters.AddWithValue("@Value", "myValue")

    myCmd.CommandText = ConvToNonParm(myCmd)

এবং ফলাফলটি কোনও পরামিতি ছাড়াই "আপডেটের কিছু টেবিল সেট মান = 'আমারভ্যালু' যেখানে আইডি = 1234"

Answer 21

কোনও সঞ্চিত প্রক্রিয়াটি ডিবাগ করতে সহায়তা করার জন্য কন এর সম্প্রসারিত কোড :

    private void ExtractSqlCommandForDebugging(SqlCommand cmd)
    {
        string sql = "exec " + cmd.CommandText;
        bool first = true;
        foreach (SqlParameter p in cmd.Parameters)
        {
            string value = ((p.Value == DBNull.Value) ? "null"
                            : (p.Value is string) ? "'" + p.Value + "'"
                            : p.Value.ToString());
            if (first)
            {
                sql += string.Format(" {0}={1}", p.ParameterName, value);
                first = false;
            }
            else
            {
                sql += string.Format("\n , {0}={1}", p.ParameterName, value);
            }
        }
        sql += "\nGO";
        Debug.WriteLine(sql);
    }

আমার প্রথম পরীক্ষার ক্ষেত্রে এটি উত্পন্ন:

exec dbo.MyStoredProcName @SnailMail=False
 , @Email=True
 , @AcceptSnailMail=False
 , @AcceptEmail=False
 , @DistanceMiles=-1
 , @DistanceLocationList=''
 , @ExcludeDissatisfied=True
 , @ExcludeCodeRed=True
 , @MinAge=null
 , @MaxAge=18
 , @GenderTypeID=-1
 , @NewThisYear=-1
 , @RegisteredThisYear=-1
 , @FormersTermGroupList=''
 , @RegistrationStartDate=null
 , @RegistrationEndDate=null
 , @DivisionList='25'
 , @LocationList='29,30'
 , @OneOnOneOPL=-1
 , @JumpStart=-1
 , @SmallGroup=-1
 , @PurchasedEAP=-1
 , @RedeemedEAP=-1
 , @ReturnPlanYes=False
 , @MinNetPromoter=-1
 , @MinSurveyScore=-1
 , @VIPExclusionTypes='-2'
 , @FieldSelectionMask=65011584
 , @DisplayType=0
GO

আপনাকে সম্ভবত আরও কিছু শর্তাধীন "..আই ..." টাইপ অ্যাসাইনমেন্ট যুক্ত করতে হবে, যেমন তারিখ এবং সময়গুলির জন্য।

Answer 22

এক রৈখিক:

string.Join(",", from SqlParameter p in cmd.Parameters select p.ToString()) 

Answer 23

প্যারামিটার কমান্ড থেকে পরামিতি কমান্ড পর্যন্ত, আপনি এটি পরিবর্তন করতে পারেন

Using cmd As SqlCommand = Connection.CreateCommand
    cmd.CommandText = "UPDATE someTable SET Value = @Value"
    cmd.CommandText &= " WHERE Id = @Id"
    cmd.Parameters.AddWithValue("@Id", 1234)
    cmd.Parameters.AddWithValue("@Value", "myValue")
    cmd.ExecuteNonQuery
End Using

প্রতি

Private sub Update( byval myID as Int32, byval myVal as String)
    Using cmd As SqlCommand = Connection.CreateCommand
        cmd.CommandText = "UPDATE someTable SET Value = '" & myVaL & "'" & _
                          " WHERE Id = " & myID  
        cmd.ExecuteNonQuery
    End Using
End sub