| /* | |
| * Copyright 2019 Alistair Leslie-Hughes | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Lesser General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Lesser General Public | |
| * License along with this library; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA | |
| */ | |
| #include <stdarg.h> | |
| #include "windef.h" | |
| #include "winbase.h" | |
| #define COBJMACROS | |
| #include "objbase.h" | |
| #include "msdasc.h" | |
| #include "msado15_backcompat.h" | |
| #include "wine/debug.h" | |
| #include "wine/list.h" | |
| #include "msado15_private.h" | |
| WINE_DEFAULT_DEBUG_CHANNEL(msado15); | |
| struct param_item | |
| { | |
| struct list entry; | |
| IDispatch *param; | |
| }; | |
| struct command | |
| { | |
| _Command Command_iface; | |
| ADOCommandConstruction ADOCommandConstruction_iface; | |
| Parameters Parameters_iface; | |
| LONG ref; | |
| CommandTypeEnum type; | |
| BSTR text; | |
| _Connection *connection; | |
| struct list parameters; | |
| }; | |
| struct parameter | |
| { | |
| _Parameter Parameter_iface; | |
| LONG ref; | |
| BSTR name; | |
| DataTypeEnum datatype; | |
| ParameterDirectionEnum direction; | |
| ADO_LONGPTR size; | |
| VARIANT value; | |
| }; | |
| static inline struct parameter *impl_from_Parameter( _Parameter *iface ) | |
| { | |
| return CONTAINING_RECORD( iface, struct parameter, Parameter_iface ); | |
| } | |
| static inline struct command *impl_from_Command( _Command *iface ) | |
| { | |
| return CONTAINING_RECORD( iface, struct command, Command_iface ); | |
| } | |
| static inline struct command *impl_from_ADOCommandConstruction( ADOCommandConstruction *iface ) | |
| { | |
| return CONTAINING_RECORD( iface, struct command, ADOCommandConstruction_iface ); | |
| } | |
| static inline struct command *impl_from_Parameters( Parameters *iface ) | |
| { | |
| return CONTAINING_RECORD( iface, struct command, Parameters_iface ); | |
| } | |
| static HRESULT WINAPI parameters_QueryInterface(Parameters *iface, REFIID riid, void **obj) | |
| { | |
| TRACE( "%p, %s, %p\n", iface, debugstr_guid(riid), obj ); | |
| *obj = NULL; | |
| if (IsEqualIID(riid, &IID_IUnknown) || | |
| IsEqualIID(riid, &IID_IDispatch) || | |
| IsEqualIID(riid, &IID__Collection) || | |
| IsEqualIID(riid, &IID__DynaCollection) || | |
| IsEqualIID(riid, &IID_Parameters)) | |
| { | |
| *obj = iface; | |
| } | |
| else | |
| { | |
| FIXME( "interface %s not implemented\n", debugstr_guid(riid) ); | |
| return E_NOINTERFACE; | |
| } | |
| Parameters_AddRef( iface ); | |
| return S_OK; | |
| } | |
| static ULONG WINAPI parameters_AddRef(Parameters *iface) | |
| { | |
| struct command *command = impl_from_Parameters( iface ); | |
| return _Command_AddRef(&command->Command_iface); | |
| } | |
| static ULONG WINAPI parameters_Release(Parameters *iface) | |
| { | |
| struct command *command = impl_from_Parameters( iface ); | |
| return _Command_Release(&command->Command_iface); | |
| } | |
| static HRESULT WINAPI parameters_GetTypeInfoCount(Parameters *iface, UINT *count) | |
| { | |
| struct command *command = impl_from_Parameters( iface ); | |
| TRACE( "%p, %p\n", command, count ); | |
| *count = 1; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI parameters_GetTypeInfo(Parameters *iface, UINT index, LCID lcid, ITypeInfo **info) | |
| { | |
| struct command *command = impl_from_Parameters( iface ); | |
| TRACE( "%p, %u, %lu, %p\n", command, index, lcid, info ); | |
| return get_typeinfo(Parameters_tid, info); | |
| } | |
| static HRESULT WINAPI parameters_GetIDsOfNames(Parameters *iface, REFIID riid, LPOLESTR *names, UINT count, | |
| LCID lcid, DISPID *dispid) | |
| { | |
| struct command *command = impl_from_Parameters( iface ); | |
| HRESULT hr; | |
| ITypeInfo *typeinfo; | |
| TRACE( "%p, %s, %p, %u, %lu, %p\n", command, debugstr_guid(riid), names, count, lcid, dispid ); | |
| hr = get_typeinfo(Parameters_tid, &typeinfo); | |
| if(SUCCEEDED(hr)) | |
| { | |
| hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, dispid); | |
| ITypeInfo_Release(typeinfo); | |
| } | |
| return hr; | |
| } | |
| static HRESULT WINAPI parameters_Invoke(Parameters *iface, DISPID member, REFIID riid, LCID lcid, WORD flags, | |
| DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err) | |
| { | |
| struct command *command = impl_from_Parameters( iface ); | |
| HRESULT hr; | |
| ITypeInfo *typeinfo; | |
| TRACE( "%p, %ld, %s, %ld, %d, %p, %p, %p, %p\n", command, member, debugstr_guid(riid), lcid, flags, params, | |
| result, excep_info, arg_err ); | |
| hr = get_typeinfo(Parameters_tid, &typeinfo); | |
| if(SUCCEEDED(hr)) | |
| { | |
| hr = ITypeInfo_Invoke(typeinfo, &command->Parameters_iface, member, flags, params, | |
| result, excep_info, arg_err); | |
| ITypeInfo_Release(typeinfo); | |
| } | |
| return hr; | |
| } | |
| static HRESULT WINAPI parameters_get_Count(Parameters *iface, LONG *count) | |
| { | |
| struct command *command = impl_from_Parameters( iface ); | |
| TRACE( "%p, %p\n", iface, count); | |
| *count = list_count(&command->parameters); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI parameters__NewEnum(Parameters *iface, IUnknown **object) | |
| { | |
| FIXME( "%p, %p\n", iface, object); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI parameters_Refresh(Parameters *iface) | |
| { | |
| FIXME( "%p\n", iface); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI parameters_Append(Parameters *iface, IDispatch *object) | |
| { | |
| struct command *command = impl_from_Parameters( iface ); | |
| struct param_item *param; | |
| TRACE( "%p, %p\n", iface, object); | |
| if (!(param = calloc(1, sizeof(*param)))) | |
| return E_OUTOFMEMORY; | |
| param->param = object; | |
| IDispatch_AddRef(object); | |
| list_add_tail(&command->parameters, ¶m->entry); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI parameters_Delete(Parameters *iface, VARIANT index) | |
| { | |
| struct command *command = impl_from_Parameters( iface ); | |
| struct param_item *para; | |
| int cnt = 0; | |
| TRACE( "%p, %s\n", iface, debugstr_variant(&index)); | |
| if (V_VT(&index) != VT_I4) | |
| { | |
| FIXME("Unsupported index type %d\n", V_VT(&index)); | |
| return E_NOTIMPL; | |
| } | |
| LIST_FOR_EACH_ENTRY(para, &command->parameters, struct param_item, entry) | |
| { | |
| if(cnt == V_I4(&index)) | |
| { | |
| list_remove(¶->entry); | |
| if (para->param) | |
| IDispatch_Release(para->param); | |
| free(para); | |
| return S_OK; | |
| } | |
| cnt++; | |
| } | |
| return MAKE_ADO_HRESULT(adErrItemNotFound); | |
| } | |
| static HRESULT WINAPI parameters_get_Item(Parameters *iface, VARIANT index, _Parameter **object) | |
| { | |
| FIXME( "%p, %s, %p\n", iface, debugstr_variant(&index), object); | |
| return E_NOTIMPL; | |
| } | |
| static const struct ParametersVtbl parameters_vtbl = | |
| { | |
| parameters_QueryInterface, | |
| parameters_AddRef, | |
| parameters_Release, | |
| parameters_GetTypeInfoCount, | |
| parameters_GetTypeInfo, | |
| parameters_GetIDsOfNames, | |
| parameters_Invoke, | |
| parameters_get_Count, | |
| parameters__NewEnum, | |
| parameters_Refresh, | |
| parameters_Append, | |
| parameters_Delete, | |
| parameters_get_Item | |
| }; | |
| static HRESULT WINAPI command_QueryInterface( _Command *iface, REFIID riid, void **obj ) | |
| { | |
| struct command *command = impl_from_Command( iface ); | |
| TRACE( "%p, %s, %p\n", iface, debugstr_guid(riid), obj ); | |
| *obj = NULL; | |
| if (IsEqualIID(riid, &IID_IUnknown) || | |
| IsEqualIID(riid, &IID_IDispatch) || | |
| IsEqualIID(riid, &IID__ADO) || | |
| IsEqualIID(riid, &IID_Command15) || | |
| IsEqualIID(riid, &IID_Command25) || | |
| IsEqualIID(riid, &IID__Command)) | |
| { | |
| *obj = iface; | |
| } | |
| else if (IsEqualIID(riid, &IID_ADOCommandConstruction)) | |
| { | |
| *obj = &command->ADOCommandConstruction_iface; | |
| } | |
| else | |
| { | |
| FIXME( "interface %s not implemented\n", debugstr_guid(riid) ); | |
| return E_NOINTERFACE; | |
| } | |
| _Command_AddRef( iface ); | |
| return S_OK; | |
| } | |
| static ULONG WINAPI command_AddRef( _Command *iface ) | |
| { | |
| struct command *command = impl_from_Command( iface ); | |
| return InterlockedIncrement( &command->ref ); | |
| } | |
| static ULONG WINAPI command_Release( _Command *iface ) | |
| { | |
| struct command *command = impl_from_Command( iface ); | |
| LONG ref = InterlockedDecrement( &command->ref ); | |
| if (!ref) | |
| { | |
| struct param_item *para, *para2; | |
| TRACE( "destroying %p\n", command ); | |
| LIST_FOR_EACH_ENTRY_SAFE(para, para2, &command->parameters, struct param_item, entry) | |
| { | |
| list_remove(¶->entry); | |
| if (para->param) | |
| IDispatch_Release(para->param); | |
| free(para); | |
| } | |
| if (command->connection) _Connection_Release(command->connection); | |
| free( command->text ); | |
| free( command ); | |
| } | |
| return ref; | |
| } | |
| static HRESULT WINAPI command_GetTypeInfoCount( _Command *iface, UINT *count ) | |
| { | |
| struct command *command = impl_from_Command( iface ); | |
| TRACE( "%p, %p\n", command, count ); | |
| *count = 1; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI command_GetTypeInfo( _Command *iface, UINT index, LCID lcid, ITypeInfo **info ) | |
| { | |
| struct command *command = impl_from_Command( iface ); | |
| TRACE( "%p, %u, %lu, %p\n", command, index, lcid, info ); | |
| return get_typeinfo(Command_tid, info); | |
| } | |
| static HRESULT WINAPI command_GetIDsOfNames( _Command *iface, REFIID riid, LPOLESTR *names, UINT count, | |
| LCID lcid, DISPID *dispid ) | |
| { | |
| struct command *command = impl_from_Command( iface ); | |
| HRESULT hr; | |
| ITypeInfo *typeinfo; | |
| TRACE( "%p, %s, %p, %u, %lu, %p\n", command, debugstr_guid(riid), names, count, lcid, dispid ); | |
| hr = get_typeinfo(Command_tid, &typeinfo); | |
| if(SUCCEEDED(hr)) | |
| { | |
| hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, dispid); | |
| ITypeInfo_Release(typeinfo); | |
| } | |
| return hr; | |
| } | |
| static HRESULT WINAPI command_Invoke( _Command *iface, DISPID member, REFIID riid, LCID lcid, WORD flags, | |
| DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err ) | |
| { | |
| struct command *command = impl_from_Command( iface ); | |
| HRESULT hr; | |
| ITypeInfo *typeinfo; | |
| TRACE( "%p, %ld, %s, %ld, %d, %p, %p, %p, %p\n", command, member, debugstr_guid(riid), lcid, flags, params, | |
| result, excep_info, arg_err ); | |
| hr = get_typeinfo(Command_tid, &typeinfo); | |
| if(SUCCEEDED(hr)) | |
| { | |
| hr = ITypeInfo_Invoke(typeinfo, &command->Command_iface, member, flags, params, | |
| result, excep_info, arg_err); | |
| ITypeInfo_Release(typeinfo); | |
| } | |
| return hr; | |
| } | |
| static HRESULT WINAPI command_get_Properties( _Command *iface, Properties **props ) | |
| { | |
| FIXME( "%p, %p\n", iface, props ); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI command_get_ActiveConnection( _Command *iface, _Connection **connection ) | |
| { | |
| struct command *command = impl_from_Command( iface ); | |
| TRACE( "%p, %p\n", iface, connection ); | |
| *connection = command->connection; | |
| if (command->connection) _Connection_AddRef(command->connection); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI command_putref_ActiveConnection( _Command *iface, _Connection *connection ) | |
| { | |
| struct command *command = impl_from_Command( iface ); | |
| TRACE( "%p, %p\n", iface, connection ); | |
| if (command->connection) _Connection_Release(command->connection); | |
| command->connection = connection; | |
| if (command->connection) _Connection_AddRef(command->connection); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI command_put_ActiveConnection( _Command *iface, VARIANT connection ) | |
| { | |
| FIXME( "%p, %s\n", iface, debugstr_variant(&connection) ); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI command_get_CommandText( _Command *iface, BSTR *text ) | |
| { | |
| struct command *command = impl_from_Command( iface ); | |
| BSTR cmd_text = NULL; | |
| TRACE( "%p, %p\n", command, text ); | |
| if (command->text && !(cmd_text = SysAllocString( command->text ))) return E_OUTOFMEMORY; | |
| *text = cmd_text; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI command_put_CommandText( _Command *iface, BSTR text ) | |
| { | |
| struct command *command = impl_from_Command( iface ); | |
| WCHAR *source = NULL; | |
| TRACE( "%p, %s\n", command, debugstr_w( text ) ); | |
| if (text && !(source = wcsdup( text ))) return E_OUTOFMEMORY; | |
| free( command->text ); | |
| command->text = source; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI command_get_CommandTimeout( _Command *iface, LONG *timeout ) | |
| { | |
| FIXME( "%p, %p\n", iface, timeout ); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI command_put_CommandTimeout( _Command *iface, LONG timeout ) | |
| { | |
| FIXME( "%p, %ld\n", iface, timeout ); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI command_get_Prepared( _Command *iface, VARIANT_BOOL *prepared ) | |
| { | |
| FIXME( "%p, %p\n", iface, prepared ); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI command_put_Prepared( _Command *iface, VARIANT_BOOL prepared ) | |
| { | |
| FIXME( "%p, %d\n", iface, prepared ); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI command_Execute( _Command *iface, VARIANT *affected, VARIANT *parameters, | |
| LONG options, _Recordset **recordset ) | |
| { | |
| FIXME( "%p, %p, %p, %ld, %p\n", iface, affected, parameters, options, recordset ); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI parameter_QueryInterface(_Parameter *iface, REFIID riid, void **obj) | |
| { | |
| TRACE( "%p, %s, %p\n", iface, debugstr_guid(riid), obj ); | |
| *obj = NULL; | |
| if (IsEqualIID(riid, &IID_IUnknown) || | |
| IsEqualIID(riid, &IID_IDispatch) || | |
| IsEqualIID(riid, &IID__Parameter)) | |
| { | |
| *obj = iface; | |
| } | |
| else | |
| { | |
| FIXME( "interface %s not implemented\n", debugstr_guid(riid) ); | |
| return E_NOINTERFACE; | |
| } | |
| _Parameter_AddRef( iface ); | |
| return S_OK; | |
| } | |
| static ULONG WINAPI parameter_AddRef(_Parameter *iface) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| return InterlockedIncrement( ¶meter->ref ); | |
| } | |
| static ULONG WINAPI parameter_Release(_Parameter *iface) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| LONG ref = InterlockedDecrement( ¶meter->ref ); | |
| if (!ref) | |
| { | |
| SysFreeString(parameter->name); | |
| VariantClear(¶meter->value); | |
| free( parameter ); | |
| } | |
| return ref; | |
| } | |
| static HRESULT WINAPI parameter_GetTypeInfoCount(_Parameter *iface, UINT *count) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| TRACE( "%p, %p\n", parameter, count ); | |
| *count = 1; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI parameter_GetTypeInfo(_Parameter *iface, UINT index, LCID lcid, ITypeInfo **info) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| TRACE( "%p, %u, %lu, %p\n", parameter, index, lcid, info ); | |
| return get_typeinfo(Parameter_tid, info); | |
| } | |
| static HRESULT WINAPI parameter_GetIDsOfNames(_Parameter *iface, REFIID riid, LPOLESTR *names, UINT count, | |
| LCID lcid, DISPID *dispid) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| HRESULT hr; | |
| ITypeInfo *typeinfo; | |
| TRACE( "%p, %s, %p, %u, %lu, %p\n", parameter, debugstr_guid(riid), names, count, lcid, dispid ); | |
| hr = get_typeinfo(Parameter_tid, &typeinfo); | |
| if(SUCCEEDED(hr)) | |
| { | |
| hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, dispid); | |
| ITypeInfo_Release(typeinfo); | |
| } | |
| return hr; | |
| } | |
| static HRESULT WINAPI parameter_Invoke(_Parameter *iface, DISPID member, REFIID riid, LCID lcid, WORD flags, | |
| DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| HRESULT hr; | |
| ITypeInfo *typeinfo; | |
| TRACE( "%p, %ld, %s, %ld, %d, %p, %p, %p, %p\n", parameter, member, debugstr_guid(riid), lcid, flags, params, | |
| result, excep_info, arg_err ); | |
| hr = get_typeinfo(Parameter_tid, &typeinfo); | |
| if(SUCCEEDED(hr)) | |
| { | |
| hr = ITypeInfo_Invoke(typeinfo, ¶meter->Parameter_iface, member, flags, params, | |
| result, excep_info, arg_err); | |
| ITypeInfo_Release(typeinfo); | |
| } | |
| return hr; | |
| } | |
| static HRESULT WINAPI parameter_get_Properties(_Parameter *iface, Properties **object) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| FIXME("%p, %p\n", parameter, object); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI parameter_get_Name(_Parameter *iface, BSTR *str) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| TRACE("%p, %p\n", parameter, str); | |
| *str = SysAllocString(parameter->name); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI parameter_put_Name(_Parameter *iface, BSTR str) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| TRACE("%p, %s\n", parameter, debugstr_w(str)); | |
| SysFreeString(parameter->name); | |
| parameter->name = SysAllocString(str); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI parameter_get_Value(_Parameter *iface, VARIANT *val) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| TRACE("%p, %p\n", parameter, val); | |
| return VariantCopy(val, ¶meter->value); | |
| } | |
| static HRESULT WINAPI parameter_put_Value(_Parameter *iface, VARIANT val) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| TRACE("%p, %s\n", parameter, debugstr_variant(&val)); | |
| VariantClear(¶meter->value); | |
| return VariantCopy(¶meter->value, &val); | |
| } | |
| static HRESULT WINAPI parameter_get_Type(_Parameter *iface, DataTypeEnum *data_type) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| TRACE("%p, %p\n", parameter, data_type); | |
| *data_type = parameter->datatype; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI parameter_put_Type(_Parameter *iface, DataTypeEnum data_type) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| TRACE("%p, %d\n", parameter, data_type); | |
| parameter->datatype = data_type; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI parameter_put_Direction(_Parameter *iface, ParameterDirectionEnum direction) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| TRACE("%p, %d\n", parameter, direction); | |
| parameter->direction = direction; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI parameter_get_Direction(_Parameter *iface, ParameterDirectionEnum *direction) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| TRACE("%p, %p\n", parameter, direction); | |
| *direction = parameter->direction; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI parameter_put_Precision(_Parameter *iface, unsigned char precision) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| FIXME("%p, %d\n", parameter, precision); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI parameter_get_Precision(_Parameter *iface, unsigned char *precision) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| FIXME("%p, %p\n", parameter, precision); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI parameter_put_NumericScale(_Parameter *iface, unsigned char scale) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| FIXME("%p, %d\n", parameter, scale); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI parameter_get_NumericScale(_Parameter *iface, unsigned char *scale) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| FIXME("%p, %p\n", parameter, scale); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI parameter_put_Size(_Parameter *iface, ADO_LONGPTR size) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| TRACE("%p, %Id\n", parameter, size); | |
| parameter->size = size; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI parameter_get_Size(_Parameter *iface, ADO_LONGPTR *size) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| TRACE("%p, %p\n", parameter, size); | |
| *size = parameter->size; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI parameter_AppendChunk(_Parameter *iface, VARIANT val) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| FIXME("%p, %s\n", parameter, debugstr_variant(&val)); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI parameter_get_Attributes(_Parameter *iface, LONG *attrs) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| FIXME("%p, %p\n", parameter, attrs); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI parameter_put_Attributes(_Parameter *iface, LONG attrs) | |
| { | |
| struct parameter *parameter = impl_from_Parameter( iface ); | |
| FIXME("%p, %ld\n", parameter, attrs); | |
| return E_NOTIMPL; | |
| } | |
| static const _ParameterVtbl parameter_vtbl = | |
| { | |
| parameter_QueryInterface, | |
| parameter_AddRef, | |
| parameter_Release, | |
| parameter_GetTypeInfoCount, | |
| parameter_GetTypeInfo, | |
| parameter_GetIDsOfNames, | |
| parameter_Invoke, | |
| parameter_get_Properties, | |
| parameter_get_Name, | |
| parameter_put_Name, | |
| parameter_get_Value, | |
| parameter_put_Value, | |
| parameter_get_Type, | |
| parameter_put_Type, | |
| parameter_put_Direction, | |
| parameter_get_Direction, | |
| parameter_put_Precision, | |
| parameter_get_Precision, | |
| parameter_put_NumericScale, | |
| parameter_get_NumericScale, | |
| parameter_put_Size, | |
| parameter_get_Size, | |
| parameter_AppendChunk, | |
| parameter_get_Attributes, | |
| parameter_put_Attributes | |
| }; | |
| static HRESULT WINAPI command_CreateParameter( _Command *iface, BSTR name, DataTypeEnum type, | |
| ParameterDirectionEnum direction, ADO_LONGPTR size, VARIANT value, | |
| _Parameter **obj ) | |
| { | |
| struct parameter *parameter; | |
| TRACE( "%p, %s, %d, %d, %Id, %s, %p\n", iface, debugstr_w(name), type, direction, size, | |
| debugstr_variant(&value), obj ); | |
| if (!(parameter = malloc( sizeof(*parameter) ))) return E_OUTOFMEMORY; | |
| parameter->Parameter_iface.lpVtbl = ¶meter_vtbl; | |
| parameter->ref = 1; | |
| parameter->name = SysAllocString(name); | |
| parameter->datatype = type; | |
| parameter->direction = direction; | |
| parameter->size = size; | |
| VariantCopy(¶meter->value, &value); | |
| *obj = ¶meter->Parameter_iface; | |
| TRACE( "returning iface %p\n", *obj ); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI command_get_Parameters( _Command *iface, Parameters **parameters ) | |
| { | |
| struct command *command = impl_from_Command( iface ); | |
| TRACE( "%p, %p\n", iface, parameters ); | |
| if (!parameters) | |
| return E_INVALIDARG; | |
| *parameters = &command->Parameters_iface; | |
| Parameters_AddRef(*parameters); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI command_put_CommandType( _Command *iface, CommandTypeEnum type ) | |
| { | |
| struct command *command = impl_from_Command( iface ); | |
| TRACE( "%p, %d\n", iface, type ); | |
| switch (type) | |
| { | |
| case adCmdUnspecified: | |
| case adCmdUnknown: | |
| case adCmdText: | |
| case adCmdTable: | |
| case adCmdStoredProc: | |
| case adCmdFile: | |
| case adCmdTableDirect: | |
| command->type = type; | |
| return S_OK; | |
| } | |
| return MAKE_ADO_HRESULT( adErrInvalidArgument ); | |
| } | |
| static HRESULT WINAPI command_get_CommandType( _Command *iface, CommandTypeEnum *type ) | |
| { | |
| struct command *command = impl_from_Command( iface ); | |
| TRACE( "%p, %p\n", iface, type ); | |
| *type = command->type; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI command_get_Name(_Command *iface, BSTR *name) | |
| { | |
| FIXME( "%p, %p\n", iface, name ); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI command_put_Name( _Command *iface, BSTR name ) | |
| { | |
| FIXME( "%p, %s\n", iface, debugstr_w(name) ); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI command_get_State( _Command *iface, LONG *state ) | |
| { | |
| FIXME( "%p, %p\n", iface, state ); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI command_Cancel( _Command *iface ) | |
| { | |
| FIXME( "%p\n", iface ); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI command_putref_CommandStream( _Command *iface, IUnknown *stream ) | |
| { | |
| FIXME( "%p, %p\n", iface, stream ); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI command_get_CommandStream( _Command *iface, VARIANT *stream ) | |
| { | |
| FIXME( "%p, %p\n", iface, stream ); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI command_put_Dialect( _Command *iface, BSTR dialect ) | |
| { | |
| FIXME( "%p, %s\n", iface, debugstr_w(dialect) ); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI command_get_Dialect( _Command *iface, BSTR *dialect ) | |
| { | |
| FIXME( "%p, %p\n", iface, dialect ); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI command_put_NamedParameters( _Command *iface, VARIANT_BOOL parameters ) | |
| { | |
| FIXME( "%p, %d\n", iface, parameters ); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI command_get_NamedParameters( _Command *iface, VARIANT_BOOL *parameters ) | |
| { | |
| FIXME( "%p, %p\n", iface, parameters ); | |
| return E_NOTIMPL; | |
| } | |
| static const struct _CommandVtbl command_vtbl = | |
| { | |
| command_QueryInterface, | |
| command_AddRef, | |
| command_Release, | |
| command_GetTypeInfoCount, | |
| command_GetTypeInfo, | |
| command_GetIDsOfNames, | |
| command_Invoke, | |
| command_get_Properties, | |
| command_get_ActiveConnection, | |
| command_putref_ActiveConnection, | |
| command_put_ActiveConnection, | |
| command_get_CommandText, | |
| command_put_CommandText, | |
| command_get_CommandTimeout, | |
| command_put_CommandTimeout, | |
| command_get_Prepared, | |
| command_put_Prepared, | |
| command_Execute, | |
| command_CreateParameter, | |
| command_get_Parameters, | |
| command_put_CommandType, | |
| command_get_CommandType, | |
| command_get_Name, | |
| command_put_Name, | |
| command_get_State, | |
| command_Cancel, | |
| command_putref_CommandStream, | |
| command_get_CommandStream, | |
| command_put_Dialect, | |
| command_get_Dialect, | |
| command_put_NamedParameters, | |
| command_get_NamedParameters | |
| }; | |
| static HRESULT WINAPI construction_QueryInterface(ADOCommandConstruction *iface, REFIID riid, void **obj) | |
| { | |
| TRACE( "%p, %s, %p\n", iface, debugstr_guid(riid), obj ); | |
| *obj = NULL; | |
| if (IsEqualIID(riid, &IID_IUnknown) || | |
| IsEqualIID(riid, &IID_ADOCommandConstruction)) | |
| { | |
| *obj = iface; | |
| } | |
| else | |
| { | |
| FIXME( "interface %s not implemented\n", debugstr_guid(riid) ); | |
| return E_NOINTERFACE; | |
| } | |
| ADOCommandConstruction_AddRef( iface ); | |
| return S_OK; | |
| } | |
| static ULONG WINAPI construction_AddRef(ADOCommandConstruction *iface) | |
| { | |
| struct command *command = impl_from_ADOCommandConstruction( iface ); | |
| return _Command_AddRef(&command->Command_iface); | |
| } | |
| static ULONG WINAPI construction_Release(ADOCommandConstruction *iface) | |
| { | |
| struct command *command = impl_from_ADOCommandConstruction( iface ); | |
| return _Command_Release(&command->Command_iface); | |
| } | |
| static HRESULT WINAPI construction_get_OLEDBCommand(ADOCommandConstruction *iface, IUnknown **command) | |
| { | |
| FIXME("%p, %p\n", iface, command); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI construction_put_OLEDBCommand(ADOCommandConstruction *iface, IUnknown *command) | |
| { | |
| FIXME("%p, %p\n", iface, command); | |
| return E_NOTIMPL; | |
| } | |
| static ADOCommandConstructionVtbl construct_vtbl = | |
| { | |
| construction_QueryInterface, | |
| construction_AddRef, | |
| construction_Release, | |
| construction_get_OLEDBCommand, | |
| construction_put_OLEDBCommand | |
| }; | |
| HRESULT Command_create( void **obj ) | |
| { | |
| struct command *command; | |
| if (!(command = malloc( sizeof(*command) ))) return E_OUTOFMEMORY; | |
| command->Command_iface.lpVtbl = &command_vtbl; | |
| command->ADOCommandConstruction_iface.lpVtbl = &construct_vtbl; | |
| command->Parameters_iface.lpVtbl = ¶meters_vtbl; | |
| command->type = adCmdUnknown; | |
| command->text = NULL; | |
| command->connection = NULL; | |
| list_init(&command->parameters); | |
| command->ref = 1; | |
| *obj = &command->Command_iface; | |
| TRACE( "returning iface %p\n", *obj ); | |
| return S_OK; | |
| } |