{"id":25230,"date":"2020-11-05T15:24:27","date_gmt":"2020-11-05T08:24:27","guid":{"rendered":"https:\/\/tom.ji42.com\/?p=25230"},"modified":"2020-11-05T15:24:27","modified_gmt":"2020-11-05T08:24:27","slug":"vfp-data-types","status":"publish","type":"post","link":"https:\/\/tom.tomwork.net\/?p=25230","title":{"rendered":"VFP Data Types"},"content":{"rendered":"

VFP has two realms that concern datatypes: the DBF table, and the types of variables and .value property. There are 3 differences: objects, numerics, and chars. There is no Object type of DBF field, and DBF has different kinds of numerics: integer, float, currency, etc. as where numeric variables are all stored in floating point. VFP automagically converts back and forth when it moves data between memory and disk. As far as I know this should not concern anyone – it has been this way for years, and no one has ever suggested that there are any pitfalls to be aware of.<\/p>\n

\"\"\u00a0Moving memos to memory does the same thing, it ends up as a character variable type. —\u00a0Mike Helland<\/a>
\n<\/span>
\nOk, I got bit: Currency’s don’t play nice with\u00a0Pad L<\/a>() – you have to use\u00a0MtoN<\/a>().\u00a0Thanks Bill
\n<\/small><\/p>\n

\n

DBF\u00a0DataTypes<\/a>:
\nFrom the VFP help topic\u00a0Data and Field Types<\/b><\/span><\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Data type<\/th>\nDescription<\/th>\nSize (bytes)<\/th>\nRange<\/th>\n<\/tr>\n
Character<\/td>\nAny text<\/td>\n1 to 254<\/td>\nAny characters<\/td>\n<\/tr>\n
\"\"\u00a0Varchar<\/td>\nAny text<\/td>\n1 to 254<\/td>\nAny characters<\/td>\n<\/tr>\n
\"\"\u00a0Varbinary<\/td>\nBinary data<\/td>\n1 to 254<\/td>\nBinary data<\/td>\n<\/tr>\n
Date<\/td>\nChronological data consisting of month, year, and day<\/td>\n8<\/td>\nWhen using strict date formats, {^0001-01-01}, January 1st, 1 A.D to {^9999-12-31}, December 31st, 9999 A.D.<\/td>\n<\/tr>\n
Date Time<\/a><\/td>\nChronological data consisting of month, year, day, and time<\/td>\n8<\/td>\n{^0001-01-01}, January 1st, 1 A.D to {^9999-12-31}, December 31st, 9999 A.D., plus 00:00:00 a.m. to 11:59:59 p.m.<\/td>\n<\/tr>\n
Numeric<\/td>\nIntegers or fractions<\/td>\n1 to 20<\/td>\n– .9999999999E+19 to .9999999999E+20<\/td>\n<\/tr>\n
Float<\/td>\nIntegers or fractions<\/td>\n1 to 20<\/td>\n– .9999999999E+19 to .9999999999E+20<\/td>\n<\/tr>\n
Integer<\/td>\nIntegers<\/td>\n4<\/td>\n-2,147,483,647 to 2,147,483,647<\/td>\n<\/tr>\n
Double<\/td>\n<\/td>\n1 to 20<\/td>\n– .9999999999E+19 to .9999999999E+20<\/td>\n<\/tr>\n
Currency<\/td>\nMonetary amounts<\/td>\n8 bytes<\/td>\n– 922337203685477.5807 to 922337203685477.5807<\/td>\n<\/tr>\n
Logical<\/td>\nBoolean value of true or false<\/td>\n1 byte<\/td>\nTrue (.T.) or False (.F.)<\/td>\n<\/tr>\n
Memo<\/a><\/td>\nAny text<\/td>\nIn the DBF 4 bytes\/memo
\nIn the FPT allocated in chuncks based on SET BLOCKSIZE<\/td>\n		Any characters<\/td>\n<\/tr>\n
General<\/td>\ndata and host program<\/td>\nIn the DBF 4 bytes\/memo
\nIn the FPT allocated in chuncks based on SET BLOCKSIZE<\/td>\n		OLE Documents<\/td>\n<\/tr>\n
Blob<\/a><\/td>\nBinary data<\/td>\nIn the DBF 4 bytes\/memo
\nIn the FPT allocated in chuncks based on SET BLOCKSIZE<\/td>\n		Binary data<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
\n

Variant<\/b>\u00a0All\u00a0FoxPro<\/a>\u00a0memory variables are basically variant. They can contain any of the\u00a0Visual FoxPro<\/a>\u00a0data types and the null value. Once a value is stored to a variant, the variant assumes the data type of the data it contains.<\/p>\n

\n

Nulls<\/b><\/p>\n

Type() and\u00a0Var Type<\/a>() handle NULLs in a different way. Here’s a demonstration (which is quicker than words!):<\/p>\n

\r\n?Type('m.test')   && Prints: U\r\n?VarType(m.test)  && Prints: U  (and DOESN'T give a var not found error!!!)\r\nm.test = .null.\r\n?Type('m.test')   && Prints: L  (Like an uninitialized parameter)\r\n?VarType(m.test)  && Prints: X\r\nm.test = 1\r\n?Type('m.test')   && Prints: N\r\n?VarType(m.test)  && Prints: N\r\nm.test = .null.\r\n?Type('m.test')   && Prints: N  (It remembers!)\r\n?VarType(m.test)  && Prints: X\r\n\r\ncreate cursor tester ( Fld1 N(5) NULL )\r\nappend blank\r\nreplace fld1 with .NULL.\r\n?type('tester.fld1')   && Prints: N\r\n?vartype(tester.fld1)  && Prints: X\r\nscatter memvar\r\n?type('m.fld1')        && Prints: N\r\n?vartype(m.fld1)       && Prints: X\r\n\r\n<\/code><\/pre>\n
The conclusion is, you CAN use\u00a0Var Type<\/a>() even if you’re not sure of a variable’s existence, PLUS it protects you from .NULL. variables that had had a value before they were null, but it’s no help in determining the real type of a field containing .NULL.<\/p>\n
VarType() is fine for non-existant variables, but it errors when checking the type of a property of a non-existant object. For example;
\n<\/span><\/p>\n
loObj = NULL\r\n? TYPE(\"loObj.Name\") && Returns U as undefined\r\n? VarType(loObj.Name) && Errors with variable not found\r\n<\/pre>\n
 <\/p>\n
\n
Double Field Type<\/b><\/p>\n
Use the Double data type instead of Numeric when you need more accuracy, a fixed amount of storage in your table, or true floating-point values. For more information about the specifications for this type, see the tables of Data and Field Types.<\/p>\n
In a table, unlike Numeric data, you determine the position of the decimal point when you enter the value.<\/p>\n
\n
Numeric and Float<\/b>\u00a0data types are identical. The only difference is the spelling of the name of the data type. The Float type was introduced to Fox for compatibility to dBase IV many yearas ago. IN VFP the float type is no different than the numeric type.
\nHmmm, I see it is stored in plain ascii text, just like a Numeric (like you said). So it isn’t a floating point at all.
\nNo it is not floating point. It was added so that Fox would not choke on the Float type in a DBF created with dBASE IV. dBASE IV’s Float is a floating point number, but Fox’s is not.<\/span>\u00a0–\u00a0Jim Booth<\/a>\"Offsite<\/p>\n
\n
\"\"\u00a0Fields and Rounding<\/b><\/p>\n