Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of de directory te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen de mappen te wijzigen.
Van toepassing op:
SQL Server
U kunt Win32-API's gebruiken om gegevens te lezen en te schrijven naar een FILESTREAM-BLOB. De volgende stappen zijn vereist:
Lees het bestandspad voor FILESTREAM.
Lees de huidige transactiecontext.
Haal een Win32-ingang op en gebruik de ingang om gegevens te lezen en te schrijven naar de FILESTREAM-BLOB.
Opmerking
Voor de voorbeelden in dit onderwerp zijn de database en tabel met FILESTREAM-functionaliteit vereist die zijn gemaakt in Een FILESTREAM-Enabled-database maken en een tabel maken voor het opslaan van FILESTREAM-gegevens.
Functies voor het werken met FILESTREAM Data
Wanneer u FILESTREAM gebruikt om binaire grote objectgegevens (BLOB) op te slaan, kunt u Win32-API's gebruiken om met de bestanden te werken. SQL Server biedt de volgende functies en API ter ondersteuning van het werken met FILESTREAM BLOB-gegevens in Win32-toepassingen:
PathName retourneert een pad dat functioneert als een token voor een BLOB. Een toepassing gebruikt dit token om een Win32-ingang te verkrijgen en te werken op BLOB-gegevens.
Wanneer de database met FILESTREAM-gegevens deel uitmaakt van een AlwaysOn-beschikbaarheidsgroep, retourneert de functie PathName een naam van een virtueel netwerk (VNN) in plaats van een computernaam.
GET_FILESTREAM_TRANSACTION_CONTEXT() retourneert een token dat de huidige transactie van een sessie vertegenwoordigt. Een toepassing gebruikt dit token om streamingbewerkingen van het FILESTREAM-bestandssysteem te binden aan de transactie.
De OpenSqlFilestream-API verkrijgt een Win32-bestandsingang. De toepassing gebruikt de handle om de FILESTREAM-gegevens te streamen en kan de ingang vervolgens doorgeven aan de volgende Win32-API's: ReadFile, WriteFile, TransmitFile, SetFilePointer, SetEndOfFile of FlushFileBuffers. Als de toepassing een andere API aanroept met behulp van de ingang, wordt er een ERROR_ACCESS_DENIED fout geretourneerd. De toepassing moet de handle sluiten met CloseHandle.
Alle FILESTREAM-gegevenscontainertoegang wordt uitgevoerd in een SQL Server-transactie. Transact-SQL instructies kunnen in dezelfde transactie worden uitgevoerd om consistentie tussen SQL-gegevens en FILESTREAM-gegevens te behouden.
Stappen voor het openen van FILESTREAM-gegevens
Het FILESTREAM-bestandspad lezen
Aan elke cel in een FILESTREAM-tabel is een bestandspad gekoppeld. Als u het pad wilt lezen, gebruikt u de PathName eigenschap van een varbinary(max) kolom in een Transact-SQL instructie. In het volgende voorbeeld ziet u hoe u het bestandspad van een kolom varbinary(max) leest.
DECLARE @filePath VARCHAR(MAX);
SELECT @filePath = Chart.PathName()
FROM Archive.dbo.Records
WHERE SerialNumber = 3;
PRINT @filepath;
De transactiecontext lezen
Gebruik de functie Transact-SQL GET_FILESTREAM_TRANSACTION_CONTEXT() om de huidige transactiecontext te verkrijgen. In het volgende voorbeeld ziet u hoe u een transactie start en de huidige transactiecontext leest.
DECLARE @txContext VARBINARY(MAX);
BEGIN TRANSACTION;
SELECT @txContext = GET_FILESTREAM_TRANSACTION_CONTEXT();
PRINT @txContext;
COMMIT;
Een Win32-bestandsingang verkrijgen
Als u een Win32-bestandsingang wilt verkrijgen, roept u de OpenSqlFilestream-API aan. Deze API wordt geëxporteerd uit het sqlncli.dll-bestand. De geretourneerde ingang kan worden doorgegeven aan een van de volgende Win32-API's: ReadFile, WriteFile, TransmitFile, SetFilePointer, SetEndOfFile of FlushFileBuffers. In de volgende voorbeelden ziet u hoe u een Win32-bestandsingang kunt verkrijgen en deze kunt gebruiken om gegevens te lezen en te schrijven naar een FILESTREAM-BLOB.
using System.IO;
using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using System.Data.SqlTypes;
namespace FILESTREAM
{
class Program
{
static void Main(string[] args)
{
SqlConnection sqlConnection = new SqlConnection(
"Integrated Security=true;server=(local)");
SqlCommand sqlCommand = new SqlCommand();
sqlCommand.Connection = sqlConnection;
try
{
sqlConnection.Open();
//The first task is to retrieve the file path
//of the SQL FILESTREAM BLOB that we want to
//access in the application.
sqlCommand.CommandText =
"SELECT Chart.PathName()"
+ " FROM Archive.dbo.Records"
+ " WHERE SerialNumber = 3";
String filePath = null;
Object pathObj = sqlCommand.ExecuteScalar();
if (DBNull.Value != pathObj)
filePath = (string)pathObj;
else
{
throw new System.Exception(
"Chart.PathName() failed"
+ " to read the path name "
+ " for the Chart column.");
}
//The next task is to obtain a transaction
//context. All FILESTREAM BLOB operations
//occur within a transaction context to
//maintain data consistency.
//All SQL FILESTREAM BLOB access must occur in
//a transaction. MARS-enabled connections
//have specific rules for batch scoped transactions,
//which the Transact-SQL BEGIN TRANSACTION statement
//violates. To avoid this issue, client applications
//should use appropriate API facilities for transaction management,
//management, such as the SqlTransaction class.
SqlTransaction transaction = sqlConnection.BeginTransaction("mainTranaction");
sqlCommand.Transaction = transaction;
sqlCommand.CommandText =
"SELECT GET_FILESTREAM_TRANSACTION_CONTEXT()";
Object obj = sqlCommand.ExecuteScalar();
byte[] txContext = (byte[])obj;
//The next step is to obtain a handle that
//can be passed to the Win32 FILE APIs.
SqlFileStream sqlFileStream = new SqlFileStream(filePath, txContext, FileAccess.ReadWrite);
byte[] buffer = new byte[512];
int numBytes = 0;
//Write the string, "EKG data." to the FILESTREAM BLOB.
//In your application this string would be replaced with
//the binary data that you want to write.
string someData = "EKG data.";
Encoding unicode = Encoding.GetEncoding(0);
sqlFileStream.Write(unicode.GetBytes(someData.ToCharArray()),
0,
someData.Length);
//Read the data from the FILESTREAM
//BLOB.
sqlFileStream.Seek(0L, SeekOrigin.Begin);
numBytes = sqlFileStream.Read(buffer, 0, buffer.Length);
string readData = unicode.GetString(buffer);
if (numBytes != 0)
Console.WriteLine(readData);
//Because reading and writing are finished, FILESTREAM
//must be closed. This closes the c# FileStream class,
//but does not necessarily close the underlying
//FILESTREAM handle.
sqlFileStream.Close();
//The final step is to commit or roll back the read and write
//operations that were performed on the FILESTREAM BLOB.
sqlCommand.Transaction.Commit();
}
catch (System.Exception ex)
{
Console.WriteLine(ex.ToString());
}
finally
{
sqlConnection.Close();
}
return;
}
}
}
Imports System.IO
Imports System
Imports System.Collections.Generic
Imports System.Text
Imports System.Data
Imports System.Data.SqlClient
Imports System.Data.SqlTypes
Module Module1
Public Sub Main(ByVal args As String())
' Dim sqlConnection As New SqlConnection("Integrated Security=true;server=(local)")
Dim sqlConnection As New SqlConnection("Integrated Security=true;server=kellyreyue\MSSQL1")
Dim sqlCommand As New SqlCommand()
sqlCommand.Connection = sqlConnection
Try
sqlConnection.Open()
'The first task is to retrieve the file path
'of the SQL FILESTREAM BLOB that we want to
'access in the application.
sqlCommand.CommandText = "SELECT Chart.PathName()" + " FROM Archive.dbo.Records" + " WHERE SerialNumber = 3"
Dim filePath As String = Nothing
Dim pathObj As Object = sqlCommand.ExecuteScalar()
If Not pathObj.Equals(DBNull.Value) Then
filePath = DirectCast(pathObj, String)
Else
Throw New System.Exception("Chart.PathName() failed" + " to read the path name " + " for the Chart column.")
End If
'The next task is to obtain a transaction
'context. All FILESTREAM BLOB operations
'occur within a transaction context to
'maintain data consistency.
'All SQL FILESTREAM BLOB access must occur in
'a transaction. MARS-enabled connections
'have specific rules for batch scoped transactions,
'which the Transact-SQL BEGIN TRANSACTION statement
'violates. To avoid this issue, client applications
'should use appropriate API facilities for transaction management,
'management, such as the SqlTransaction class.
Dim transaction As SqlTransaction = sqlConnection.BeginTransaction("mainTranaction")
sqlCommand.Transaction = transaction
sqlCommand.CommandText = "SELECT GET_FILESTREAM_TRANSACTION_CONTEXT()"
Dim obj As Object = sqlCommand.ExecuteScalar()
Dim txContext As Byte() = Nothing
Dim contextLength As UInteger
If Not obj.Equals(DBNull.Value) Then
txContext = DirectCast(obj, Byte())
contextLength = txContext.Length()
Else
Dim message As String = "GET_FILESTREAM_TRANSACTION_CONTEXT() failed"
Throw New System.Exception(message)
End If
'The next step is to obtain a handle that
'can be passed to the Win32 FILE APIs.
Dim sqlFileStream As New SqlFileStream(filePath, txContext, FileAccess.ReadWrite)
Dim buffer As Byte() = New Byte(511) {}
Dim numBytes As Integer = 0
'Write the string, "EKG data." to the FILESTREAM BLOB.
'In your application this string would be replaced with
'the binary data that you want to write.
Dim someData As String = "EKG data."
Dim unicode As Encoding = Encoding.GetEncoding(0)
sqlFileStream.Write(unicode.GetBytes(someData.ToCharArray()), 0, someData.Length)
'Read the data from the FILESTREAM
'BLOB.
sqlFileStream.Seek(0, SeekOrigin.Begin)
numBytes = sqlFileStream.Read(buffer, 0, buffer.Length)
Dim readData As String = unicode.GetString(buffer)
If numBytes <> 0 Then
Console.WriteLine(readData)
End If
'Because reading and writing are finished, FILESTREAM
'must be closed. This closes the c# FileStream class,
'but does not necessarily close the underlying
'FILESTREAM handle.
sqlFileStream.Close()
'The final step is to commit or roll back the read and write
'operations that were performed on the FILESTREAM BLOB.
sqlCommand.Transaction.Commit()
Catch ex As System.Exception
Console.WriteLine(ex.ToString())
Finally
sqlConnection.Close()
End Try
Return
End Sub
End Module
#include <windows.h>
#include <sql.h>
#include<sqltypes.h>
#include<sqlext.h>
#include <stdio.h>
#include <msodbcsql.h>
#define COPYBUFFERSIZE 4096
/// <summary>
///This class iterates though the ODBC error queue and prints all of the
///accumulated error messages to the console.
/// </summary>
class ODBCErrors
{
private:
int m_iLine; //Source code line on which the error occurred
SQLSMALLINT m_type; //Type of handle on which the error occurred
SQLHANDLE m_handle; //ODBC handle on which the error occurred
public:
/// <summary>
///Default constructor for the ODBCErrors class
///</summary>
ODBCErrors()
{
m_iLine = -1;
m_type = 0;
m_handle = SQL_NULL_HANDLE;
}
/// <summary>
///Constructor for the ODBCErrors class
/// </summary>
/// <param name="iLine">
/// This parameter is the source code line
/// at which the error occurred.
///</param>
/// <param name="type">
/// This parameter is the type of ODBC handle passed in
/// the next parameter.
///</param>
/// <param name="handle">
/// This parameter is the handle on which the error occurred.
///</param>
ODBCErrors(int iLine, SQLSMALLINT type, SQLHANDLE handle)
{
m_iLine = iLine;
m_type = type;
m_handle = handle;
}
///<summary>
/// This method iterates though the error stack for the handle passed
/// into the constructor and displays those errors on the console.
///</summary>
void Print()
{
SQLSMALLINT i = 0, len = 0;
SQLINTEGER native;
SQLTCHAR state[9], text[256];
SQLRETURN sqlReturn = SQL_SUCCESS;
if ( m_handle == SQL_NULL_HANDLE )
{
wprintf_s(TEXT("The error handle is not a valid handle.\n"), m_iLine);
return;
}
wprintf_s(TEXT("Error Line(%d)\n"), m_iLine);
while( sqlReturn == SQL_SUCCESS )
{
len = 0;
sqlReturn = SQLGetDiagRec(
m_type,
m_handle,
++i,
state,
&native,
text,
sizeof(text)/sizeof(SQLTCHAR),
&len);
if ( SQL_SUCCEEDED(sqlReturn) )
wprintf_s(TEXT("Error(%d, %ld, %s) : %s\n"), i, native, state, text);
}
}
};
BOOL CopyFileToSQL(LPTSTR srcFilePath, LPTSTR dstFilePath, LPBYTE transactionToken, SQLINTEGER cbTransactionToken)
{
BOOL bRetCode = FALSE;
HANDLE srcHandle = INVALID_HANDLE_VALUE;
HANDLE dstHandle = INVALID_HANDLE_VALUE;
BYTE buffer[COPYBUFFERSIZE] = { 0 };
TCHAR *szErrMsgSrc = TEXT("Error opening source file.");
TCHAR *szErrMsgDst = TEXT("Error opening destFile file.");
TCHAR *szErrMsgRead = TEXT("Error reading source file.");
TCHAR *szErrMsgWrite = TEXT("Error writing SQL file.");
try
{
if ( (srcHandle = CreateFile(
srcFilePath,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_FLAG_SEQUENTIAL_SCAN,
NULL)) == INVALID_HANDLE_VALUE )
throw szErrMsgSrc;
if ( (dstHandle = OpenSqlFilestream(
dstFilePath,
Write,
0,
transactionToken,
cbTransactionToken,
0)) == INVALID_HANDLE_VALUE)
throw szErrMsgDst;
DWORD bytesRead = 0;
DWORD bytesWritten = 0;
do
{
if ( ReadFile(srcHandle, buffer, COPYBUFFERSIZE, &bytesRead, NULL) == 0 )
throw szErrMsgRead;
if (bytesRead > 0)
{
if ( WriteFile(dstHandle, buffer, bytesRead, &bytesWritten, NULL) == 0 )
throw szErrMsgWrite;
}
} while (bytesRead > 0);
bRetCode = TRUE;
}
catch( TCHAR *szErrMsg )
{
wprintf_s(szErrMsg);
bRetCode = FALSE;
}
if ( srcHandle != INVALID_HANDLE_VALUE )
CloseHandle(srcHandle);
if ( dstHandle != INVALID_HANDLE_VALUE )
CloseHandle(dstHandle);
return bRetCode;
}
void main()
{
TCHAR *sqlDBQuery =
TEXT("INSERT INTO Archive.dbo.Records(Id, SerialNumber, Chart)")
TEXT(" OUTPUT GET_FILESTREAM_TRANSACTION_CONTEXT(), inserted.Chart.PathName()")
TEXT("VALUES (newid (), 5, CONVERT(VARBINARY, '**Temp**'))");
SQLCHAR transactionToken[32];
SQLHANDLE henv = SQL_NULL_HANDLE;
SQLHANDLE hdbc = SQL_NULL_HANDLE;
SQLHANDLE hstmt = SQL_NULL_HANDLE;
try
{
//These statements Initialize ODBC for the client application and
//connect to the database.
if ( SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv) != SQL_SUCCESS )
throw new ODBCErrors(__LINE__, SQL_HANDLE_ENV, henv);
if ( SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION,(void*)SQL_OV_ODBC3, NULL) != SQL_SUCCESS )
throw new ODBCErrors(__LINE__, SQL_HANDLE_ENV, henv);
if ( SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc) != SQL_SUCCESS )
throw new ODBCErrors(__LINE__, SQL_HANDLE_ENV, henv);
//This code assumes that the dataset name "Sql Server FILESTREAM"
//has been previously created on the client computer system. An
//ODBC DSN is created with the ODBC Data Source item in
//the Windows Control Panel.
if ( SQLConnect(hdbc, TEXT("Sql Server FILESTREAM"),
SQL_NTS, NULL, 0, NULL, 0) <= 0 )
throw new ODBCErrors(__LINE__, SQL_HANDLE_DBC, hdbc);
//FILESTREAM requires that all read and write operations occur
//within a transaction.
if ( SQLSetConnectAttr(hdbc,
SQL_ATTR_AUTOCOMMIT,
(SQLPOINTER)SQL_AUTOCOMMIT_OFF,
SQL_IS_UINTEGER) != SQL_SUCCESS )
throw new ODBCErrors(__LINE__, SQL_HANDLE_DBC, hdbc);
if ( SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt) != SQL_SUCCESS )
throw new ODBCErrors(__LINE__, SQL_HANDLE_DBC, hdbc);
if ( SQLExecDirect(hstmt, sqlDBQuery, SQL_NTS) != SQL_SUCCESS )
throw new ODBCErrors(__LINE__, SQL_HANDLE_STMT, hstmt);
//Retrieve the transaction token.
if ( SQLFetch(hstmt) != SQL_SUCCESS )
throw new ODBCErrors(__LINE__, SQL_HANDLE_STMT, hstmt);
SQLINTEGER cbTransactionToken = sizeof(transactionToken);
if ( SQLGetData(hstmt, 1,
SQL_C_BINARY,
transactionToken,
sizeof(transactionToken),
&cbTransactionToken) != SQL_SUCCESS )
throw new ODBCErrors(__LINE__, SQL_HANDLE_STMT, hstmt);
//Retrieve the file path for the inserted record.
TCHAR dstFilePath[1024];
SQLINTEGER cbDstFilePath;
if ( SQLGetData(hstmt, 2, SQL_C_TCHAR, dstFilePath, sizeof(dstFilePath), &cbDstFilePath) != SQL_SUCCESS )
throw new ODBCErrors(__LINE__, SQL_HANDLE_STMT, hstmt);
if ( SQLCloseCursor(hstmt) != SQL_SUCCESS )
throw new ODBCErrors(__LINE__, SQL_HANDLE_STMT, hstmt);
SQLUSMALLINT mode = SQL_ROLLBACK;
if ( CopyFileToSQL(
TEXT("C:\\Users\\Data\\chart1.jpg"),
dstFilePath,
transactionToken,
cbTransactionToken) == TRUE )
mode = SQL_COMMIT;
SQLTransact(henv, hdbc, mode);
}
catch(ODBCErrors *pErrors)
{
pErrors->Print();
delete pErrors;
}
if ( hstmt != SQL_NULL_HANDLE )
SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
if ( hdbc != SQL_NULL_HANDLE )
SQLDisconnect(hdbc);
if ( hdbc != SQL_NULL_HANDLE )
SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
if ( henv != SQL_NULL_HANDLE )
SQLFreeHandle(SQL_HANDLE_ENV, henv);
}
Aanbevolen procedures voor toepassingsontwerp en -implementatie
Houd rekening met de volgende richtlijnen wanneer u toepassingen ontwerpt en implementeert die FILESTREAM gebruiken:
Gebruik NULL in plaats van 0x om een niet-geïnitialiseerde FILESTREAM-kolom weer te geven. De 0x-waarde zorgt ervoor dat een bestand wordt gemaakt en NULL niet.
Vermijd invoeg- en verwijderbewerkingen in tabellen die niet-nul-FILESTREAM-kolommen bevatten. Invoeg- en verwijderbewerkingen kunnen de FILESTREAM-tabellen wijzigen die worden gebruikt voor garbagecollection. Dit kan ertoe leiden dat de prestaties van een toepassing na verloop van tijd afnemen.
Gebruik NEWSEQUENTIALID() in plaats van NEWID() in toepassingen die gebruikmaken van replicatie. NEWSEQUENTIALID() presteert beter dan NEWID() voor GUID-generatie in deze toepassingen.
De FILESTREAM-API is ontworpen voor Win32-streamingtoegang tot gegevens. Vermijd het gebruik van Transact-SQL om FILESTREAM binaire grote objecten (BLOBs) te lezen of schrijven die groter zijn dan 2 MB. Als u BLOB-gegevens uit Transact-SQL moet lezen of schrijven, moet u ervoor zorgen dat alle BLOB-gegevens worden gebruikt voordat u de FILESTREAM-blob probeert te openen vanuit Win32. Als u niet alle Transact-SQL gegevens gebruikt, kunnen opeenvolgende open- of sluitbewerkingen van FILESTREAM mislukken.
Vermijd Transact-SQL instructies die gegevens bijwerken, aanvullen of voorafgaand toevoegen aan de FILESTREAM BLOB. Hierdoor worden de BLOB-gegevens in de tempdb-database gespoeld en vervolgens terug in een nieuw fysiek bestand geplaatst.
Vermijd het toevoegen van kleine BLOB-updates aan een FILESTREAM-BLOB. Elke toevoeg zorgt ervoor dat de onderliggende FILESTREAM-bestanden worden gekopieerd. Als een toepassing kleine BLOBs moet toevoegen, schrijft u de BLOBs in een kolom varbinary(max) en voert u vervolgens één schrijfbewerking uit naar de FILESTREAM-BLOB wanneer het aantal BLObs een vooraf vastgestelde limiet bereikt.
Vermijd het ophalen van de gegevenslengte van veel BLOB-bestanden in een toepassing. Dit is een tijdrovende bewerking omdat de grootte niet is opgeslagen in de SQL Server Database Engine. Als u de lengte van een BLOB-bestand moet bepalen, gebruikt u de functie Transact-SQL DATALENGTH() om de grootte van de BLOB te bepalen als deze is gesloten. DATALENGTH() opent het BLOB-bestand niet om de grootte ervan te bepalen.
Als een toepassing gebruikmaakt van het SMB1-protocol (Message Block1), moeten FILESTREAM BLOB-gegevens worden gelezen in veelvouden van 60 kB om de prestaties te optimaliseren.
Zie ook
Conflicten voorkomen met databasebewerkingen in FILESTREAM-toepassingen
Access FILESTREAM-gegevens met OpenSqlFilestream
Binaire grote objectgegevens (blob) (SQL Server)
Gedeeltelijke updates uitvoeren voor FILESTREAM-gegevens