Unit msedb

Description

Uses

Classes, Interfaces, Objects and Records

Functions and Procedures

Types

Constants

Variables

Description

Overview

Classes, Interfaces, Objects and Records

Name	Description
Record `fielddefty`
Interface `imasterlink`
Interface `imselocate`
Interface `idbdata`
Interface `idbeditinfo`
Interface `ireccontrol`
Interface `ipersistentfieldsinfo`
Interface `idatasetsum`
Class `tdbfieldnamearrayprop`
Interface `idsfieldcontroller`
Interface `ifieldcomponent`
Interface `imsefield`
Class `tmsefield`
Class `tmsestringfield`
Class `tmseguidfield`
Class `tmsenumericfield`
Class `tmselongintfield`
Class `tmselargeintfield`
Class `tmsesmallintfield`
Class `tmsewordfield`
Class `tmseautoincfield`
Class `tmsefloatfield`
Class `tmsecurrencyfield`
Class `tmsebooleanfield`
Class `tmsedatetimefield`
Class `tmsedatefield`
Class `tmsetimefield`
Class `tmsebinaryfield`
Class `tmsebytesfield`
Class `tmsevarbytesfield`
Class `tmsebcdfield`
Record `blobidty`
Class `tblobcachenode`
Class `tblobcache`
Class `tmseblobfield`
Class `tmsememofield`
Class `tmsevariantfield`
Class `tmsedatalink`
Class `tfieldsdatalink`
Class `tfielddatalink`
Class `tmsedatasource`
Class `tpersistentfields`
Interface `idscontroller`
Interface `igetdscontroller`
Class `epostcancel`
Class `tdscontroller`
Interface `idbcontroller`
Class `tfieldlinkdatalink`
Class `tfieldlink`
Class `ttimestampfieldlink`
Class `tfieldfieldlink`
Class `tmseparam`
Class `tparamconnector`
Class `tmseparams`

Functions and Procedures

function getdsfields(const adataset: tdataset; const afields: array of tfield): fieldarty;

function getfielddefar(const fielddefs: tfielddefs): fielddefarty;

function getmsefieldclass(const afieldtype: tfieldtype): tfieldclass; overload;

function getmsefieldclass(const afieldtype: fieldclasstypety): tfieldclass; overload;

function fieldvariants(const afields: array of tfield): variantarty;

function fieldclasstoclasstyp(const fieldclass: fieldclassty): fieldclasstypety;

function fieldtosql(const field: tfield): msestring;

function fieldtooldsql(const field: tfield): msestring;

function paramtosql(const aparam: tparam): msestring;

function fieldchanged(const field: tfield): boolean;

function curfieldchanged(const field: tfield): boolean;

procedure fieldtoparam(const field: tfield; const param: tparam);

procedure copyfieldvalues(const source: tdataset; const dest: tdataset);

procedure msestringtoparam(const avalue: msestring; const param: tparam);

function getasmsestring(const field: tfield; const utf8: boolean = true): msestring;

procedure setasmsestring(const avalue: msestring; const field: tfield; const utf8: boolean = true);

function checkfieldcompatibility(const afield: tfield; const adatatype: tfieldtype): boolean;

function vartorealty(const avalue: variant): realty;

function locaterecord(const adataset: tdataset; const fields: array of tfield; const keys: array of const; const isnull: array of boolean; const keyoptions: array of locatekeyoptionsty; const options: locaterecordoptionsty): locateresultty;

function encodesqlstring(const avalue: msestring): msestring;

function encodesqlcstring(const avalue: msestring): msestring;

function encodesqlblob(const avalue: string): msestring;

function encodesqlinteger(const avalue: integer): msestring;

function encodesqllongword(const avalue: longword): msestring;

function encodesqllargeint(const avalue: int64): msestring;

function encodesqlqword(const avalue: qword): msestring;

function encodesqldatetime(const avalue: tdatetime): msestring;

function encodesqldate(const avalue: tdatetime): msestring;

function encodesqltime(const avalue: tdatetime): msestring;

function encodesqlfloat(const avalue: real): msestring;

function encodesqlcurrency(const avalue: currency): msestring;

function encodesqlboolean(const avalue: boolean): msestring;

function encodesqlvariant(const avalue: variant; cstyle: boolean): msestring;

procedure regfieldclass(const atype: fieldclasstypety; const aclass: fieldclassty);

procedure varianttorealty(const value: variant; out dest: realty); overload;

function varianttorealty(const value: variant):realty; overload;

procedure realtytovariant(const value: realty; out dest: variant); overload;

function realtytovariant(const value: realty): variant; overload;

function varianttoid(const value: variant): int64;

function idtovariant(const value: int64): variant;

function varianttomsestring(const value: variant): msestring;

function msestringtovariant(const value: msestring): variant;

function dbtrystringtoguid(const value: string; out guid: tguid): boolean;

function dbstringtoguid(const value: string): tguid;

function dbguidtostring(const avalue: tguid): string;

function dbcreateguidstring: string;

function guidparam(const value: tguid): varrecarty;

function opentodynarrayft(const items: array of tfieldtype): fieldtypearty;

Types

lookupdatatypety = (...);

bookmarkty = string;

fieldtypearty = array of tfieldtype;

fieldtypesty = set of tfieldtype;

fieldtypesarty = array of fieldtypesty;

datasetarty = array of tdataset;

pfielddefty = ˆfielddefty;

fielddefarty = array of fielddefty;

filtereditkindty = (...);

locateresultty = (...);

recnosearchoptionty = (...);

recnosearchoptionsty = set of recnosearchoptionty;

locatekeyoptionty = (...);

locatekeyoptionsty = set of locatekeyoptionty;

locaterecordoptionty = (...);

locaterecordoptionsty = set of locaterecordoptionty;

fieldarty = array of tfield;

optionmasterlinkty = (...);

optionsmasterlinkty = set of optionmasterlinkty;

getdatasourcefuncty = function: tdatasource of object;

fieldstatety = (...);

fieldstatesty = set of fieldstatety;

getmsestringdataty = function(const sender: tmsestringfield; out avalue: msestring): boolean of object;

setmsestringdataty = procedure(const sender: tmsestringfield; avalue: msestring) of object;

datetimefieldoptionty = (...);

datetimefieldoptionsty = set of datetimefieldoptionty;

getblobidfuncty = function(const afield: tfield; out aid: blobidty): boolean of object;

setvardataty = procedure(const sender: tmsevariantfield; avalue: variant) of object;

getvardataty = function(const sender: tmsevariantfield; out avalue: variant): boolean of object;

fielddatalinkstatety = (...);

fielddatalinkstatesty = set of fielddatalinkstatety;

fieldclassty = class of tfield;

fieldclasstypety = (...);

fieldclasstypearty = array of fieldclasstypety;

datasetoptionty = (...);

datasetoptionsty = set of datasetoptionty;

savepointoptionty = (...);

savepointoptionsty = set of savepointoptionty;

fieldlinkarty = array of ifieldcomponent;

dscontrollerstatety = (...);

dscontrollerstatesty = set of dscontrollerstatety;

datasetstatechangedeventty = procedure(const sender: tdataset; const statebefore: tdatasetstate) of object;

masterdataseteventty = procedure(const sender: tdataset; const master: tdataset) of object;

slavedataseteventty = procedure(const sender: tdataset; const slave: tdataset) of object;

afterdbopeventty = procedure(const sender: tdataset; var ok: boolean) of object;

opkindty = (...);

fieldeventty = procedure(const afield: tfield) of object;

fieldlinkoptionty = (...);

fieldlinkoptionsty = set of fieldlinkoptionty;

Constants

mse_vtguid = $ff;

guidbuffersize = 36;

de_modified = ord(high(tdataevent))+1;

de_afterdelete = ord(high(tdataevent))+2;

de_afterinsert = ord(high(tdataevent))+3;

de_afterpost = ord(high(tdataevent))+4;

de_hasactiveedit = ord(high(tdataevent))+5;

de_afterapplyupdate = ord(high(tdataevent))+6;

defaultdscontrolleroptions = [];

allfieldkinds = [fkData,fkCalculated,fkLookup,fkInternalCalc];

int32fields = [ftsmallint,ftinteger,ftword];

int64fields = [ftlargeint];

doublefields = [ftfloat,ftcurrency];

datetimefields = [ftdate,fttime,ftdatetime];

charfields = [ftstring,ftfixedchar];

widecharfields = [ftwidestring,ftfixedwidechar,ftwidememo];

textfields = [ftstring,ftfixedchar,ftwidestring,ftfixedwidechar,ftmemo,ftguid];

memofields = textfields+[ftmemo];

integerfields = [ftsmallint,ftinteger,ftword,ftlargeint,ftbcd];

booleanfields = [ftboolean,ftstring,ftfixedchar]+integerfields-[ftbcd];

realfields = [ftfloat,ftcurrency,ftbcd];

stringfields = textfields + integerfields + booleanfields +
                realfields + datetimefields;

widestringfields = [ftwidestring,ftfixedwidechar,ftwidememo];

blobfields = [ftblob,ftmemo,ftgraphic];

varsizefields = [ftstring,ftfixedchar,ftwidestring,ftfixedwidechar,
                  ftbytes,ftvarbytes,ftbcd,ftfmtbcd];

converrorstring = '?';

deprecatedbdsoptions = [
                         dso_postsavepoint,dso_deletesavepoint,
                         dso_cancelupdateonerror,dso_cancelupdatesonerror,
                         dso_cancelupdateondeleteerror,
                         dso_editonapplyerror,
                         dso_restoreupdateonsavepointrollback,
                         dso_noapply,dso_autoapply,
                         dso_autocommitret,dso_autocommit,
                         dso_refreshafterapply,dso_recnoapplyrefresh,
                         dso_refreshtransaction,
                         dso_notransactionrefresh,dso_recnotransactionrefresh,
                         dso_noprepare,
                         dso_cacheblobs,
                         dso_offline, 
                         dso_local   
                         ];

fieldtypeclasses: array[fieldclasstypety] of fieldclassty = 
          (tfield,tstringfield,tguidfield,tnumericfield,
           tlongintfield,tlargeintfield,tsmallintfield,
           twordfield,tautoincfield,tfloatfield,tcurrencyfield,
           tbooleanfield,
           tdatetimefield,tdatefield,ttimefield,
           tbinaryfield,tbytesfield,tvarbytesfield,
           tbcdfield,tblobfield,tmemofield,tgraphicfield,
           tvariantfield);

tfieldtypetotypety: array[tfieldtype] of fieldclasstypety = (
    
      ft_unknown,ft_string,ft_smallint,ft_longint,ft_word,
    
      ft_boolean,ft_float,ft_currency,ft_bcd,ft_date,ft_time,ft_datetime,
    
      ft_bytes,ft_varbytes,ft_autoinc,ft_blob,ft_memo,ft_graphic,ft_memo,
    
      ft_unknown,ft_unknown,ft_unknown,ft_unknown,ft_string,
    
      ft_string,ft_largeint,ft_unknown,ft_unknown,ft_unknown,
    
      ft_unknown,ft_unknown,ft_unknown,ft_variant,ft_unknown,
    
      ft_unknown,  ft_guid,ft_unknown,  ft_unknown
    
      ,ft_string,    ft_string
      );

realfcomp = [ftfloat,ftcurrency];

datetimefcomp = [ftdate,fttime,ftdatetime];

blobfcomp = [ftblob,ftgraphic,ftmemo];

memofcomp = [ftmemo];

longintfcomp = [ftboolean,ftsmallint,ftinteger,ftword];

largeintfcomp = longintfcomp + [ftlargeint];

stringfcomp = [ftstring,ftguid,ftfixedchar,ftwidestring,ftfixedwidechar,
                ftwidememo];

booleanfcomp = [ftboolean,ftsmallint,ftinteger,ftword];

fieldcompatibility: array[tfieldtype] of fieldtypesty = (
    
      [ftunknown],stringfcomp,longintfcomp,longintfcomp,longintfcomp,
    
      booleanfcomp,realfcomp,realfcomp,[ftbcd],
    
      datetimefcomp,datetimefcomp,datetimefcomp,
    
      [ftbytes],[ftvarbytes],[ftautoinc],
    
      blobfcomp,memofcomp,blobfcomp,memofcomp,
    
      [ftParadoxOle],[ftDBaseOle],[ftTypedBinary],[ftCursor],stringfcomp,
    
     stringfcomp,[ftLargeint],[ftADT],[ftArray],[ftReference],
    
      [ftDataSet],[ftOraBlob],[ftOraClob],[ftVariant],[ftInterface],
    
      [ftIDispatch],[ftGuid],[ftTimeStamp],[ftFMTBcd]
    
      ,stringfcomp,stringfcomp
      );

Description

Functions and Procedures

function getdsfields(const adataset: tdataset; const afields: array of tfield): fieldarty;

function getfielddefar(const fielddefs: tfielddefs): fielddefarty;

function getmsefieldclass(const afieldtype: tfieldtype): tfieldclass; overload;

function getmsefieldclass(const afieldtype: fieldclasstypety): tfieldclass; overload;

function fieldvariants(const afields: array of tfield): variantarty;

function fieldclasstoclasstyp(const fieldclass: fieldclassty): fieldclasstypety;

function fieldtosql(const field: tfield): msestring;

function fieldtooldsql(const field: tfield): msestring;

function paramtosql(const aparam: tparam): msestring;

function fieldchanged(const field: tfield): boolean;

function curfieldchanged(const field: tfield): boolean;

procedure fieldtoparam(const field: tfield; const param: tparam);

procedure copyfieldvalues(const source: tdataset; const dest: tdataset);

procedure msestringtoparam(const avalue: msestring; const param: tparam);

function getasmsestring(const field: tfield; const utf8: boolean = true): msestring;

procedure setasmsestring(const avalue: msestring; const field: tfield; const utf8: boolean = true);

function checkfieldcompatibility(const afield: tfield; const adatatype: tfieldtype): boolean;

function vartorealty(const avalue: variant): realty;

function locaterecord(const adataset: tdataset; const fields: array of tfield; const keys: array of const; const isnull: array of boolean; const keyoptions: array of locatekeyoptionsty; const options: locaterecordoptionsty): locateresultty;