sql - গঠন - ধারাবাহিক একটি এসকিউএল পরামিতি




w3schools sql (20)

আমি কীভাবে একটি ক্যোয়ারীকে পরামিতি করব যা একটি IN ক্লজ সহ একটি পরিবর্তনশীল সংখ্যক আর্গুমেন্ট সহ, এটির মত?

SELECT * FROM Tags 
WHERE Name IN ('ruby','rails','scruffy','rubyonrails')
ORDER BY Count DESC

এই প্রশ্নের মধ্যে, আর্গুমেন্ট সংখ্যা 1 থেকে 5 কোথাও হতে পারে।

আমি এই (বা এক্সএমএল) এর জন্য একটি ডেডিকেটেড সংরক্ষিত পদ্ধতি ব্যবহার করতে পছন্দ করি না, তবে যদি SQL সার্ভার 2008 নির্দিষ্ট কিছু মার্জিত উপায় থাকে তবে আমি এটি খুলি।


SQL সার্ভার 2008 এর জন্য, আপনি একটি টেবিল মূল্যবান পরামিতি ব্যবহার করতে পারেন। এটি একটি বিট কাজ, কিন্তু এটা আমার অন্যান্য পদ্ধতির চেয়ে arguably ক্লিনার হয়।

প্রথম, আপনি একটি টাইপ তৈরি করতে হবে

CREATE TYPE dbo.TagNamesTableType AS TABLE ( Name nvarchar(50) )

তারপর, আপনার ADO.NET কোডটি এরকম দেখাচ্ছে:

string[] tags = new string[] { "ruby", "rails", "scruffy", "rubyonrails" };
cmd.CommandText = "SELECT Tags.* FROM Tags JOIN @tagNames as P ON Tags.Name = P.Name";

// value must be IEnumerable<SqlDataRecord>
cmd.Parameters.AddWithValue("@tagNames", tags.AsSqlDataRecord("Name")).SqlDbType = SqlDbType.Structured;
cmd.Parameters["@tagNames"].TypeName = "dbo.TagNamesTableType";

// Extension method for converting IEnumerable<string> to IEnumerable<SqlDataRecord>
public static IEnumerable<SqlDataRecord> AsSqlDataRecord(this IEnumerable<string> values, string columnName) {
    if (values == null || !values.Any()) return null; // Annoying, but SqlClient wants null instead of 0 rows
    var firstRecord = values.First();
    var metadata = SqlMetaData.InferFromValue(firstRecord, columnName);
    return values.Select(v => 
    {
       var r = new SqlDataRecord(metadata);
       r.SetValues(v);
       return r;
    });
}

আপনি প্রতিটি মান পরামিতি করতে পারেন, তাই কিছু ভালো:

string[] tags = new string[] { "ruby", "rails", "scruffy", "rubyonrails" };
string cmdText = "SELECT * FROM Tags WHERE Name IN ({0})";

string[] paramNames = tags.Select(
    (s, i) => "@tag" + i.ToString()
).ToArray();

string inClause = string.Join(", ", paramNames);
using (SqlCommand cmd = new SqlCommand(string.Format(cmdText, inClause))) {
    for(int i = 0; i < paramNames.Length; i++) {
       cmd.Parameters.AddWithValue(paramNames[i], tags[i]);
    }
}

যা আপনাকে দেবে:

cmd.CommandText = "SELECT * FROM Tags WHERE Name IN (@tag0, @tag1, @tag2, @tag3)"
cmd.Parameters["@tag0"] = "ruby"
cmd.Parameters["@tag1"] = "rails"
cmd.Parameters["@tag2"] = "scruffy"
cmd.Parameters["@tag3"] = "rubyonrails"

না, এই এসকিউএল ইনজেকশন খোলা হয় না। CommandText মধ্যে শুধুমাত্র ইনজেকশন টেক্সট ব্যবহারকারী ইনপুট উপর ভিত্তি করে নয়। এটি সম্পূর্ণরূপে হার্ডডাকড "@ ট্যাগ" উপসর্গ এবং একটি অ্যারের সূচকের উপর ভিত্তি করে। সূচক সর্বদা একটি পূর্ণসংখ্যা হবে, ব্যবহারকারী উত্পন্ন হয় না, এবং নিরাপদ।

ব্যবহারকারী ইনপুট মান এখনও পরামিতি মধ্যে স্টাফ করা হয়, তাই সেখানে কোন দুর্বলতা নেই।

সম্পাদনা:

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

ক্যাশেড ক্যোয়ারী প্ল্যানগুলি মূল্যবান নয়, তবে আইএমও এই প্রশ্নের বেশিরভাগ সুবিধা দেখতে যথেষ্ট জটিল নয়। সংকলন খরচ কার্যকর করার খরচ (অথবা এমনকি অতিক্রম) করতে পারে, আপনি এখনও মিলিসেকেন্ড কথা বলছেন।

যদি আপনার পর্যাপ্ত RAM থাকে তবে আমি আশা করি SQL সার্ভার সম্ভবত প্যারামিটারের সাধারণ গণনার জন্য একটি পরিকল্পনাটি ক্যাশে করবে। আমি মনে করি আপনি সর্বদা পাঁচটি প্যারামিটার যুক্ত করতে পারেন এবং অনির্দিষ্ট ট্যাগগুলিকে নুল করতে দিন - ক্যোয়ারী পরিকল্পনাটি একই হওয়া উচিত তবে এটি আমার কাছে বেশ কুৎসিত বলে মনে হচ্ছে এবং আমি নিশ্চিত নই যে এটি মাইক্রো-অপ্টিমাইজেশনের মূল্যবান (যদিও, স্ট্যাক ওভারফ্লো উপর - এটি খুব ভাল হতে পারে)।

এছাড়াও, এসকিউএল সার্ভার 7 এবং পরবর্তীতে স্ব-প্যারামিটারাইজেশন ক্যোয়ারী করবে , তাই প্যারামিটার ব্যবহার করে একটি কর্মক্ষমতা দৃষ্টিকোণ থেকে সত্যিই প্রয়োজনীয় নয় - তবে, এটি নিরাপত্তা দৃষ্টিকোণ থেকে গুরুত্বপূর্ণ - বিশেষ করে ব্যবহারকারীর ইনপুটযুক্ত ডেটা সহ।


আপনি যদি .NET থেকে কল করেন তবে আপনি ড্যাপার ডট নেট ব্যবহার করতে পারেন:

string[] names = new string[] {"ruby","rails","scruffy","rubyonrails"};
var tags = dataContext.Query<Tags>(@"
select * from Tags 
where Name in @names
order by Count desc", new {names});

এখানে Dapper চিন্তা করে, তাই আপনি করতে হবে না। LINQ to SQL মতো কিছুটা অবশ্যই সম্ভব:

string[] names = new string[] {"ruby","rails","scruffy","rubyonrails"};
var tags = from tag in dataContext.Tags
           where names.Contains(tag.Name)
           orderby tag.Count descending
           select tag;

আমাদের এমন ফাংশন রয়েছে যা একটি টেবিল পরিবর্তনশীল তৈরি করে যা আপনি এতে যোগ দিতে পারেন:

ALTER FUNCTION [dbo].[Fn_sqllist_to_table](@list  AS VARCHAR(8000),
                                           @delim AS VARCHAR(10))
RETURNS @listTable TABLE(
  Position INT,
  Value    VARCHAR(8000))
AS
  BEGIN
      DECLARE @myPos INT

      SET @myPos = 1

      WHILE Charindex(@delim, @list) > 0
        BEGIN
            INSERT INTO @listTable
                        (Position,Value)
            VALUES     (@myPos,LEFT(@list, Charindex(@delim, @list) - 1))

            SET @myPos = @myPos + 1

            IF Charindex(@delim, @list) = Len(@list)
              INSERT INTO @listTable
                          (Position,Value)
              VALUES     (@myPos,'')

            SET @list = RIGHT(@list, Len(@list) - Charindex(@delim, @list))
        END

      IF Len(@list) > 0
        INSERT INTO @listTable
                    (Position,Value)
        VALUES     (@myPos,@list)

      RETURN
  END 

তাই:

@Name varchar(8000) = null // parameter for search values    

select * from Tags 
where Name in (SELECT value From fn_sqllist_to_table(@Name,',')))
order by Count desc

আমি একটি টেবিল ধরণ প্যারামিটার পাস করব (এটি SQL সার্ভার 2008 এর পরে ), এবং where exists , অথবা অভ্যন্তরীণ যোগদান করবেন। আপনি sp_xml_preparedocument ব্যবহার করে এক্সএমএল ব্যবহার করতে পারেন, এবং তারপরেও অস্থায়ী টেবিল সূচী করতে পারেন।


আমি জেফ / জোয়েলকে আজকের পডকাস্টে এই বিষয়ে কথা বলেছি ( পর্ব 34 , 2008-12-16 (এমপি 3, 31 মেগাবাইট), 1 ঘন্টা 03 মিনিট 38 সেকেন্ড - 1 ঘন্টা 06 মিনি 45 সেকেন্ড), এবং আমি ভেবেছিলাম যে আমি স্ট্যাক ওভারফ্লোকে স্মরণ করেছি LINQ to SQL ব্যবহার LINQ to SQL ব্যবহার করা LINQ to SQL , কিন্তু সম্ভবত এটি ditched ছিল। LINQ থেকে SQL এ একই জিনিস এখানে।

var inValues = new [] { "ruby","rails","scruffy","rubyonrails" };

var results = from tag in Tags
              where inValues.Contains(tag.Name)
              select tag;

এটাই. এবং, হ্যাঁ, LINQ ইতিমধ্যে যথেষ্ট পিছনে দেখে মনে হচ্ছে, তবে Contains ধারাটি অতিরিক্ত পিছনে আমার মনে হয়। যখন আমাকে কাজের একটি প্রকল্পের জন্য একই প্রশ্ন করতে হয়েছিল, তখন স্থানীয়ভাবে অ্যারে এবং এসকিউএল সার্ভার টেবিলের মধ্যে যোগদান করে আমি স্বাভাবিকভাবেই এটি ভুল করার চেষ্টা করেছি, LINQ থেকে SQL অনুবাদককে চিত্রিত করার জন্য যথেষ্ট স্মার্ট হবে কোনভাবে অনুবাদ। এটি ছিল না, কিন্তু এটি একটি ত্রুটি বার্তা প্রদান করে যা বর্ণনামূলক ছিল এবং আমাকে ধারণ করে প্রতি নির্দেশ করে।

যাইহোক, যদি আপনি LINQPad অত্যন্ত LINQPad চালান এবং এই প্রশ্নটি চালান, তবে আপনি SQL LINQ সরবরাহকারী যে প্রকৃত SQL তৈরি করেছেন তা দেখতে পারেন। এটি আপনাকে একটি IN বিভাগে প্যারামিটারাইজড হওয়া মানগুলির প্রতিটিটি দেখাবে।


এখানে আমি ব্যবহার করেছি একটি দ্রুত এবং নোংরা কৌশল:

SELECT * FROM Tags
WHERE '|ruby|rails|scruffy|rubyonrails|'
LIKE '%|' + Name + '|%'

সুতরাং এখানে সি # কোড আছে:

string[] tags = new string[] { "ruby", "rails", "scruffy", "rubyonrails" };
const string cmdText = "select * from tags where '|' + @tags + '|' like '%|' + Name + '|%'";

using (SqlCommand cmd = new SqlCommand(cmdText)) {
   cmd.Parameters.AddWithValue("@tags", string.Join("|", tags);
}

দুই ক্যাভিটস:

  • কর্মক্ষমতা ভয়ানক। LIKE "%...%" প্রশ্ন সূচী করা হয় না।
  • নিশ্চিত করুন যে আপনার কোনও নেই | , ফাঁকা, বা নাল ট্যাগ বা এই কাজ করবে না

এমন কিছু করার উপায় রয়েছে যা কিছু লোক ক্লিনার বিবেচনা করতে পারে, তাই অনুগ্রহ করে পড়া চালিয়ে যান।


এটি মোট, কিন্তু যদি আপনি কমপক্ষে একটি নিশ্চিত করার জন্য নিশ্চিত হন তবে আপনি করতে পারেন:

SELECT ...
       ...
 WHERE tag IN( @tag1, ISNULL( @tag2, @tag1 ), ISNULL( @tag3, @tag1 ), etc. )

আইএন ('ট্যাগ 1', 'ট্যাগ 2', 'ট্যাগ 1', 'ট্যাগ 1', 'ট্যাগ 1') এসকিউএল সার্ভার দ্বারা সহজেই অপ্টিমাইজ করা হবে। প্লাস, আপনি সরাসরি সূচক সন্ধান পেতে


যদি আপনি SQL সার্ভার 2008 বা পরে পেয়ে থাকেন তবে আমি একটি সারণী মূল্যবান পরামিতি ব্যবহার করব।

আপনি SQL সার্ভার 2005 আটকে যথেষ্ট যথেষ্ট দুর্ভাগ্যজনক যদি আপনি এই মত একটি CLR ফাংশন যোগ করতে পারে,

[SqlFunction(
    DataAccessKind.None,
    IsDeterministic = true,
    SystemDataAccess = SystemDataAccessKind.None,
    IsPrecise = true,
    FillRowMethodName = "SplitFillRow",
    TableDefinintion = "s NVARCHAR(MAX)"]
public static IEnumerable Split(SqlChars seperator, SqlString s)
{
    if (s.IsNull)
        return new string[0];

    return s.ToString().Split(seperator.Buffer);
}

public static void SplitFillRow(object row, out SqlString s)
{
    s = new SqlString(row.ToString());
}

যা আপনি এই মত ব্যবহার করতে পারে,

declare @desiredTags nvarchar(MAX);
set @desiredTags = 'ruby,rails,scruffy,rubyonrails';

select * from Tags
where Name in [dbo].[Split] (',', @desiredTags)
order by Count desc

সঠিকভাবে আইএমএইচও একটি অক্ষর স্ট্রিংয়ের তালিকাটি সংরক্ষণ করতে পারে (ডিবিএমএস সমর্থনের দ্বারা সীমিত সীমিত); একমাত্র কৌশল হল (প্রক্রিয়াজাতকরণ সহজতর করার জন্য) শুরুতে এবং স্ট্রিং শেষে আমার একটি বিভাজক (আমার উদাহরণে একটি কমা) আছে। ধারণাটি "ফ্লাইতে স্বাভাবিকীকরণ" করা, তালিকাটিকে এক-কলাম টেবিলে পরিণত করা যা প্রতিটি মানের প্রতি একটি সারি ধারণ করে। এই আপনি চালু করতে পারবেন

ইন (ct1, ct2, ct3 ... ctn)

একটি মধ্যে

ইন (নির্বাচন করুন ...)

অথবা (আমি যে সমাধানটি সম্ভবত পছন্দ করি) নিয়মিত যোগদান করুন, যদি আপনি তালিকাতে সদৃশ মানগুলির সমস্যাগুলি এড়ানোর জন্য একটি "স্বতন্ত্র" যোগ করেন।

দুর্ভাগ্যবশত, একটি স্ট্রিং টুকরা করার কৌশল মোটামুটি পণ্য-নির্দিষ্ট। এসকিউএল সার্ভার সংস্করণ এখানে:

 with qry(n, names) as
       (select len(list.names) - len(replace(list.names, ',', '')) - 1 as n,
               substring(list.names, 2, len(list.names)) as names
        from (select ',Doc,Grumpy,Happy,Sneezy,Bashful,Sleepy,Dopey,' names) as list
        union all
        select (n - 1) as n,
               substring(names, 1 + charindex(',', names), len(names)) as names
        from qry
        where n > 1)
 select n, substring(names, 1, charindex(',', names) - 1) dwarf
 from qry;

ওরাকল সংস্করণ:

 select n, substr(name, 1, instr(name, ',') - 1) dwarf
 from (select n,
             substr(val, 1 + instr(val, ',', 1, n)) name
      from (select rownum as n,
                   list.val
            from  (select ',Doc,Grumpy,Happy,Sneezy,Bashful,Sleepy,Dopey,' val
                   from dual) list
            connect by level < length(list.val) -
                               length(replace(list.val, ',', ''))));

এবং MySQL সংস্করণ:

select pivot.n,
      substring_index(substring_index(list.val, ',', 1 + pivot.n), ',', -1) from (select 1 as n
     union all
     select 2 as n
     union all
     select 3 as n
     union all
     select 4 as n
     union all
     select 5 as n
     union all
     select 6 as n
     union all
     select 7 as n
     union all
     select 8 as n
     union all
     select 9 as n
     union all
     select 10 as n) pivot,    (select ',Doc,Grumpy,Happy,Sneezy,Bashful,Sleepy,Dopey,' val) as list where pivot.n <  length(list.val) -
                   length(replace(list.val, ',', ''));

(অবশ্যই, "পিভট" অবশ্যই অনেকগুলি সারি ফেরত দিতে হবে যা আমরা তালিকাতে সর্বাধিক সংখ্যক আইটেম খুঁজে পেতে পারি)


আমরা এখানে এক্সএমএল ব্যবহার করতে পারেন:

    declare @x xml
    set @x='<items>
    <item myvalue="29790" />
    <item myvalue="31250" />
    </items>
    ';
    With CTE AS (
         SELECT 
            x.item.value('@myvalue[1]', 'decimal') AS myvalue
        FROM @x.nodes('//items/item') AS x(item) )

    select * from YourTable where tableColumnName in (select myvalue from cte)

আমার একটি উত্তর আছে যা একটি ইউডিএফ, এক্সএমএল প্রয়োজন হয় না কারণ একটি নির্বাচিত বিবৃতি গ্রহণ করে যেমন নির্বাচন করুন * নির্বাচন থেকে যেখানে ডাটা ইন (টেবিল থেকে নির্বাচন মান)

আপনি সত্যিই একটি টেবিলের মধ্যে স্ট্রিং রূপান্তর করার একটি উপায় প্রয়োজন।

এটি একটি পুনরাবৃত্তিশীল CTE, অথবা একটি সংখ্যা সারণির সাথে একটি প্রশ্ন (অথবা মাস্টার..এসপি_ভ্যালু) দিয়ে করা যেতে পারে

এখানে সিটিই সংস্করণ।

DECLARE @InputString varchar(8000) = 'ruby,rails,scruffy,rubyonrails'

SELECT @InputString = @InputString + ','

;WITH RecursiveCSV(x,y) 
AS 
(
    SELECT 
        x = SUBSTRING(@InputString,0,CHARINDEX(',',@InputString,0)),
        y = SUBSTRING(@InputString,CHARINDEX(',',@InputString,0)+1,LEN(@InputString))
    UNION ALL
    SELECT 
        x = SUBSTRING(y,0,CHARINDEX(',',y,0)),
        y = SUBSTRING(y,CHARINDEX(',',y,0)+1,LEN(y))
    FROM 
        RecursiveCSV 
    WHERE
        SUBSTRING(y,CHARINDEX(',',y,0)+1,LEN(y)) <> '' OR 
        SUBSTRING(y,0,CHARINDEX(',',y,0)) <> ''
)
SELECT
    * 
FROM 
    Tags
WHERE 
    Name IN (select x FROM RecursiveCSV)
OPTION (MAXRECURSION 32767);

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


এখানে এই সমস্যার আরেকটি উত্তর।

(নতুন সংস্করণ 6/4/13 পোস্ট)।

    private static DataSet GetDataSet(SqlConnectionStringBuilder scsb, string strSql, params object[] pars)
    {
        var ds = new DataSet();
        using (var sqlConn = new SqlConnection(scsb.ConnectionString))
        {
            var sqlParameters = new List<SqlParameter>();
            var replacementStrings = new Dictionary<string, string>();
            if (pars != null)
            {
                for (int i = 0; i < pars.Length; i++)
                {
                    if (pars[i] is IEnumerable<object>)
                    {
                        List<object> enumerable = (pars[i] as IEnumerable<object>).ToList();
                        replacementStrings.Add("@" + i, String.Join(",", enumerable.Select((value, pos) => String.Format("@_{0}_{1}", i, pos))));
                        sqlParameters.AddRange(enumerable.Select((value, pos) => new SqlParameter(String.Format("@_{0}_{1}", i, pos), value ?? DBNull.Value)).ToArray());
                    }
                    else
                    {
                        sqlParameters.Add(new SqlParameter(String.Format("@{0}", i), pars[i] ?? DBNull.Value));
                    }
                }
            }
            strSql = replacementStrings.Aggregate(strSql, (current, replacementString) => current.Replace(replacementString.Key, replacementString.Value));
            using (var sqlCommand = new SqlCommand(strSql, sqlConn))
            {
                if (pars != null)
                {
                    sqlCommand.Parameters.AddRange(sqlParameters.ToArray());
                }
                else
                {
                    //Fail-safe, just in case a user intends to pass a single null parameter
                    sqlCommand.Parameters.Add(new SqlParameter("@0", DBNull.Value));
                }
                using (var sqlDataAdapter = new SqlDataAdapter(sqlCommand))
                {
                    sqlDataAdapter.Fill(ds);
                }
            }
        }
        return ds;
    }

চিয়ার্স।


আমি শীর্ষ ভোট দেওয়া উত্তর একটি সংক্ষিপ্ত সংক্ষিপ্ত সংস্করণ ব্যবহার করুন :

List<SqlParameter> parameters = tags.Select((s, i) => new SqlParameter("@tag" + i.ToString(), SqlDbType.NVarChar(50)) { Value = s}).ToList();

var whereCondition = string.Format("tags in ({0})", String.Join(",",parameters.Select(s => s.ParameterName)));

এটি ট্যাগ পরামিতিগুলির মাধ্যমে দুইবার লুপ করে; কিন্তু এটি বেশিরভাগ সময়ই কোন ব্যাপার নয় (এটি আপনার সমস্যা হবে না; যদি এটি হয় তবে লুপটি আনলোল করুন)।

আপনি যদি সত্যিই পারফরমেন্সে আগ্রহী হন এবং লুপের মাধ্যমে পুনরাবৃত্তি করতে না চান তবে এখানে একটি কম সুন্দর সংস্করণ রয়েছে:

var parameters = new List<SqlParameter>();
var paramNames = new List<string>();
for (var i = 0; i < tags.Length; i++)  
{
    var paramName = "@tag" + i;

    //Include size and set value explicitly (not AddWithValue)
    //Because SQL Server may use an implicit conversion if it doesn't know
    //the actual size.
    var p = new SqlParameter(paramName, SqlDbType.NVarChar(50) { Value = tags[i]; } 
    paramNames.Add(paramName);
    parameters.Add(p);
}

var inClause = string.Join(",", paramNames);

আরেকটি সম্ভাব্য সমাধান একটি সংরক্ষিত পদ্ধতিতে একটি পরিবর্তনশীল সংখ্যক আর্গুমেন্ট প্রেরণের পরিবর্তে, আপনার নামের পরে একটি একক স্ট্রিং পাস করুন, তবে তাদের পাশাপাশি তাদের '<>' দিয়ে অনন্য করুন। তারপরে নামগুলি খুঁজতে PATINDEX ব্যবহার করুন:

SELECT * 
FROM Tags 
WHERE PATINDEX('%<' + Name + '>%','<jo>,<john>,<scruffy>,<rubyonrails>') > 0

এখানে অন্য বিকল্প। সঞ্চিত পদ্ধতিতে একটি স্ট্রিং প্যারামিটার হিসাবে কেবল একটি কমা-সীমিত তালিকাটি পাস করুন এবং:

CREATE PROCEDURE [dbo].[sp_myproc]
    @UnitList varchar(MAX) = '1,2,3'
AS
select column from table
where ph.UnitID in (select * from CsvToInt(@UnitList))

এবং ফাংশন:

CREATE Function [dbo].[CsvToInt] ( @Array varchar(MAX))
returns @IntTable table
(IntValue int)
AS
begin
    declare @separator char(1)
    set @separator = ','
    declare @separator_position int
    declare @array_value varchar(MAX)

    set @array = @array + ','

    while patindex('%,%' , @array) <> 0
    begin

        select @separator_position = patindex('%,%' , @array)
        select @array_value = left(@array, @separator_position - 1)

        Insert @IntTable
        Values (Cast(@array_value as int))
        select @array = stuff(@array, 1, @separator_position, '')
    end
    return
end

এখানে একই সমস্যা সমাধান একটি ক্রস পোস্ট। সংরক্ষিত ডেলিমিটারগুলির চেয়ে আরও শক্ত - এতে পালানো এবং নিস্তব্ধ অ্যারে অন্তর্ভুক্ত রয়েছে, এবং NULL এবং খালি অ্যারে বোঝে।

সি # এবং টি-এসকিউএল স্ট্রিং [] প্যাক / ইউনালিটি ফাংশন আনপ্যাক

আপনি তারপর টেবিল মূল্যবান ফাংশন যোগ দিতে পারেন।


এসকিউএল সার্ভার 2016+ এ আরেকটি সম্ভাবনা OPENJSONফাংশন ব্যবহার করা হয় ।

এই পদ্ধতিটি OPENJSON এ ব্লগ করা হয়েছে - আইডস তালিকা দ্বারা সারি নির্বাচন করার সেরা উপায়গুলির মধ্যে একটি

নীচে একটি সম্পূর্ণ কাজ উদাহরণ

CREATE TABLE dbo.Tags
  (
     Name  VARCHAR(50),
     Count INT
  )

INSERT INTO dbo.Tags
VALUES      ('VB',982), ('ruby',1306), ('rails',1478), ('scruffy',1), ('C#',1784)

GO

CREATE PROC dbo.SomeProc
@Tags VARCHAR(MAX)
AS
SELECT T.*
FROM   dbo.Tags T
WHERE  T.Name IN (SELECT J.Value COLLATE Latin1_General_CI_AS
                  FROM   OPENJSON(CONCAT('[', @Tags, ']')) J)
ORDER  BY T.Count DESC

GO

EXEC dbo.SomeProc @Tags = '"ruby","rails","scruffy","rubyonrails"'

DROP TABLE dbo.Tags 

নিম্নলিখিত সংরক্ষিত পদ্ধতি ব্যবহার করুন। এটি একটি কাস্টম বিভক্ত ফাংশন ব্যবহার করে, যা here পাওয়া here

 create stored procedure GetSearchMachingTagNames 
    @PipeDelimitedTagNames varchar(max), 
    @delimiter char(1) 
    as  
    begin
         select * from Tags 
         where Name in (select data from [dbo].[Split](@PipeDelimitedTagNames,@delimiter) 
    end





parameters