Datos FILESTREAMFILESTREAM Data

El atributo de almacenamiento FILESTREAM es para los datos binarios (BLOB) almacenados en una columna varbinary(max).The FILESTREAM storage attribute is for binary (BLOB) data stored in a varbinary(max) column. Antes de FILESTREAM, los datos binarios de almacenamiento necesitaban un control especial.Before FILESTREAM, storing binary data required special handling. Los datos no estructurados, como los documentos de texto, imágenes y vídeo, se suelen almacenar fuera de la base de datos, con lo que resulta difícil administrarlos.Unstructured data, such as text documents, images and video, is often stored outside of the database, making it difficult to manage.

Nota

Debe instalar .NET Framework 3.5 Service Pack 1 (o posterior) para trabajar con datos de FILESTREAM con SqlClient.You must install the .NET Framework 3.5 SP1 (or later) to work with FILESTREAM data using SqlClient.

La especificación del atributo FILESTREAM en una columna varbinary(max) provoca que SQL Server almacene los datos en el sistema de archivos NTFS local en lugar de hacerlo en el archivo de base de datos.Specifying the FILESTREAM attribute on a varbinary(max) column causes SQL Server to store the data on the local NTFS file system instead of in the database file. Aunque se almacenan por separado, puede usar las mismas instrucciones Transact-SQLTransact-SQL admitidas para trabajar con los datos varbinary(max) almacenados en la base de datos.Although it is stored separately, you can use the same Transact-SQLTransact-SQL statements that are supported for working with varbinary(max) data that is stored in the database.

Compatibilidad de SqlClient con FILESTREAMSqlClient Support for FILESTREAM

El .NET Framework.NET Framework proveedor de datos para SQL Server, System.Data.SqlClient, admite la lectura y escritura de datos de FILESTREAM mediante el SqlFileStream clase definida en el System.Data.SqlTypes espacio de nombres.The .NET Framework.NET Framework Data Provider for SQL Server, System.Data.SqlClient, supports reading and writing to FILESTREAM data using the SqlFileStream class defined in the System.Data.SqlTypes namespace. SqlFileStream hereda de la clase Stream, que proporciona métodos para leer y escribir en flujos de datos.SqlFileStream inherits from the Stream class, which provides methods for reading and writing to streams of data. La lectura de una secuencia transfiere los datos desde la secuencia a una estructura de datos como, por ejemplo, una matriz de bytes.Reading from a stream transfers data from the stream into a data structure, such as an array of bytes. La escritura transfiere los datos desde la estructura de datos hasta una secuencia.Writing transfers the data from the data structure into a stream.

Crear la tabla de SQL ServerCreating the SQL Server Table

Las siguientes instrucciones Transact-SQLTransact-SQL crean una tabla denominada employees e insertan una fila de datos.The following Transact-SQLTransact-SQL statements creates a table named employees and inserts a row of data. Una vez que ha habilitado el almacenamiento de FILESTREAM, puede usar esta tabla junto con los ejemplos de código que figuran a continuación.Once you have enabled FILESTREAM storage, you can use this table in conjunction with the code examples that follow. Los vínculos a recursos en los libros en pantalla de SQL Server se encuentran al final de este tema.The links to resources in SQL Server Books Online are located at the end of this topic.

CREATE TABLE employees  
(  
  EmployeeId INT  NOT NULL  PRIMARY KEY,  
  Photo VARBINARY(MAX) FILESTREAM  NULL,  
  RowGuid UNIQUEIDENTIFIER  NOT NULL  ROWGUIDCOL  
  UNIQUE DEFAULT NEWID()  
)  
GO  
Insert into employees  
Values(1, 0x00, default)  
GO  

Ejemplo: leer, sobrescribir e insertar datos de FILESTREAMExample: Reading, Overwriting, and Inserting FILESTREAM Data

En el ejemplo siguiente se muestra cómo se leen datos de un FILESTREAM.The following sample demonstrates how to read data from a FILESTREAM. El código obtiene la ruta de acceso lógica del archivo, y establece FileAccess en Read y FileOptions en SequentialScan.The code gets the logical path to the file, setting the FileAccess to Read and the FileOptions to SequentialScan. El código lee después los bytes del SqlFileStream en el búfer.The code then reads the bytes from the SqlFileStream into the buffer. Después los bytes se escriben en la ventana de la consola.The bytes are then written to the console window.

En el ejemplo se muestra también cómo se escriben datos en un FILESTREAM en el que se sobrescriben todos los datos existentes.The sample also demonstrates how to write data to a FILESTREAM in which all existing data is overwritten. El código obtiene la ruta de acceso lógica del archivo y crea SqlFileStream, y establece FileAccess en Write y FileOptions en SequentialScan.The code gets the logical path to the file and creates the SqlFileStream, setting the FileAccess to Write and the FileOptions to SequentialScan. Se escribe un byte único en SqlFileStream, que remplaza los datos del archivo.A single byte is written to the SqlFileStream, replacing any data in the file.

En el ejemplo también se muestra cómo se escriben datos en un FILESTREAM mediante el método Seek para anexar los datos al final del archivo.The sample also demonstrates how to write data to a FILESTREAM by using the Seek method to append data to the end of the file. El código obtiene la ruta de acceso lógica del archivo y crea SqlFileStream, y establece FileAccess en ReadWrite y FileOptions en SequentialScan.The code gets the logical path to the file and creates the SqlFileStream, setting the FileAccess to ReadWrite and the FileOptions to SequentialScan. El código usa el método Seek para buscar hasta el final del archivo, y anexa un byte único al archivo existente.The code uses the Seek method to seek to the end of the file, appending a single byte to the existing file.

using System;  
using System.Data.SqlClient;  
using System.Data.SqlTypes;  
using System.Data;  
using System.IO;  

namespace FileStreamTest  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder("server=(local);integrated security=true;database=myDB");  
            ReadFilestream(builder);  
            OverwriteFilestream(builder);  
            InsertFilestream(builder);  

            Console.WriteLine("Done");  
        }  

        private static void ReadFilestream(SqlConnectionStringBuilder connStringBuilder)  
        {  
            using (SqlConnection connection = new SqlConnection(connStringBuilder.ToString()))  
            {  
                connection.Open();  
                SqlCommand command = new SqlCommand("SELECT TOP(1) Photo.PathName(), GET_FILESTREAM_TRANSACTION_CONTEXT() FROM employees", connection);  

                SqlTransaction tran = connection.BeginTransaction(IsolationLevel.ReadCommitted);  
                command.Transaction = tran;  

                using (SqlDataReader reader = command.ExecuteReader())  
                {  
                    while (reader.Read())  
                    {  
                        // Get the pointer for the file  
                        string path = reader.GetString(0);  
                        byte[] transactionContext = reader.GetSqlBytes(1).Buffer;  

                        // Create the SqlFileStream  
                        using (Stream fileStream = new SqlFileStream(path, transactionContext, FileAccess.Read, FileOptions.SequentialScan, allocationSize: 0))  
                        {  
                            // Read the contents as bytes and write them to the console  
                            for (long index = 0; index < fileStream.Length; index++)  
                            {  
                                Console.WriteLine(fileStream.ReadByte());  
                            }  
                        }  
                    }  
                }  
                tran.Commit();  
            }  
        }  

        private static void OverwriteFilestream(SqlConnectionStringBuilder connStringBuilder)  
        {  
            using (SqlConnection connection = new SqlConnection(connStringBuilder.ToString()))  
            {  
                connection.Open();  

                SqlCommand command = new SqlCommand("SELECT TOP(1) Photo.PathName(), GET_FILESTREAM_TRANSACTION_CONTEXT() FROM employees", connection);  

                SqlTransaction tran = connection.BeginTransaction(IsolationLevel.ReadCommitted);  
                command.Transaction = tran;  

                using (SqlDataReader reader = command.ExecuteReader())  
                {  
                    while (reader.Read())  
                    {  
                        // Get the pointer for file   
                        string path = reader.GetString(0);  
                        byte[] transactionContext = reader.GetSqlBytes(1).Buffer;  

                        // Create the SqlFileStream  
                        using (Stream fileStream = new SqlFileStream(path, transactionContext, FileAccess.Write, FileOptions.SequentialScan, allocationSize: 0))  
                        {  
                            // Write a single byte to the file. This will  
                            // replace any data in the file.  
                            fileStream.WriteByte(0x01);  
                        }  
                    }  
                }  
                tran.Commit();  
            }  
        }  

        private static void InsertFilestream(SqlConnectionStringBuilder connStringBuilder)  
        {  
            using (SqlConnection connection = new SqlConnection(connStringBuilder.ToString()))  
            {  
                connection.Open();  

                SqlCommand command = new SqlCommand("SELECT TOP(1) Photo.PathName(), GET_FILESTREAM_TRANSACTION_CONTEXT() FROM employees", connection);  

                SqlTransaction tran = connection.BeginTransaction(IsolationLevel.ReadCommitted);  
                command.Transaction = tran;  

                using (SqlDataReader reader = command.ExecuteReader())  
                {  
                    while (reader.Read())  
                    {  
                        // Get the pointer for file  
                        string path = reader.GetString(0);  
                        byte[] transactionContext = reader.GetSqlBytes(1).Buffer;  

                        using (Stream fileStream = new SqlFileStream(path, transactionContext, FileAccess.ReadWrite, FileOptions.SequentialScan, allocationSize: 0))  
                        {  
                            // Seek to the end of the file  
                            fileStream.Seek(0, SeekOrigin.End);  

                            // Append a single byte   
                            fileStream.WriteByte(0x01);  
                        }  
                    }  
                }  
                tran.Commit();  
            }  

        }  
    }  
}

Para obtener otro ejemplo, vea cómo almacenar y recuperar datos binarios en una columna de secuencia de archivo.For another sample, see How to store and fetch binary data into a file stream column.

Recursos en los Libros en pantalla de SQL ServerResources in SQL Server Books Online

La documentación completa de FILESTREAM se encuentra en las secciones siguientes en los libros en pantalla de SQL Server.The complete documentation for FILESTREAM is located in the following sections in SQL Server Books Online.

TemaTopic DescripciónDescription
Diseñar e implementar almacenamiento FILESTREAMDesigning and Implementing FILESTREAM Storage Proporciona vínculos a la documentación de FILESTREAM y a los temas relacionados.Provides links to FILESTREAM documentation and related topics.
Información general de FILESTREAMFILESTREAM Overview Describe cuándo se usa el almacenamiento de FILESTREAM y cómo éste integra el Motor de base de datos de SQL Server con un sistema de archivos NTFS.Describes when to use FILESTREAM storage and how it integrates the SQL Server Database Engine with an NTFS file system.
Introducción al almacenamiento FILESTREAMGetting Started with FILESTREAM Storage Describe cómo habilitar FILESTREAM en una instancia de SQL Server, cómo crear una base de datos y una tabla para los datos de un FILESTREAM almacenados y cómo manipular filas que contienen datos de un FILESTREAM.Describes how to enable FILESTREAM on an instance of SQL Server, how to create a database and a table to stored FILESTREAM data, and how to manipulate rows containing FILESTREAM data.
Usar el almacenamiento FILESTREAM en aplicaciones clienteUsing FILESTREAM Storage in Client Applications Describe las funciones de la API de Win32 para trabajar con datos de un FILESTREAM.Describes the Win32 API functions for working with FILESTREAM data.
FILESTREAM y otras características de SQL ServerFILESTREAM and Other SQL Server Features Proporciona consideraciones, instrucciones y limitaciones para usar datos de un FILESTREAM con otras características de SQL Server.Provides considerations, guidelines and limitations for using FILESTREAM data with other features of SQL Server.

Vea tambiénSee Also

Tipos de datos de SQL Server y ADO.NETSQL Server Data Types and ADO.NET
Recuperar y modificar datos en ADO.NETRetrieving and Modifying Data in ADO.NET
Seguridad de acceso del código y ADO.NETCode Access Security and ADO.NET
Datos binarios y datos de valores grandes de SQL ServerSQL Server Binary and Large-Value Data
Proveedores administrados de ADO.NET y Centro para desarrolladores de DataSetADO.NET Managed Providers and DataSet Developer Center