HRESULT Goods::FindGoodInObjects(int *NewGoodFlag, LPWSTR Articul)
{
	HRESULT		hr			= NOERROR;			
	DBBINDING	*prgBinding		= NULL;			
	HROW		rghRows[ 1 ];						
	HROW		*prghRows		= rghRows;		
   	ULONG		cRowsObtained		=  0 ;				
	BYTE		*pData			= NULL;			
	DWORD		dwBindingSize		=  0 ;
	DWORD		dwIndex			=  0 ;
	DWORD		dwOffset		=  0 ;
	IRowset		*pIRowset		= NULL;			
	IRowsetIndex	*pIRowsetIndex		= NULL;				
	IAccessor	*pIAccessor		= NULL;		
	HACCESSOR	hAccessor		= DB_NULL_HACCESSOR;
	WCHAR*		pwszDocObj[]		=	{
								L "Articul" 
							};

	dwBindingSize = sizeof(pwszDocObj)/sizeof(pwszDocObj[ 0 ]);
	prgBinding = (DBBINDING*)CoTaskMemAlloc(sizeof(DBBINDING)*dwBindingSize);
	if (NULL == prgBinding)
	{
		hr = E_OUTOFMEMORY;
		goto Exit;
	}

	hr = g_pODBInterf->GetFieldsOfSeek(m_pIDBCreateSession, L "DocObj" , L "PK_DOCNUM_ARTICUL" , &pIRowset, &pIRowsetIndex, prgBinding, &dwOffset, pwszDocObj, dwBindingSize);
	if(FAILED(hr))
	{
		goto Exit;
	}

	hr = pIRowset->QueryInterface(IID_IAccessor, (void**)&pIAccessor);
	if(FAILED(hr))
	{
		goto Exit;
	}

    	hr = pIAccessor->CreateAccessor(DBACCESSOR_ROWDATA, dwBindingSize, prgBinding,  0 , &hAccessor,NULL);
	if(FAILED(hr))
	{
     	   goto Exit;
	}

	pData = (BYTE*)CoTaskMemAlloc(dwOffset);
	if (NULL == pData)
	{
		hr = E_OUTOFMEMORY;
		goto Exit;
	}

    	memset(pData,  0 , dwOffset);

	*(DBSTATUS*)(pData+prgBinding[ 0 ].obStatus)	= DBSTATUS_S_OK;
	wcscpy((WCHAR*)(pData+prgBinding[ 0 ].obValue), Articul);
	*(ULONG*)(pData+prgBinding[ 0 ].obLength)	= wcslen((WCHAR*)(pData+prgBinding[ 0 ].obValue))*sizeof(WCHAR);

	hr = pIRowsetIndex->Seek(hAccessor,  1 , pData, DBSEEK_FIRSTEQ);
	if(FAILED(hr))
	{
		goto Exit;	
	}

	hr = pIRowset->GetNextRows(DB_NULL_HCHAPTER,  0 ,  1 , &cRowsObtained, &prghRows);
	if(FAILED(hr))
	{
		goto Exit;	
	}

	if (DB_S_ENDOFROWSET != hr)
	{
		hr = pIRowset->GetData(prghRows[ 0 ], hAccessor, pData);
		if (FAILED(hr))
		{
			goto Exit;
		}

		*NewGoodFlag =  1 ;
	}

	pIRowset->ReleaseRows( 1 , prghRows, NULL, NULL, NULL);

Exit:
	if (prghRows)
	{
        CoTaskMemFree(prghRows);
        prghRows = NULL;
	}

	if (prgBinding)
	{
        	CoTaskMemFree(prgBinding);
	        prgBinding = NULL;
	}

	if (pData)
	{
	        CoTaskMemFree(pData);
		pData = NULL;
	}

	if(pIAccessor)
	{
		pIAccessor->ReleaseAccessor(hAccessor, NULL); 
		pIAccessor->Release();
		pIAccessor = NULL;
	}

	if(pIRowset)
	{
		pIRowset->Release();
		pIRowset = NULL;
	}

	if (pIRowsetIndex)
	{
		pIRowsetIndex->Release();
		pIRowsetIndex = NULL;
	}

	return hr;
}

HRESULT ODBInterf::GetFieldsOfSeek(IDBCreateSession *m_pIDBCreateSession, WCHAR *TableName, WCHAR* IndexName, IRowset **ppIRowset, IRowsetIndex **ppIRowsetIndex, DBBINDING *prgBinding, DWORD *dwOffset, WCHAR** NameRecords, DWORD dwBindingSize)
{
	HRESULT		hr		= NOERROR;	
	HROW		rghRows[ 1 ];	
	HROW		*prghRows	= rghRows;
	DBID		TableID;								
	DBID		IndexID;								
	DBPROPSET	rowsetpropset[ 1 ];
	DBPROP		rowsetprop[ 1 ];	
   	ULONG		cRowsObtained	=  0 ;				
	DBOBJECT	dbObject;
	DBCOLUMNINFO	*pDBColumnInfo	= NULL;				
	WCHAR		*pStringsBuffer	= NULL;
	DWORD		dwIndex		=  0 ;
	DWORD		dwOrdinal	=  0 ;
	ULONG		ulNumCols;

	IOpenRowset	*pIOpenRowset	= NULL;				
	IRowset		*pIRowset	= NULL;			
	IRowsetIndex	*pIRowsetIndex	= NULL;				
	ILockBytes	*pILockBytes	= NULL;			
	IColumnsInfo	*pIColumnsInfo	= NULL;				

	VariantInit(&rowsetprop[ 0 ].vValue);

	if (NULL == m_pIDBCreateSession)
	{
		hr = E_POINTER;
		goto Exit;
	}

	hr = m_pIDBCreateSession->CreateSession(NULL, IID_IOpenRowset, (IUnknown**) &pIOpenRowset);
	if(FAILED(hr))
	{
        	goto Exit;
	}

	TableID.eKind	= DBKIND_NAME;
	TableID.uName.pwszName	= TableName;

	IndexID.eKind	= DBKIND_NAME;
	IndexID.uName.pwszName	= IndexName;

	rowsetpropset[ 0 ].cProperties	=  1 ;
	rowsetpropset[ 0 ].guidPropertySet= DBPROPSET_ROWSET;
	rowsetpropset[ 0 ].rgProperties	= rowsetprop;

	rowsetprop[ 0 ].dwPropertyID	= DBPROP_IRowsetIndex;
	rowsetprop[ 0 ].dwOptions		= DBPROPOPTIONS_REQUIRED;
	rowsetprop[ 0 ].colid		= DB_NULLID;
	rowsetprop[ 0 ].vValue.vt		= VT_BOOL;
	rowsetprop[ 0 ].vValue.boolVal	= VARIANT_TRUE;

	hr = pIOpenRowset->OpenRowset(	NULL, &TableID,	&IndexID,IID_IRowsetIndex,				sizeof(rowsetpropset)/sizeof(rowsetpropset[ 0 ]),	rowsetpropset, (IUnknown**) &pIRowsetIndex);
	if(FAILED(hr))
	{
		goto Exit;
	}

	if(pIOpenRowset)
	{
		pIOpenRowset->Release();
		pIOpenRowset = NULL;
	}

	VariantClear(&rowsetprop[ 0 ].vValue);

	hr = pIRowsetIndex->QueryInterface(IID_IRowset, (void**) &pIRowset);
	if(FAILED(hr))
	{
		goto Exit;
	}

	hr = pIRowset->QueryInterface(IID_IColumnsInfo, (void **)&pIColumnsInfo);
	if(FAILED(hr))
	{
		goto Exit;
	}

	hr = pIColumnsInfo->GetColumnInfo(&ulNumCols, &pDBColumnInfo, &pStringsBuffer);
	if(FAILED(hr) ||  0  == ulNumCols)
	{
		goto Exit;
	}

	*dwOffset =  0 ;

	for (dwIndex =  0 ; dwIndex < dwBindingSize; ++dwIndex)
   	{
		if (!GetColumnOrdinal(pDBColumnInfo, ulNumCols, NameRecords[dwIndex], &dwOrdinal))
		{
			hr = E_FAIL;
			goto Exit;
		}

		prgBinding[dwIndex].iOrdinal	= dwOrdinal;
		prgBinding[dwIndex].dwPart		= DBPART_VALUE | DBPART_STATUS | DBPART_LENGTH;
		prgBinding[dwIndex].obLength	= *dwOffset;                                     
		prgBinding[dwIndex].obStatus	= prgBinding[dwIndex].obLength + sizeof(ULONG);  
		prgBinding[dwIndex].obValue		= prgBinding[dwIndex].obStatus + sizeof(DBSTATUS);
		prgBinding[dwIndex].pTypeInfo	= NULL;
		prgBinding[dwIndex].pBindExt	= NULL;
		prgBinding[dwIndex].dwMemOwner	= DBMEMOWNER_CLIENTOWNED;
		prgBinding[dwIndex].dwFlags		=  0 ;
		prgBinding[dwIndex].bPrecision	= pDBColumnInfo[dwOrdinal].bPrecision;
		prgBinding[dwIndex].bScale		= pDBColumnInfo[dwOrdinal].bScale;

		switch(pDBColumnInfo[dwOrdinal].wType)
		{
		case DBTYPE_BYTES:
			dbObject.dwFlags = STGM_READ;
			dbObject.iid	 = IID_ILockBytes;

			prgBinding[dwIndex].pObject		= &dbObject;
			prgBinding[dwIndex].cbMaxLen	= sizeof(IUnknown*);
			prgBinding[dwIndex].wType		= DBTYPE_IUNKNOWN;
			break;

		case DBTYPE_WSTR:
			prgBinding[dwIndex].pObject		= NULL;
			prgBinding[dwIndex].wType		= pDBColumnInfo[dwOrdinal].wType;
			prgBinding[dwIndex].cbMaxLen	= sizeof(WCHAR)*(pDBColumnInfo[dwOrdinal].ulColumnSize +  1 );
			break;

		default:
			prgBinding[dwIndex].pObject		= NULL;
			prgBinding[dwIndex].wType		= pDBColumnInfo[dwOrdinal].wType;
			prgBinding[dwIndex].cbMaxLen	= pDBColumnInfo[dwOrdinal].ulColumnSize; 
			break;
		}

		*dwOffset = prgBinding[dwIndex].obValue + prgBinding[dwIndex].cbMaxLen;

		*dwOffset = ROUND_UP(*dwOffset, COLUMN_ALIGNVAL);
	}

	*ppIRowset = pIRowset;
	*ppIRowsetIndex = pIRowsetIndex;

Exit:
	if (pIColumnsInfo)
	{
		pIColumnsInfo->Release();
		pIColumnsInfo = NULL;
	}

	if (pStringsBuffer)
	{
        	CoTaskMemFree(pStringsBuffer);
	        pStringsBuffer = NULL;
    	}

	if (pDBColumnInfo)
	{
        	CoTaskMemFree(pDBColumnInfo);
	        pDBColumnInfo = NULL;
	}

	return hr;
}

HRESULT Goods::GoodsListChange(HWND g_hDlg)
{
	HRESULT				hr					= NOERROR;			// Error code reporting
	DBBINDING			*prgBinding			= NULL;				// Binding used to create accessor
	HROW				rghRows[ 1 ];								// Array of row handles obtained from the rowset object
	HROW				*prghRows			= rghRows;			// Row handle(s) pointer
   	ULONG				cRowsObtained		=  0 ;				// Number of rows obtained from the rowset object
	BYTE				*pData				= NULL;				// record data
	DWORD				dwBindingSize		=  0 ;
	DWORD				dwIndex				=  0 ;
	DWORD				dwOffset			=  0 ;

	IRowset				*pIRowset			= NULL;				// Provider Interface Pointer
	IRowsetIndex		*pIRowsetIndex		= NULL;				// Provider Interface Pointer
	IAccessor			*pIAccessor			= NULL;				// Provider Interface Pointer
	HACCESSOR			hAccessor			= DB_NULL_HACCESSOR;// Accessor handle
//	HWND				hObject;
	LPWSTR				Articul				= NULL;
	IOpenRowset			*pIOpenRowset		= NULL;				// Provider Interface Pointer
	LPWSTR				pwszName			= NULL;

	WCHAR*				pwszGoods[]		=	{						// Employee info Column names
													L "Articul" ,
													L "Name" ,
													L "InPlace" ,
													L "Price" 
												};

Это было закоментировано намеренно:
 /*
	hObject = GetDlgItem(g_hDlg, IDC_GOODSLIST);
	dwIndex = ListView_GetSelectionMark(hObject);

	Articul = (LPWSTR)CoTaskMemAlloc(7);
	ListView_GetItemText(hObject, dwIndex, 0, Articul, 7);
*/ 
	pwszName = (LPWSTR)CoTaskMemAlloc( 10 );

	dwBindingSize = sizeof(pwszGoods)/sizeof(pwszGoods[ 0 ]);
	prgBinding = (DBBINDING*)CoTaskMemAlloc(sizeof(DBBINDING)*dwBindingSize);
	if (NULL == prgBinding)
	{
		hr = E_OUTOFMEMORY;
		goto Exit;
	}

	hr = g_pODBInterf->GetFieldsOfSeek(m_pIDBCreateSession, L "Goods" , L "PK_ARTICUL" , &pIOpenRowset, &pIRowset, &pIRowsetIndex, prgBinding, &dwOffset, pwszGoods, dwBindingSize);
	if(FAILED(hr))
	{
		goto Exit;
	}

	// Get IAccessor interface
	//
	hr = pIRowset->QueryInterface(IID_IAccessor, (void**)&pIAccessor);
	if(FAILED(hr))
	{
		goto Exit;
	}

    // Create accessor.
	//
    hr = pIAccessor->CreateAccessor(DBACCESSOR_ROWDATA, 
									dwBindingSize, 
									prgBinding,
									 0 ,
									&hAccessor,
									NULL);
    if(FAILED(hr))
    {
        goto Exit;
    }

	// Allocate data buffer for seek and retrieve operation.
	//
	pData = (BYTE*)CoTaskMemAlloc(dwOffset);
	if (NULL == pData)
	{
		hr = E_OUTOFMEMORY;
		goto Exit;
	}

    // Set data buffer to zero
    //
    memset(pData,  0 , dwOffset);

    // Set data buffer for seek operation
    //
	*(DBSTATUS*)(pData+prgBinding[ 0 ].obStatus)	= DBSTATUS_S_OK;

Вместо этой строки вставлена следующая, которая вместо Articul использует постоянное значение
//	wcscpy((WCHAR*)(pData+prgBinding[ 0 ].obValue), Articul);
	wcscpy((WCHAR*)(pData+prgBinding[ 0 ].obValue), L "13865 ");

	*(ULONG*)(pData+prgBinding[ 0 ].obLength)		= wcslen((WCHAR*)(pData+prgBinding[ 0 ].obValue))*sizeof(WCHAR);

 	// Position at a key value within the current range 
	//
	hr = pIRowsetIndex->Seek(hAccessor,  1 , pData, DBSEEK_FIRSTEQ);
	if(FAILED(hr))
	{
		goto Exit;	
	}

    // Retrieve a row handle for the row resulting from the seek
    //
    hr = pIRowset->GetNextRows(DB_NULL_HCHAPTER,  0 ,  1 , &cRowsObtained, &prghRows);
	if (DB_S_ENDOFROWSET != hr)
	{
		// Fetch actual data
		//
		hr = pIRowset->GetData(prghRows[ 0 ], hAccessor, pData);
		if (FAILED(hr))
		{
			pIRowset->ReleaseRows( 1 , prghRows, NULL, NULL, NULL);
			goto Exit;
		}

		// Update dialog
		// If return a null value or status is not OK, ignore the contents of the value and length parts of the buffer.
		//
		if (DBSTATUS_S_ISNULL != *(DBSTATUS *)(pData+prgBinding[ 1 ].obStatus) &&
            DBSTATUS_S_OK == *(DBSTATUS *)(pData+prgBinding[ 1 ].obStatus))
		{
			SetDlgItemText(g_hDlg, IDC_GOOD, (WCHAR*)(pData+prgBinding[ 1 ].obValue));
		} 

		if (DBSTATUS_S_ISNULL != *(DBSTATUS *)(pData+prgBinding[ 2 ].obStatus) &&
            DBSTATUS_S_OK == *(DBSTATUS *)(pData+prgBinding[ 2 ].obStatus))
		{

Эти строки также заменены на строку без испоьзования динамически содаваемой переменной:
//			wsprintf(pwszName, L "%d" , *(int*)(pData+prgBinding[ 2 ].obValue));
//			SetDlgItemText(g_hDlg, IDC_INPLACEVALUE, pwszName);
						SetDlgItemText(g_hDlg, IDC_INPLACEVALUE, L "0 . 0 ");
		}

		if (DBSTATUS_S_ISNULL != *(DBSTATUS *)(pData+prgBinding[ 3 ].obStatus) &&
            DBSTATUS_S_OK == *(DBSTATUS *)(pData+prgBinding[ 3 ].obStatus))
		{

Эти строки также заменены на строку без испоьзования динамически содаваемой переменной:
//			wsprintf(pwszName, L "%f" , *(float*)(pData+prgBinding[ 3 ].obValue));
//			SetDlgItemText(g_hDlg, IDC_PRICEVALUE, pwszName);
			SetDlgItemText(g_hDlg, IDC_PRICEVALUE, L "0 . 00 ");
		}

		hr = pIRowset->ReleaseRows( 1 , prghRows, NULL, NULL, NULL);
        if(FAILED(hr))
        {
			goto Exit;
        }
	}

Exit:

	if (prghRows)
	{
        CoTaskMemFree(prghRows);
        prghRows = NULL;
	}

	if(pIAccessor)
	{
		hr = pIAccessor->ReleaseAccessor(hAccessor, NULL); 
		if (FAILED(hr))
		{
			MessageBox(g_hDlg, L "Error" , L "Goods" , MB_OK);
		}
		hr = pIAccessor->Release();
		if (FAILED(hr))
		{
			MessageBox(g_hDlg, L "Error" , L "Goods" , MB_OK);
		}
		pIAccessor = NULL;
	}

	if (pData)
	{
        CoTaskMemFree(pData);
		pData = NULL;
	}

	if(pIRowset)
	{
		hr = pIRowset->Release();
		if (FAILED(hr))
		{
			MessageBox(g_hDlg, L "Error" , L "Goods" , MB_OK);
		}

		pIRowset = NULL;
	}

	if (pIRowsetIndex)
	{
		hr = pIRowsetIndex->Release();
		if (FAILED(hr))
		{
			MessageBox(g_hDlg, L "Error" , L "Goods" , MB_OK);
		}

		pIRowsetIndex = NULL;
	}
    
	if (pIOpenRowset)
	{
		hr = pIOpenRowset->Release();
		if (FAILED(hr))
		{
			MessageBox(g_hDlg, L "Error" , L "Goods" , MB_OK);
		}
		pIOpenRowset = NULL;
	}
	
	if (prgBinding)
    {
        CoTaskMemFree(prgBinding);
        prgBinding = NULL;
    }

	if (pwszName)
	{
		CoTaskMemFree(pwszName);
		pwszName = NULL;
	}

	if (Articul)
	{
		CoTaskMemFree(Articul);
		Articul = NULL;
	}

	return hr;
}