נניח למשל שיש לי אתה מכירות, תהיה לי טבלת הזמנות, לשמירה של ההזמנה עצמה, ותהיה לי טבלה של מוצרים-לרשימה שבה ישמרו המוצרים שקשורים לרשימה. איך אפשר לשלוח את הרשימה של המוצרים כשכל מוצר הוא אובייקט עם מידע, למשל קוד המוצר, כמות מוזמנת וכו'

אפשר לשלוח את המוצרים אחד אחרי השני, זה יהיה הקוד של ה-API:

using System.Data.SqlClient;

public class OrderItem
{
    public int OrderId { get; set; }
    public int ProductId { get; set; }
    public decimal Price { get; set; }
    // Other properties
}

public void SaveOrderItems(List<OrderItem> orderItems)
{
    using (SqlConnection conn = new SqlConnection(connectionString))
    {
        conn.Open();

        using (SqlTransaction transaction = conn.BeginTransaction())
        {
            try
            {
                foreach (var item in orderItems)
                {
                    using (SqlCommand cmd = new SqlCommand("INSERT INTO orderItems (OrderId, ProductId, Price) VALUES (@OrderId, @ProductId, @Price)", conn, transaction))
                    {
                        cmd.Parameters.AddWithValue("@OrderId", item.OrderId);
                        cmd.Parameters.AddWithValue("@ProductId", item.ProductId);
                        cmd.Parameters.AddWithValue("@Price", item.Price);
                        // Add other parameters as necessary

                        cmd.ExecuteNonQuery();
                    }
                }

                transaction.Commit();
            }
            catch
            {
                transaction.Rollback();
                throw;
            }
        }
    }
}

הבעיה היא שזה לא מתאם אם רוצים לחסוך במשאבים.

הדרך היותר יעילה לשלוח את הרשימה היא על ידי יצירה מקומית של טבלה ב-API ושליחה של כל הטבלה כמשתנה ל-SQL.

שלב 1: יצירת סוג הטבלה ב-SQL, הטבלה הזאת תקבל את הנתונים שיגיעו.

CREATE TYPE dbo.OrderItemType AS TABLE
(
    OrderId INT,
    ProductId INT,
    Price DECIMAL(18, 2)
    -- Define other columns as needed
);

במקרה הזה יש לי טבלת ItemsOrder שאליה אני רוצה להכניס את הנתונים, הטבלה שאני יוצרת עכשיו היא מעין טבלה מקשרת שמקבלת אליה את הנתונים מה-API ומכניסה אותם לטבלת ItemsOrder.

את ההגדרות של הטבלה אפשר למצוא אחר כך תחת תיקיית Programming של מסד הנתונים בתוך תיקיית Type ושם ב- User-Defined Table Types.

בטבלה הזאת אני מגדירה רק את הפרמטרים שמגיעים מה-API, אין צורך להגדיר את כל השדות של הטבלה שאליה אני רוצה להכניס את הנתונים.

לא להגדיר בטבלה שדות של מספור אוטומטי שקיימים בטבלה אליה הנתונים נכנסים, הם אמורים לתת ערך לעצמם.

שלב 2: יצירת הפרוצדורה שמקבלת את הטבלה.

CREATE PROCEDURE dbo.InsertOrderItems
    @OrderItems dbo.OrderItemType READONLY
AS
BEGIN
    INSERT INTO orderItems (OrderId, ProductId, Price)
    SELECT OrderId, ProductId, Price FROM @OrderItems;
END;

הפרמטר של הפרוצדורה הזאת הוא טבלה. אנחנו מכניסים בהתאמה את השדות מהטבלה שקיבלנו כפרמטר לטבלה שאליה הנתונים צריכים להדיע.

שלב 3: יצירת טבלה ב-C# ששולחת את הנתונים.

public void SaveOrderItems(List<OrderItem> orderItems)
{
    using (SqlConnection conn = new SqlConnection(connectionString))
    {
        conn.Open();

        using (SqlCommand cmd = new SqlCommand("dbo.InsertOrderItems", conn))
        {
            cmd.CommandType = CommandType.StoredProcedure;

            DataTable table = new DataTable();
            table.Columns.Add("OrderId", typeof(int));
            table.Columns.Add("ProductId", typeof(int));
            table.Columns.Add("Price", typeof(decimal));
            // Add other columns as necessary

            foreach (var item in orderItems)
            {
                table.Rows.Add(item.OrderId, item.ProductId, item.Price);
                // Add other values as necessary
            }

            SqlParameter tvpParam = cmd.Parameters.AddWithValue("@OrderItems", table);
            tvpParam.SqlDbType = SqlDbType.Structured;
            tvpParam.TypeName = "dbo.OrderItemType";

            cmd.ExecuteNonQuery();
        }
    }
}

1. קריאה סדרתית לפרוצדורות.

using (SqlConnection conn = new SqlConnection(connectionString))
{
    conn.Open();
    using (SqlCommand cmd = new SqlCommand("StoredProcedure1", conn))
    {
        cmd.CommandType = CommandType.StoredProcedure;
        // Set parameters for cmd here
        cmd.ExecuteNonQuery();
    }
    using (SqlCommand cmd = new SqlCommand("StoredProcedure2", conn))
    {
        cmd.CommandType = CommandType.StoredProcedure;
        // Set parameters for cmd here
        cmd.ExecuteNonQuery();
    }
}

2. עטיפת 2 הפוצדורות בשלישית ב-SQL וקריאה לפרוצדורה העוטפת.

קוד ה-SQL יראה כך:

CREATE PROCEDURE dbo.WrapperProcedure
AS
BEGIN
    EXEC dbo.StoredProcedure1;
    EXEC dbo.StoredProcedure2;
END;

קוד ה-API יקרא לפרוצדורה:

using (SqlConnection conn = new SqlConnection(connectionString))
{
    conn.Open();
    using (SqlCommand cmd = new SqlCommand("WrapperProcedure", conn))
    {
        cmd.CommandType = CommandType.StoredProcedure;
        cmd.ExecuteNonQuery();
    }
}

אם יש צורך לשלוח פרמטרים לשתי הפרוצדורות, נגדיר את כל הפרמטרים ב-API ונקבל לכל פרוצדורה את הפרמטרים שמתאימים לה.

כל פרוצדורה מקבלת את הפרמטרים שלה:

CREATE PROCEDURE dbo.WrapperProcedure
    @Param1 DataType1,
    @Param2 DataType2
AS
BEGIN
    -- Call the first stored procedure
    EXEC dbo.StoredProcedure1 @Param1;

    -- Call the second stored procedure
    EXEC dbo.StoredProcedure2 @Param2;
END;

בקריאה של ה-API כל הפרמטרים נשלחים יחד:

using System.Data;
using System.Data.SqlClient;

// ...

using (SqlConnection conn = new SqlConnection(connectionString))
{
    conn.Open();

    using (SqlCommand cmd = new SqlCommand("WrapperProcedure", conn))
    {
        cmd.CommandType = CommandType.StoredProcedure;

        // Add parameters for the wrapper procedure
        cmd.Parameters.Add(new SqlParameter("@Param1", valueForParam1));
        cmd.Parameters.Add(new SqlParameter("@Param2", valueForParam2));

        // Execute the wrapper procedure
        cmd.ExecuteNonQuery();
    }
}

ALTER TABLE table_name
ALTER COLUMN column_name datatype;

למשל אם אני רוצה לשנות את אורך התיאור בטבלת המוצרים שלי, הקוד יהיה כזה:

ALTER TABLE product
ALTER COLUMN description VARCHAR(250);

אם רוצים לעשות שינוי כך שעמודה תקבל מספור אוטומטי, אי אפשר לעשות את זה ישירות, צריך קודם לבטל את העמודה הקיימת ואז להוסיף אותה מחדש.

ALTER TABLE YourTable
DROP COLUMN OldColumn;

אחרי ביטול העמודה:

ALTER TABLE YourTable
ADD NewColumn INT IDENTITY(1,1);

אם העמודה היא גם מפתח ראשי, זה יראה ככה:

ALTER TABLE YourTable
ADD NewColumn INT IDENTITY(1,1) PRIMARY KEY;

צריך לשים לב, שאם העמודה מוגדרת כמפתח ראשי, אי אפשר לבטל אותה. צריך קודם לבל את המפתח הראשי. כדי לעשות את זה צריך את השם של המפתח הראשי. 

ב-SQL Server זה נמצא תחת תיקיית Keys שנמצאת מתחת לטבלה.

מבטלים את המפתח הראשי:

ALTER TABLE YourTable
DROP CONSTRAINT PK_YourTable_CurrentPrimaryKey;

ואז אפשר לבטל את העמודה.

כדי להגדיר עמודה כמפתח ראשי, נשתמש בקוד הבא:

ALTER TABLE YourTable
ADD CONSTRAINT PK_YourTable_NewPrimaryKey PRIMARY KEY (NewPrimaryKeyColumn);

אם לא מצליחים למצוא את השם של המפתח הראשי, אפשר להשתמש בקוד הבא:

SELECT *
FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS
WHERE TABLE_NAME = 'YourTableName' AND CONSTRAINT_TYPE = 'PRIMARY KEY';