FILESTREAM veri istemci uygulamaları oluşturma
Win32 için FILESTREAM blob veri yazmak ve okumak için kullanabilirsiniz. Aşağıdaki adımları gereklidir:
FILESTREAM dosya yolunu okuyun.
Geçerli işlem içeriği okuyabilir.
Win32 tanıtıcı al ve FILESTREAM blob verileri okuyup tutamacını kullanın.
[!NOT]
Bu konudaki örneklerde FILESTREAM etkin veritabanı ve oluşturulan tablo gerektiren FILESTREAM etkin veritabanı oluşturmakve FILESTREAM veri depolama için bir tablo oluşturmak.
Bu Konuda
FILESTREAM verilerle çalışmak için işlevler
FILESTREAM veri erişim için adımlar
FILESTREAM dosya yolunu okuma
İşlem içeriği okuma
Bir Win32 dosya tanıtıcı elde etme
Uygulama Tasarım ve uygulama için en iyi yöntemler
FILESTREAM verilerle çalışmak için işlevler
Büyük ikili nesne (blob) veri depolamak için FILESTREAM'ı kullandığınızda, dosyalarla çalışmak için Win32 API'ları kullanabilirsiniz. Win32 uygulamaları, FILESTREAM blob verileri ile çalışma desteklemek için SQL Serveraşağıdaki işlevleri ve API sağlar:
Yol bir yolu bir blob için token olarak döndürür. Bir uygulama bu belirteç Win32 tanıtıcı al ve blob verileri kullanır.
FILESTREAM veri içeren veritabanını bir AlwaysOn kullanılabilirlik grubuna aitse, yol adı işlev (vnn) bilgisayar adı yerine bir sanal ağ adını verir.
GET_FILESTREAM_TRANSACTION_CONTEXT() bir oturumun geçerli hareket temsil eden bir belirteci döndürür. Bir uygulama bu belirteç işlemleri işlem Akış FILESTREAM dosya sistemine bağlamak için kullanır.
OpenSqlFilestream API bir Win32 dosya tanıtıcı alır. Uygulama FILESTREAM veri akışı için tanıtıcı kullanır ve sonra kolu-ebilmek geçmek için aşağıdaki Win32 API: ReadFile, WriteFile, TransmitFile, SetFilePointer, SetEndOfFile, ya FlushFileBuffers. Uygulama tutamacını kullanarak diğer bir API çağrıları ERROR_ACCESS_DENIED hata döndürülür. Uygulamayı kullanarak tanıtıcı kapatmalısınız CloseHandle.
Tüm FILESTREAM veri kapsayıcısı erişim içinde gerçekleştirilen bir SQL Serverişlem. Transact-SQLdeyimleri sql veri ve FILESTREAM veri arasında tutarlılık sağlamak için aynı işlemde çalıştırılabilir.
FILESTREAM veri erişim için adımlar
FILESTREAM dosya yolunu okuma
Her hücre bir FILESTREAM tabloda ilişkili bir dosya yolu vardır. Yolu okumak için PathNameözelliği bir varbinary(max)sütununda bir Transact-SQLdeyimi. Aşağıdaki örnek nasıl dosya yolunu gösterir bir varbinary(max)sütun.
DECLARE @filePath varchar(max)
SELECT @filePath = Chart.PathName()
FROM Archive.dbo.Records
WHERE SerialNumber = 3
PRINT @filepath
İşlem içeriği okuma
Geçerli işlem içeriği almak için kullanmak Transact-SQL GET_FILESTREAM_TRANSACTION_CONTEXT() işlevi. Aşağıdaki örnek, bir hareketin başlaması ve geçerli işlem içeriği okumak gösterilmiştir.
DECLARE @txContext varbinary(max)
BEGIN TRANSACTION
SELECT @txContext = GET_FILESTREAM_TRANSACTION_CONTEXT()
PRINT @txContext
COMMIT
Bir Win32 dosya tanıtıcı elde etme
Bir Win32 dosya tanıtıcı elde etmek için arama OpenSqlFilestreamAPI. Bu API sqlncli.dll dosyasından dışa aktarılır. Aşağıdaki Win32 API'larının birine dönen ele geçirilebilir: ReadFile, WriteFile, TransmitFile, SetFilePointer, SetEndOfFile, ya FlushFileBuffers. Aşağıdaki örnekler bir Win32 dosya tanıtıcı edinme ve kullanma o için FILESTREAM blob verileri okuyup gösterir.
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 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 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 <sqlncli.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);
}
Uygulama Tasarım ve uygulama için en iyi yöntemler
Ne zaman tasarlıyor ve FILESTREAM, kullanan uygulamalar uygulama aşağıdaki yönergeleri dikkate alın:
null yerine 0 x başlatıldı FILESTREAM sütun göstermek için kullanın. 0 X değeri oluşturulacak dosya neden olur ve boş yok.
INSERT önlemek ve silme işlemleri nonnull FILESTREAM sütunları içeren tablolar. Ekleme ve silme işlemlerini çöp toplama işlemi için kullanılan FILESTREAM tabloları değiştirebilirsiniz. Bu uygulamanın performans zaman içinde azalmaya neden olabilir.
Çoğaltma kullanan uygulamalarda NEWSEQUENTIALID() newid yerine kullanın. NEWSEQUENTIALID() newid daha iyi bu uygulamalar GUID üretimi gerçekleştirir.
FILESTREAM API, Win32 akış erişim veri için tasarlanmıştır. Kullanmaktan kaçının Transact-SQLokuma veya yazma 2 MB'den büyük olan FILESTREAM büyük ikili nesneler (BLOB'lar). Eğer okumak gerekir veya blob verileri yazmak Transact-SQL, Bütün blob verileri tüketilen bu Win32 FILESTREAM blob açmaya çalışmadan önce emin olun. Tüm tüketmeye hata Transact-SQLverileri izleyen herhangi bir FILESTREAM açık neden veya kapatma işlemleri başarısız.
Kaçmak Transact-SQL, Güncelleştir, Ekle veya FILESTREAM blob veri başına deyimleri. Bu blob verileri içine biriktirilmesine neden tempdbveritabanı ve yeni bir fiziksel dosyasına yeniden.
Küçük blob güncellemeler için FILESTREAM blob ekleyerek kaçının. Her ekleme temel FILESTREAM dosyaların kopyalanmasına neden olur. Küçük BLOB'lar eklemek bir uygulama varsa, BLOB'ları içine yazmak a varbinary(max)sütun ve BLOB Sayısı belirlenmiş bir sınıra ulaştığında FILESTREAM blob tek yazma işlemi gerçekleştirin.
blob dosyaları bir uygulamada bir sürü veri uzunluğunu alınıyor kaçının. Bu zaman alıcı bir işlem çünkü boyutu depolanan değil SQL Server Veritabanı Altyapısı. blob dosya uzunluğunu belirlemelisiniz, kullanın Transact-SQLdatalength() işlevi kapalıysa KABARCIK boyutunu belirlemek için. datalength() boyutunu belirlemek için blob dosya açılmaz.
Uygulama ileti Block1 kullanıyorsa (SMB1) protokolü, FILESTREAM blob verileri okumalısınız içinde 60 kb çarpan performansı en iyi duruma getirme.
Ayrıca bkz.
Başvuru
Erişim FILESTREAM veri ile OpenSqlFilestream
Kavramlar
FILESTREAM uygulamalarında veritabanı işlemleri ile çatışmaları önlemek