संग्रहीत कार्यविधि में सरणी पैरामीटर पास करना


53

मुझे एक प्रक्रिया मिली है जो रिकॉर्ड (1000) का एक गुच्छा पकड़ती है और उन पर काम करती है, और जब मैं पूरा हो जाता हूं, तो मुझे बड़ी संख्या में उन्हें संसाधित करने की आवश्यकता होती है। मैं आईडी की एक बड़ी सूची के साथ इसका संकेत कर सकता हूं। मैं "अपडेट्स इन द लूप" पैटर्न से बचने की कोशिश कर रहा हूं, इसलिए मैं आईडी के इस बैग को एमएस SQL ​​सर्वर 2008 स्टोर किए गए खरीद में भेजने के लिए एक अधिक कुशल तरीका खोजना चाहता हूं।

प्रस्ताव # 1 - तालिका मानदंड पैरामीटर। मैं तालिका प्रकार w / सिर्फ एक ID फ़ील्ड को परिभाषित कर सकता हूं और अपडेट करने के लिए ID से भरी तालिका में भेज सकता हूं।

प्रस्ताव # 2 - XML ​​पैरामीटर (varchar) OPENXML () बॉडी के साथ।

प्रस्ताव # 3 - सूची पार्स करना। मैं इससे बचना चाहता हूँ, यदि संभव हो तो, जैसा कि यह अस्पष्ट और त्रुटि-प्रवण लगता है।

इनमें से कोई वरीयता, या कोई विचार जो मैंने याद किया है?


आपको आईडी की बड़ी सूची कैसे मिल रही है?
लैरी कोलमैन

मैं उन्हें "पेलोड" डेटा के साथ एक और संग्रहीत खरीद के माध्यम से नीचे खींच रहा हूं। मुझे उस सभी डेटा को अपडेट करने की आवश्यकता नहीं है, हालांकि - बस कुछ रिकॉर्ड पर एक ध्वज को अपडेट करें।
डी। लैम्बर्ट

जवाबों:


42

इस मामले पर सबसे अच्छा लेख Erland Sommarskog द्वारा हैं:

वह सभी विकल्पों को शामिल करता है और बहुत अच्छी तरह से समझाता है।

जवाब की कमी के लिए खेद है, लेकिन एरलैंड पर एरलैंड का लेख पेड़ों और अन्य उपचारों पर जो सेल्को की किताबों की तरह है :)


23

StackOverflow पर इसकी बहुत चर्चा है जो कई दृष्टिकोणों को कवर करती है। SQL Server 2008+ के लिए मैं जो पसंद करता हूं वह है टेबल- वैल्यूएटेड मापदंडों का उपयोग करना । यह मूल रूप से आपकी समस्या का SQL सर्वर समाधान है - एक संग्रहीत प्रक्रिया के लिए मूल्यों की सूची में गुजर रहा है।

इस दृष्टिकोण के लाभ हैं:

  • 1 पैरामीटर के रूप में पारित आपके सभी डेटा के साथ एक संग्रहीत कार्यविधि कॉल करें
  • तालिका इनपुट संरचित और दृढ़ता से टाइप किया गया है
  • कोई स्ट्रिंग बिल्डिंग / XML की पार्सिंग या हैंडलिंग
  • आसानी से टेबल इनपुट का उपयोग फ़िल्टर, जुड़ने, या जो भी हो कर सकते हैं

हालाँकि, ध्यान दें: यदि आप एक संग्रहीत कार्यविधि कहते हैं जो ADO.NET या ODBC के माध्यम से TVPs का उपयोग करती है और SQL सर्वर प्रोफाइलर के साथ गतिविधि पर एक नज़र डालें, तो आप देखेंगे कि SQL सर्वर INSERTTVP को लोड करने के लिए कई कथन प्राप्त करता है , प्रत्येक पंक्ति के लिए एक TVP में , प्रक्रिया के लिए कॉल के बाद। यह डिजाइन द्वारा हैINSERTहर बार प्रक्रिया को कहा जाता है, और छोटे ओवरहेड का गठन करने के लिए s के इस बैच को संकलित करने की आवश्यकता होती है। हालांकि, इस ओवरहेड के साथ, टीवीपी अभी भी उपयोग के मामलों के लिए प्रदर्शन और प्रयोज्य के संदर्भ में अन्य दृष्टिकोणों को दूर कर देता है

यदि आप अधिक सीखना चाहते हैं, तो एर्लैंड सोमरसकॉग में पूरी तरह से पतला है कि तालिका-मूल्यवान पैरामीटर कैसे काम करते हैं और कई उदाहरण प्रदान करते हैं।

यहाँ एक और उदाहरण है जो मैंने व्यक्त किया है:

CREATE TYPE id_list AS TABLE (
    id int NOT NULL PRIMARY KEY
);
GO

CREATE PROCEDURE [dbo].[tvp_test] (
      @param1           INT
    , @customer_list    id_list READONLY
)
AS
BEGIN
    SELECT @param1 AS param1;

    -- join, filter, do whatever you want with this table 
    -- (other than modify it)
    SELECT *
    FROM @customer_list;
END;
GO

DECLARE @customer_list id_list;

INSERT INTO @customer_list (
    id
)
VALUES (1), (2), (3), (4), (5), (6), (7);

EXECUTE [dbo].[tvp_test]
      @param1 = 5
    , @customer_list = @customer_list
;
GO

DROP PROCEDURE dbo.tvp_test;
DROP TYPE id_list;
GO

जब मैं इसे चलाता हूं तो मुझे एक त्रुटि मिलती है: Msg 2715, Level 16, State 3, Procedure tvp_test, Line 4 [बैच प्रारंभ लाइन 4] कॉलम, पैरामीटर, या चर # 2: डेटा प्रकार id_list नहीं ढूँढ सकता। पैरामीटर या चर '@customer_list' में एक अमान्य डेटा प्रकार है। Msg 1087, स्तर 16, राज्य 1, प्रक्रिया tvp_test, पंक्ति 13 [बैच प्रारंभ पंक्ति 4] तालिका चर "@customer_list" घोषित करना चाहिए।
डेमियन

@ डामियन - क्या CREATE TYPEशुरुआत में बयान सफलतापूर्वक चला? SQL सर्वर का कौन सा संस्करण चल रहा है?
निक चम्मास

SP कोड में आपके पास यह वाक्य इनलाइन है 'SELECT @ param1 AS param1;' । क्या उद्देश्य है? आप उपयोग या पेराम 1 नहीं करते हैं, इसलिए आपने इसे एसपी हेडर में एक पैरामीटर के रूप में क्यों रखा है?
ईएमेज़

@ ईमेज - यह सिर्फ एक मनमाना उदाहरण था। बात यह @customer_listनहीं है @param1। उदाहरण बस दर्शाता है कि आप विभिन्न पैरामीटर प्रकारों को मिला सकते हैं।
निक चामास

21

पूरे विषय पर चर्चा की है Erland Sommarskog द्वारा निश्चित लेख: "Arrays और SQL सर्वर में सूची" । किस संस्करण को चुनना है, इसका चयन करें।

सारांश, पूर्व SQL सर्वर 2008 के लिए जहां टीवीपी बाकी को ट्रम्प करता है

  • CSV, आप की तरह कैसे विभाजित (मैं आमतौर पर एक संख्या तालिका का उपयोग करता हूं)
  • XML और पार्स (SQL सर्वर 2005+ के साथ बेहतर)
  • क्लाइंट पर एक अस्थायी तालिका बनाएं

लेख अन्य तकनीकों और सोच को देखने के लिए वैसे भी पढ़ने लायक है।

संपादित करें: विशाल सूचियों के लिए कहीं और देर से उत्तर : संग्रहीत मापदंडों के लिए सरणी पैरामीटर पास करना


14

मुझे पता है कि मुझे इस पार्टी के लिए देर हो रही है, लेकिन मुझे अतीत में ऐसी समस्या थी, 100K बिगिंट नंबर तक भेजने और कुछ बेंचमार्क करने के लिए। हमने उन्हें बाइनरी प्रारूप में भेजना समाप्त कर दिया, एक छवि के रूप में - जो कि 100K नंबरों के लिए बाकी सब से तेज था।

यहाँ मेरा पुराना (SQL Server 2005) कोड है:

SELECT  Number * 8 + 1 AS StartFrom ,
        Number * 8 + 8 AS MaxLen
INTO    dbo.ParsingNumbers
FROM    dbo.Numbers
GO

CREATE FUNCTION dbo.ParseImageIntoBIGINTs ( @BIGINTs IMAGE )
RETURNS TABLE
AS RETURN
    ( SELECT    CAST(SUBSTRING(@BIGINTs, StartFrom, 8) AS BIGINT) Num
      FROM      dbo.ParsingNumbers
      WHERE     MaxLen <= DATALENGTH(@BIGINTs)
    )
GO

निम्न कोड पूर्णांक को बाइनरी ब्लॉब में पैक कर रहा है। मैं यहाँ बाइट्स के क्रम को उलट रहा हूँ:

static byte[] UlongsToBytes(ulong[] ulongs)
{
int ifrom = ulongs.GetLowerBound(0);
int ito   = ulongs.GetUpperBound(0);
int l = (ito - ifrom + 1)*8;
byte[] ret = new byte[l];
int retind = 0;
for(int i=ifrom; i<=ito; i++)
{
ulong v = ulongs[i];
ret[retind++] = (byte) (v >> 0x38);
ret[retind++] = (byte) (v >> 0x30);
ret[retind++] = (byte) (v >> 40);
ret[retind++] = (byte) (v >> 0x20);
ret[retind++] = (byte) (v >> 0x18);
ret[retind++] = (byte) (v >> 0x10);
ret[retind++] = (byte) (v >> 8);
ret[retind++] = (byte) v;
}
return ret;
}

9

मैं आपको एसओ को संदर्भित करने या यहां इसका जवाब देने के बीच फट गया हूं, 'क्योंकि यह लगभग एक प्रोग्रामिंग सवाल है। लेकिन जब से मुझे पहले से ही एक समाधान मिला है जिसका मैं उपयोग करता हूं ... मैं इसे पोस्ट करूंगा;)

जिस तरह से यह काम करता है वह है आप एक अल्पविराम सीमांकित स्ट्रिंग (सरल विभाजन, CSV शैली विभाजन को नहीं करता है) को varchar (4000) के रूप में संग्रहीत कार्यविधि में फीड करें और फिर उस सूची को इस फ़ंक्शन में फ़ीड करें और एक आसान तालिका वापस प्राप्त करें, बस varchars की एक तालिका।

यह आपको केवल उन आईडी के मूल्यों को भेजने की अनुमति देता है जिन्हें आप संसाधित करना चाहते हैं, और आप उस बिंदु पर एक साधारण जुड़ाव कर सकते हैं।

वैकल्पिक रूप से आप सीएलआर डेटाटेबल के साथ कुछ कर सकते हैं और उस में फ़ीड कर सकते हैं, लेकिन यह समर्थन के लिए थोड़ा अधिक उपरि है और हर कोई सीएसवी सूचियों को समझता है।

USE [Database]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO

ALTER FUNCTION [dbo].[splitListToTable] (@list      nvarchar(MAX), @delimiter nchar(1) = N',')
      RETURNS @tbl TABLE (value     varchar(4000)      NOT NULL) AS
/*
http://www.sommarskog.se/arrays-in-sql.html
This guy is apparently THE guy in SQL arrays and lists 

Need an easy non-dynamic way to split a list of strings on input for comparisons

Usage like thus:

DECLARE @sqlParam VARCHAR(MAX)
SET @sqlParam = 'a,b,c'

SELECT * FROM (

select 'a' as col1, '1' as col2 UNION
select 'a' as col1, '2' as col2 UNION
select 'b' as col1, '3' as col2 UNION
select 'b' as col1, '4' as col2 UNION
select 'c' as col1, '5' as col2 UNION
select 'c' as col1, '6' as col2 ) x 
WHERE EXISTS( SELECT value FROM splitListToTable(@sqlParam,',') WHERE x.col1 = value )

*/
BEGIN
   DECLARE @endpos   int,
           @startpos int,
           @textpos  int,
           @chunklen smallint,
           @tmpstr   nvarchar(4000),
           @leftover nvarchar(4000),
           @tmpval   nvarchar(4000)

   SET @textpos = 1
   SET @leftover = ''
   WHILE @textpos <= datalength(@list) / 2
   BEGIN
      SET @chunklen = 4000 - datalength(@leftover) / 2
      SET @tmpstr = @leftover + substring(@list, @textpos, @chunklen)
      SET @textpos = @textpos + @chunklen

      SET @startpos = 0
      SET @endpos = charindex(@delimiter, @tmpstr)

      WHILE @endpos > 0
      BEGIN
         SET @tmpval = ltrim(rtrim(substring(@tmpstr, @startpos + 1,
                                             @endpos - @startpos - 1)))
         INSERT @tbl (value) VALUES(@tmpval)
         SET @startpos = @endpos
         SET @endpos = charindex(@delimiter, @tmpstr, @startpos + 1)
      END

      SET @leftover = right(@tmpstr, datalength(@tmpstr) / 2 - @startpos)
   END

   INSERT @tbl(value) VALUES (ltrim(rtrim(@leftover)))
   RETURN
END

ठीक है, मैं विशेष रूप से अल्पविराम-सीमांकित सूची से बचने की कोशिश कर रहा था ताकि मुझे ऐसा कुछ लिखना न पड़े, लेकिन चूंकि यह पहले से ही लिखा गया है, इसलिए मुझे लगता है कि मुझे उस समाधान को मिश्रण में वापस फेंकना होगा। ;-)
डी। लैम्बर्ट

1
मैं कहता हूं कि कोशिश की और सच करना आसान है। आप कोड के सेकंड में एक कॉमा से अलग की गई सूची को C # में थूक सकते हैं, और आप इसे इस कार्य में टॉस कर सकते हैं (इसे अपने स्पोक में प्राप्त करने के बाद) बहुत जल्दी, और आपको इसके बारे में शायद ही सोचना भी नहीं है। ~ और मैं तुम्हें कहा था कि आप एक समारोह का उपयोग नहीं करना चाहता था पता है, लेकिन मुझे लगता है कि यह सबसे आसान तरीका है (शायद नहीं सबसे प्रभावी) है
jcolebrand

5

मैं नियमित रूप से हमारे आवेदन से भेजी गई पंक्तियों और 10000 पंक्तियों की विभिन्न पंक्तियों के सेट प्राप्त करता हूं, जिन्हें विभिन्न SQL सर्वर संग्रहीत प्रक्रियाओं द्वारा संसाधित किया जाता है।

प्रदर्शन की मांगों को पूरा करने के लिए, हम टीवीपी का उपयोग करते हैं, लेकिन आपको अपने स्वयं के अमूर्त को dbDataReader को क्रियान्वित करना चाहिए ताकि इसके डिफ़ॉल्ट-मोड प्रसंस्करण में कुछ प्रदर्शन समस्याओं को दूर किया जा सके। मैं इस अनुरोध के दायरे से बाहर होने के कारण मैं वहां नहीं जाऊंगा।

मैंने XML प्रसंस्करण पर विचार नहीं किया क्योंकि मुझे एक XML कार्यान्वयन नहीं मिला है जो 10,000 से अधिक "पंक्तियों" के साथ प्रदर्शनशील रहता है।

सूची प्रसंस्करण को एकल-आयाम और डबल-आयाम टैली (संख्या) तालिका प्रसंस्करण द्वारा नियंत्रित किया जा सकता है। हमने विभिन्न क्षेत्रों में इनका सफलतापूर्वक उपयोग किया है, लेकिन अच्छी तरह से प्रबंधित टीवीपी अधिक प्रदर्शन करते हैं जब कुछ सौ "पंक्तियों" से अधिक होते हैं।

SQL सर्वर प्रोसेसिंग के बारे में सभी विकल्पों के साथ, आपको उपयोग मॉडल के आधार पर अपनी पसंद का चयन करना होगा।


5

मुझे आखिरकार कुछ टेबलवैलिडपैरेटर्स करने का मौका मिला और वे बहुत अच्छे काम करते हैं, इसलिए मैं एक संपूर्ण कोड कोड पेस्ट करने जा रहा हूं, जिसमें दिखाया गया है कि मैं अपने वर्तमान कोड के कुछ नमूने के साथ उनका उपयोग कैसे कर रहा हूं: (नोट: हम ADO का उपयोग करते हैं। नेट)

यह भी नोट करें: मैं एक सेवा के लिए कुछ कोड लिख रहा हूं, और मुझे दूसरी कक्षा में बहुत सारे पूर्वनिर्धारित कोड बिट्स मिल गए हैं, लेकिन मैं इसे एक कंसोल ऐप के रूप में लिख रहा हूं, इसलिए मैं इसे डीबग कर सकता हूं, इसलिए मैंने यह सब चीर डाला कंसोल ऐप। मेरी कोडिंग शैली (हार्डकोड कनेक्शन स्ट्रिंग्स की तरह) को बहाना करें क्योंकि यह "एक को फेंकने के लिए निर्माण" था। मैं यह दिखाना चाहता था कि मैं कैसे एक का उपयोग करता हूं List<customObject>और इसे डेटाबेस में एक तालिका के रूप में आसानी से धकेल देता हूं, जिसे मैं संग्रहीत प्रक्रिया में उपयोग कर सकता हूं। नीचे C # और TSQL कोड:

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using a;

namespace a.EventAMI {
    class Db {
        private static SqlCommand SqlCommandFactory(string sprocName, SqlConnection con) { return new SqlCommand { CommandType = CommandType.StoredProcedure, CommandText = sprocName, CommandTimeout = 0, Connection = con }; }

        public static void Update(List<Current> currents) {
            const string CONSTR = @"just a hardwired connection string while I'm debugging";
            SqlConnection con = new SqlConnection( CONSTR );

            SqlCommand cmd = SqlCommandFactory( "sprocname", con );
            cmd.Parameters.Add( "@CurrentTVP", SqlDbType.Structured ).Value = Converter.GetDataTableFromIEnumerable( currents, typeof( Current ) ); //my custom converter class

            try {
                using ( con ) {
                    con.Open();
                    cmd.ExecuteNonQuery();
                }
            } catch ( Exception ex ) {
                ErrHandler.WriteXML( ex );
                throw;
            }
        }
    }
    class Current {
        public string Identifier { get; set; }
        public string OffTime { get; set; }
        public DateTime Off() {
            return Convert.ToDateTime( OffTime );
        }

        private static SqlCommand SqlCommandFactory(string sprocName, SqlConnection con) { return new SqlCommand { CommandType = CommandType.StoredProcedure, CommandText = sprocName, CommandTimeout = 0, Connection = con }; }

        public static List<Current> GetAll() {
            List<Current> l = new List<Current>();

            const string CONSTR = @"just a hardcoded connection string while I'm debugging";
            SqlConnection con = new SqlConnection( CONSTR );

            SqlCommand cmd = SqlCommandFactory( "sprocname", con );

            try {
                using ( con ) {
                    con.Open();
                    using ( SqlDataReader reader = cmd.ExecuteReader() ) {
                        while ( reader.Read() ) {
                            l.Add(
                                new Current {
                                    Identifier = reader[0].ToString(),
                                    OffTime = reader[1].ToString()
                                } );
                        }
                    }

                }
            } catch ( Exception ex ) {
                ErrHandler.WriteXML( ex );
                throw;
            }

            return l;
        }
    }
}

-------------------
the converter class
-------------------
using System;
using System.Collections;
using System.Data;
using System.Reflection;

namespace a {
    public static class Converter {
        public static DataTable GetDataTableFromIEnumerable(IEnumerable aIEnumerable) {
            return GetDataTableFromIEnumerable( aIEnumerable, null );
        }

        public static DataTable GetDataTableFromIEnumerable(IEnumerable aIEnumerable, Type baseType) {
            DataTable returnTable = new DataTable();

            if ( aIEnumerable != null ) {
                //Creates the table structure looping in the in the first element of the list
                object baseObj = null;

                Type objectType;

                if ( baseType == null ) {
                    foreach ( object obj in aIEnumerable ) {
                        baseObj = obj;
                        break;
                    }

                    objectType = baseObj.GetType();
                } else {
                    objectType = baseType;
                }

                PropertyInfo[] properties = objectType.GetProperties();

                DataColumn col;

                foreach ( PropertyInfo property in properties ) {
                    col = new DataColumn { ColumnName = property.Name };
                    if ( property.PropertyType == typeof( DateTime? ) ) {
                        col.DataType = typeof( DateTime );
                    } else if ( property.PropertyType == typeof( Int32? ) ) {
                        col.DataType = typeof( Int32 );
                    } else {
                        col.DataType = property.PropertyType;
                    }
                    returnTable.Columns.Add( col );
                }

                //Adds the rows to the table

                foreach ( object objItem in aIEnumerable ) {
                    DataRow row = returnTable.NewRow();

                    foreach ( PropertyInfo property in properties ) {
                        Object value = property.GetValue( objItem, null );
                        if ( value != null )
                            row[property.Name] = value;
                        else
                            row[property.Name] = "";
                    }

                    returnTable.Rows.Add( row );
                }
            }
            return returnTable;
        }

    }
}

USE [Database]
GO

SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO

ALTER PROC [dbo].[Event_Update]
    @EventCurrentTVP    Event_CurrentTVP    READONLY
AS

/****************************************************************
    author  cbrand
    date    
    descrip I'll ask you to forgive me the anonymization I've made here, but hope this helps
    caller  such and thus application
****************************************************************/

BEGIN TRAN Event_Update

DECLARE @DEBUG INT

SET @DEBUG = 0 /* test using @DEBUG <> 0 */

/*
    Replace the list of outstanding entries that are still currently disconnected with the list from the file
    This means remove all existing entries (faster to truncate and insert than to delete on a join and insert, yes?)
*/
TRUNCATE TABLE [database].[dbo].[Event_Current]

INSERT INTO [database].[dbo].[Event_Current]
           ([Identifier]
            ,[OffTime])
SELECT [Identifier]
      ,[OffTime]
  FROM @EventCurrentTVP

IF (@@ERROR <> 0 OR @DEBUG <> 0) 
BEGIN
ROLLBACK TRAN Event_Update
END
ELSE
BEGIN
COMMIT TRAN Event_Update
END

USE [Database]
GO

CREATE TYPE [dbo].[Event_CurrentTVP] AS TABLE(
    [Identifier] [varchar](20) NULL,
    [OffTime] [datetime] NULL
)
GO

इसके अलावा, यदि आप के पास (सभी पाठकों के लिए जो इस सवाल पर आते हैं) को प्रस्तुत करने के लिए, लेकिन कृपया इसे रचनात्मक रूप से रखें; । उम्मीद है कि कोड के इस भाग के साथ एक देख सकते हैं कि वे कैसे उपयोग कर सकते हैं List<Current>जैसा कि मैंने इसे db में तालिका के रूप में परिभाषित किया है और List<T>उनके ऐप में।


3

मैं या तो प्रस्ताव # 1 के साथ जाऊंगा या, एक विकल्प के रूप में, एक स्क्रैच टेबल बनाऊंगा जो सिर्फ प्रोसेस्ड आईडी रखता है। प्रसंस्करण के दौरान उस तालिका में सम्मिलित करें, फिर एक बार समाप्त होने के बाद, नीचे के समान एक खरीद को बुलाएं:

BEGIN TRAN

UPDATE dt
SET processed = 1
FROM dataTable dt
JOIN processedIds pi ON pi.id = dt.id;

TRUNCATE TABLE processedIds

COMMIT TRAN

आप कई आवेषण करेंगे, लेकिन वे एक छोटी मेज पर होंगे, इसलिए यह तेज़ होना चाहिए। आप ADO.net या आपके द्वारा उपयोग किए जा रहे डेटा एडेप्टर का उपयोग करके अपनी आवेषण को बैच सकते हैं।


2

प्रश्न शीर्षक में किसी एप्लिकेशन से संग्रहीत प्रक्रिया में डेटा प्रसारित करने का कार्य शामिल है। उस भाग को प्रश्न निकाय द्वारा बाहर रखा गया है, लेकिन मुझे इसका उत्तर देने का प्रयास करें।

एसक्यूएल-सर्वर -2008 के संदर्भ में टैग द्वारा निर्दिष्ट के रूप में ई। सोमरसकॉग एरेज़ और लिस्ट्स द्वारा एसक्यूएल सर्वर 2008 में एक और शानदार लेख है । BTW मैं यह लेख में पाया गया कि मैरियन ने अपने जवाब में संदर्भित किया।

केवल लिंक देने के बजाय, मैं इसकी सामग्री की सूची उद्धृत करता हूं:

  • परिचय
  • पृष्ठभूमि
  • टी-एसक्यूएल में टेबल-वेलिड पैरामीटर
  • ADO .NET से टेबल-वैलिड पैरामीटर्स पास करना
    • एक सूची का उपयोग करना
    • DataTable का उपयोग करना
    • DataReader का उपयोग करना
    • अंतिम टिप्पणी
  • अन्य एपीआई से टेबल-वैलिड पैरामीटर का उपयोग करना
    • ODBC
    • OLE DB
    • एडीओ
    • LINQ और इकाई फ्रेमवर्क
    • JDBC
    • पीएचपी
    • पर्ल
    • क्या होगा यदि आपका एपीआई टीवीपी का समर्थन नहीं करता है
  • प्रदर्शन के विचार
    • सर्वर साइड
    • ग्राहक की ओर
    • प्राथमिक कुंजी या नहीं?
  • आभार और प्रतिक्रिया
  • संशोधन इतिहास

वहां बताई गई तकनीकों से परे, मुझे यह महसूस होता है कि कुछ मामलों में सामान्य मामले में स्कोपॉपी और बल्क इंसर्ट का उल्लेख किया जा सकता है।


1

संग्रहीत कार्यविधि में सरणी पैरामीटर पास करना

MS SQL 2016 के लिए नवीनतम संस्करण

MS SQL 2016 के साथ वे एक नया फ़ंक्शन शुरू करते हैं: कई मानों को पार्स करने के लिए SPLIT_STRING ()

इससे आपकी समस्या आसानी से हल हो सकती है।

एमएस SQL ​​पुराने संस्करण के लिए

यदि आप पुराने संस्करण का उपयोग कर रहे हैं, तो इस चरण का अनुसरण करें:

पहले एक समारोह करें:

 ALTER FUNCTION [dbo].[UDF_IDListToTable]
 (
    @list          [varchar](MAX),
    @Seperator     CHAR(1)
  )
 RETURNS @tbl TABLE (ID INT)
 WITH 

 EXECUTE AS CALLER
 AS
  BEGIN
    DECLARE @position INT
    DECLARE @NewLine CHAR(2) 
    DECLARE @no INT
    SET @NewLine = CHAR(13) + CHAR(10)

    IF CHARINDEX(@Seperator, @list) = 0
    BEGIN
    INSERT INTO @tbl
    VALUES
      (
        @list
      )
END
ELSE
BEGIN
    SET @position = 1
    SET @list = @list + @Seperator
    WHILE CHARINDEX(@Seperator, @list, @position) <> 0
    BEGIN
        SELECT @no = SUBSTRING(
                   @list,
                   @position,
                   CHARINDEX(@Seperator, @list, @position) - @position
               )

        IF @no <> ''
            INSERT INTO @tbl
            VALUES
              (
                @no
              )

        SET @position = CHARINDEX(@Seperator, @list, @position) + 1
    END
END
RETURN
END

इसे बनाने के बाद, अपने स्ट्रिंग को विभाजक के साथ इस फ़ंक्शन में पास करें।

मैं उम्मीद करता हूँ यह आप के लिए उपयोगी है। :-)


-1

"Create type table" बनाने के लिए इसका उपयोग करें। उपयोगकर्ता के लिए सरल उदाहरण

CREATE TYPE unit_list AS TABLE (
    ItemUnitId int,
    Amount float,
    IsPrimaryUnit bit
);

GO
 CREATE TYPE specification_list AS TABLE (
     ItemSpecificationMasterId int,
    ItemSpecificationMasterValue varchar(255)
);

GO
 declare @units unit_list;
 insert into @units (ItemUnitId, Amount, IsPrimaryUnit) 
  values(12,10.50, false), 120,100.50, false), (1200,500.50, true);

 declare @spec specification_list;
  insert into @spec (ItemSpecificationMasterId,temSpecificationMasterValue) 
   values (12,'test'), (124,'testing value');

 exec sp_add_item "mytests", false, @units, @spec


//Procedure definition
CREATE PROCEDURE sp_add_item
(   
    @Name nvarchar(50),
    @IsProduct bit=false,
    @UnitsArray unit_list READONLY,
    @SpecificationsArray specification_list READONLY
)
AS


BEGIN
    SET NOCOUNT OFF     

    print @Name;
    print @IsProduct;       
    select * from @UnitsArray;
    select * from @SpecificationsArray;
END
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.