How To Add Percentage Sign Quote In Sql Query

Structured Query Linguistic communication (SQL) is a standard computer language that contains a set up of divers syntax and expressions used for accessing and managing data in databases and in other information processing technologies.

The American National Standards Institute (ANSI) defines a standard for SQL. Most RDBMSs use that standard and have extended it, making SQL syntax across dissimilar RDBMSs slightly unlike from one another.

Query expressions in ArcGIS adhere to standard SQL expressions. The SQL syntax you employ inside an expression differs depending on the data source. Each data source has its own variant of SQL, which are referred to as SQL dialects.

For example:

File-based data, including file geodatabases, shapefiles, in-memory table views, text files such as .dbf, .csv, .txt, .xlsx tables, and feature services that use standardized queries use the ArcGIS SQL dialect that supports a subset of SQL capabilities.
Mobile geodatabases, ST_geometry SQLite, GeoPackage, and Excel use SQLite SQL dialect.
Databases or enterprise geodatabases employ the SQL syntax of the underlying RDBMS, such as, Oracle, SQL Server, PostgreSQL, SAP HANA, and IBM Db2, where each database uses its own slightly dissimilar SQL dialect.

When using ArcGIS dialog boxes to construct a SQL expression, autocomplete is used to help you apply the correct syntax for the data source yous're querying. Equally you blazon, a prompt appears, showing the field names, values, keywords, and operators supported by your information source.

Tip:

Review the following to help decide when ArcGIS SQL syntax is used or when the SQL syntax of the underlying RDBMS is used when creating an SQL expression.

If the information within your SQL expression comes from a mixture of data source locations, the following will occur:
- Where the data sources come from both file-based and from an RDBMS, ArcGIS SQL syntax will be used.
If all the information within your SQL expression comes from the aforementioned data source location, the following volition occur:
- Where the data source is file based data, ArcGIS SQL syntax will be used.
- Where the data source is a database or enterprise geodatabase, ArcGIS will laissez passer the SQL expression to the RDBMS for resolution and you will need to consult the documentation for your database management organisation for the specific expression syntax and information types supported.

Inside ArcGIS Pro, the SQL expression dialog box can be found in the following locations:

Select past attributes using the Select Layer by Aspect geoprocessing tool.
Definition Query tab on the Layer Properties dialog box.
Display filters tab in the Symbology pane.
Create reports using the Create New Reports pane.
Consign tables using the Table to Table geoprocessing tool.
Export features using the Feature Class to Characteristic Form geoprocessing tool.
Use the Calculate Field geoprocessing tool to create an expression to perform simple or complex calculations on field values.
Utilise Select to query data for further assay.
Use the Make Query Tabular array geoprocessing tool to create a layer or table view.
Use Brand Feature Layer geoprocessing tool to create a feature layer.
Create a view in a database or geodatabase using the Create Database View geoprocessing tool.
Utilize the Suspend geoprocessing tool to append multiple input datasets into a target dataset.
Use ProSDK Cadre.Data.QueryDef.

An overview of SQL expression syntax

A SQL expression contains a combination of ane or more than values, operators, and SQL functions that can be used to query or select a subset of features and tabular array records within ArcGIS.

All SQL queries are expressed using the keyword SELECT.

SELECT * FROM forms the first function of the SQL expression and is automatically supplied for you lot on about ArcGIS dialog boxes. For example, when you construct a query past writing SQL syntax, a SELECT argument is used to select fields from a layer or tabular array and is supplied for y'all.

The side by side part of the SQL expression that comes after SELECT * FROM <Layer_name> is the WHERE clause. The WHERE clause is used to get records that run into specific criteria and is the part of the expression you must build.

Tip:

The asterisk (*) in a SQL expression is used to inquire for all columns.

Hither is a basic grade of a SQL expression WHERE clause:

<Field_name> <Operator> <Value or String>

For example, STATE_NAME = 'Florida'. This expression contains a single clause and selects all features containing 'Florida' in the STATE_NAME field.

For compound expressions, the post-obit class is used:

<Field_name> <Operator> <Value or String> <Connector> <Field_name> <Operator> <Value or String> ...

For example, STATE_NAME = 'Florida' OR (STATE_NAME = 'Due south Carolina' AND POP2010 > 15000). This compound expression is comprised of multiple clauses connected by a logical operator, AND or OR, and selects all features containing Florida in the STATE_NAME field, and all the features that comprise both South Carolina in the STATE_NAME field and have a value greater than 15,000 in the field named POP2010.

Tip:

Optionally, parentheses () can exist used for defining the society of operations in compound expressions.

Because you lot are selecting columns as a whole, you cannot restrict the SELECT to return merely some of the columns in the respective table because the SELECT * syntax is hard-coded. For this reason, keywords, such every bit Singled-out, ORDER BY, and Group By, cannot be used in an SQL expression in ArcGIS except when using subqueries. To learn more, see Subqueries.

The following sections describe the elements of common SQL query expressions used in ArcGIS.

Common queries: Searching strings

Strings must always be enclosed in single quotation marks in queries, for instance:

STATE_NAME = 'California'

Strings are case sensitive in expressions, except when run on geodatabases in Microsoft SQL Server. To make a case-insensitive search in other data sources, you lot tin can use an SQL function to catechumen all values to the same case. For file-based data sources such equally file geodatabases or shapefiles, you can use the UPPER or LOWER function to set the case for a selection. For example, the following expression selects the state whose name is stored as 'Rhode Island' or 'RHODE Island':

UPPER(STATE_NAME) = 'RHODE ISLAND'

If the cord contains a unmarried quotation mark, you first need to use another unmarried quotation mark as an escape character, for example:

NAME = 'Alfie''due south Trough'

Apply the LIKE operator (instead of the = operator) to build a fractional string search. For case, this expression selects Mississippi and Missouri among U.s. state names:

STATE_NAME Similar 'Miss%'

The percent symbol (%) means that anything is adequate in its place: 1 character, a hundred characters, or no grapheme. Alternatively, if yous want to search with a wildcard that represents one character, use an underscore (_). For case, this expression finds Catherine Smith and Katherine Smith:

OWNER_NAME LIKE '_atherine Smith'

You tin can utilize greater than (>), less than (<), greater than or equal (>=), less than or equal (<=), non equal (<>), and Betwixt operators to select string values based on sorting order. For example, this expression selects all the cities in a coverage with names starting with the letters Thousand through Z:

CITY_NAME >= 'One thousand'

String functions tin be used to format strings. For example, the LEFT function returns a certain number of characters starting on the left of the string. In this example, the query returns all states starting with the letter A:

LEFT(STATE_NAME,one) = 'A'

Refer to the documentation of your database management system (DBMS) for a list of supported functions.

Common expressions: Searching for NULL values

Yous can use the Null keyword to select features and records that have null values for the specified field. The Zero keyword is ever preceded by IS or IS Non. For example, to find cities whose 1996 population has not been entered, you can use the post-obit:

POPULATION IS Cipher

Alternatively, to find cities whose 1996 population has been entered, y'all can use the following:

POPULATION96 IS NOT Nothing

Mutual expressions: Searching numbers

The decimal betoken (.) is always used as the decimal delimiter, regardless of your locale or regional settings. The comma cannot be used equally a decimal or thousands delimiter in an expression.

Y'all can query numbers using the equal (=), not equal (<>), greater than (>), less than (<), greater than or equal to (>=), less than or equal to (<=), and Betwixt operators, for example:

POPULATION >= 5000

Numeric functions can exist used to format numbers. For instance, the ROUND part rounds a number to a given number of decimals in a file geodatabase:

Round(SQKM,0) = 500

Refer to your DBMS documentation for a list of supported numeric functions.

Dates and time

Full general rules and common expressions

Geodatabase data sources shop dates in a appointment-time field. However, shapefiles practice non. Therefore, most of the query syntax listed below contains a reference to the fourth dimension. In some cases, the fourth dimension part of the query may be safely omitted if the field is known to contain only dates; in other cases, it needs to exist stated, or the query volition return a syntax error.

Searching appointment fields requires careful attention to the syntax required past your data source. If you build a date query in Clause way of the Query Builder, the correct syntax will be automatically generated for you. Hither is an example of a query that will render all records on or after January 1, 2011, for a file geodatabase data source:

INCIDENT_DATE >= appointment '2011-01-01 00:00:00'

Dates are stored in the underlying database as a reference to December xxx, 1899, at 00:00:00. This is valid for all the data sources listed here.

The purpose of this department is only to aid yous query dates, not time values. When a time that is not null is stored with the dates (for case, January 12, 1999, 04:00:00), querying the date only will not return the record considering when you pass only a date to a engagement-time field, it will fill the time with zeros and retrieve merely the records where the time is 12:00:00 a.m.

The attribute table shows date and time in a user-friendly format, depending on your regional settings, rather than the underlying database's format. This is fine most of the time, but it also has a few drawbacks:

The string shown in the SQL query may only slightly resemble the value shown in the table, especially when fourth dimension is involved. For instance, a time entered as 00:00:15 shows as 12:00:15 a.m. in the attribute table, with the The states equally your regional settings, and the comparable query syntax is Datefield = '1899-12-30 00:00:15'.
The attribute table does not know what the underlying data source is until you save your edits. It will commencement endeavor to format the value entered to fit its ain format, and so upon saving edits, it volition try to tweak the resulting value to fit into the database. Because of this, you can enter a time in a shapefile, but you will find that it is dropped when yous salvage your edits. The field volition then contain a value '1899-12-30' that will evidence every bit 12:00:00 a.m. or the equivalent depending on your regional settings.

Date-time syntax for enterprise geodatabases

Oracle

Datefield = engagement 'yyyy-mm-dd'

Keep in mind this volition not render records where the fourth dimension is not nothing.

An alternative format for querying dates in Oracle follows:

Datefield = TO_DATE('yyyy-mm-dd hh:mm:ss','YYYY-MM-DD HH24:MI:SS')

The 2d parameter 'YYYY-MM-DD HH24:MI:SS' describes the format used for querying. An actual query looks like this:

Datefield = TO_DATE('2003-01-08 14:35:00','YYYY-MM-DD HH24:MI:SS')

You tin can apply a shorter version:

TO_DATE('2003-eleven-18','YYYY-MM-DD')

Once again, this volition non render records where the fourth dimension is not null.

SQL Server

Datefield = 'yyyy-mm-dd hh:mm:ss'

The hh:mm:ss office of the query can be omitted when the time is not ready in the records.

The post-obit is an alternative format:

Datefield = 'mm/dd/yyyy'

IBM Db2

Datefield = TO_DATE('yyyy-mm-dd hh:mm:ss','YYYY-MM-DD HH24:MI:SS')

The hh:mm:ss part of the query cannot be omitted even if the time is equal to 00:00:00.

PostgreSQL

Datefield = TIMESTAMP 'YYYY-MM-DD HH24:MI:SS' Datefield = TIMESTAMP 'YYYY-MM-DD'

You must specify the total time stamp when using equal-to queries or no records will exist returned. You can successfully query with the following statements if the table you query contains date records with these verbal time stamps (2007-05-29 00:00:00 or 2007-05-29 12:fourteen:25):

select * from tabular array where date = '2007-05-29 00:00:00';

select * from table where date = '2007-05-29 12:14:25';

If you utilize other operators—such equally greater than, less than, greater than or equal to, or less than or equal to—you don't need to designate the time, but you can if you want to be that precise. Both of the following statements piece of work:

select * from table where appointment < '2007-05-29';

select * from table where date < '2007-05-29 12:xiv:25';

File geodatabases, shapefiles, coverages, and other file-based data sources

Datefield = engagement 'yyyy-mm-dd'

File geodatabases back up the utilise of a time in the date field, so this can be added to the expression:

Datefield = date 'yyyy-mm-dd hh:mm:ss'

Shapefiles and coverages do not support the use of fourth dimension in a date field.

All SQL used by the file geodatabase is based on the SQL-92 standard.

Known limitations

Querying a engagement on the left part (first table) of a join simply works with file-based data sources, such as file geodatabases, shapefiles, and DBF tables. Even so, there is a possible workaround for working with information that is not file-based, similar enterprise data every bit described below.

Querying a engagement on the left role of a join volition be successful when using the limited version of SQL developed for file-based data sources. If you are not using such a data source, you can strength the expression to use this format. This can exist washed past making sure the query expression involves fields from more than one bring together table. For instance, if a feature class and a table (FC1 and Table1) are joined and are both from an enterprise geodatabase, the following expressions will fail or return no data:

FC1.appointment = date #01/12/2001# FC1.appointment = date '01/12/2001'

To query successfully, you can create a query as follows:

FC1.engagement = date '01/12/2001' and Table1.OBJECTID > 0

Since the query involves fields from both tables, the limited SQL version will be used. In this expression, Table1.OBJECTID is ever > 0 for records that matched during bring together creation, and so this expression is truthful for all rows that comprise join matches.

To ensure that every tape with FC1.engagement = appointment '01/12/2001' is selected, use the following query:

FC1.engagement = date '01/12/2001' and (Table1.OBJECTID IS Not NULL OR Table1.OBJECTID IS Cipher)

This query will select all records with FC1.engagement = date '01/12/2001', whether or not there was a join match for each item record.

Combining expressions

Compound expressions can be built by combining expressions with the AND and OR operators. For case, the following expression selects all the houses that have more than than 1,500 foursquare feet and a garage for 3 or more cars:

Expanse > 1500 AND GARAGE > 3

When you lot use the OR operator, at least one side of the expression of the 2 separated past the OR operator must be true for the tape to exist selected, for case:

RAINFALL < xx OR Gradient > 35

Use the NOT operator at the beginning of an expression to find features or records that don't match the specified expression, for example:

Non STATE_NAME = 'Colorado'

Not expressions can be combined with AND and OR. For case, this expression selects all the New England states except Maine:

SUB_REGION = 'New England' AND NOT STATE_NAME = 'Maine'

Calculations

Calculations can be included in expressions using the arithmetics operators +, -, *, and /. Calculations tin can be between fields and numbers, for example:

Area >= PERIMETER * 100

Calculations can also be performed between fields. For example, to find the countries with a population density of less than or equal to 25 people per square mile, you tin can employ this expression:

POP1990 / AREA <= 25

Operator precedence

Expressions are evaluated according to standard operator precedence rules. For example, the part of an expression enclosed in parentheses is evaluated before the office that isn't enclosed.

HOUSEHOLDS > MALES * (POP90_SQMI + AREA)

Y'all tin can add parentheses in SQL Edit mode by typing them, or use the Group and Ungroup commands in Clause mode to add or remove them.

Subqueries

A subquery is a query nested in another query and is supported by geodatabase information sources but. Information technology can be used to use predicate or aggregate functions or to compare data with values stored in some other table. This can exist washed with the IN or Any keyword. For instance, this query selects just the countries that are non also listed in the indep_countries table:

COUNTRY_NAME NOT IN (SELECT COUNTRY_NAME FROM indep_countries)

Shapefiles, and other nongeodatabase file-based information sources do non back up subqueries. Subqueries that are performed on versioned enterprise characteristic classes and tables will not render features that are stored in the delta tables. File geodatabases provide the limited support for subqueries explained in this section, while enterprise geodatabases provide full support. For information on the total set of subquery capabilities of enterprise geodatabases, refer to your DBMS documentation.

This query returns the features with a GDP2006 greater than the GDP2005 of whatever of the features independent in countries:

GDP2006 > (SELECT MAX(GDP2005) FROM countries)

Subquery back up in file geodatabases is limited to the following:

Scalar subqueries with comparison operators. A scalar subquery returns a single value, for example:
```
GDP2006 > (SELECT MAX(GDP2005) FROM countries)
```
For file geodatabases, the set functions AVG, COUNT, MIN, MAX, and SUM can only exist used in scalar subqueries.

EXISTS predicate, for example:

EXISTS (SELECT * FROM indep_countries WHERE COUNTRY_NAME = 'United mexican states')

Operators

The following is the full list of query operators supported past file geodatabases, shapefiles, coverages, and other file-based data sources. They are also supported by enterprise geodatabases, although these information sources may require different syntax. In addition to the operators below, enterprise geodatabases support other capabilities. See your DBMS documentation for details.

Arithmetic operators

You utilize an arithmetics operator to add together, subtract, multiply, and divide numeric values.

Arithmetic operators
Operator	Description
*	Arithmetics operator for multiplication
/	Arithmetics operator for sectionalization
+	Arithmetic operator for addition
-	Arithmetics operator for subtraction

Comparison operators

You use comparison operators to compare one expression to another.

Comparison operators
Operator	Description
<	Less than. Information technology tin be used with strings (comparison is based on alphabetical order), numbers, and dates.
<=	Less than or equal to. It tin be used with strings (comparing is based on alphabetical club), numbers, and dates.
<>	Not equal to. It tin exist used with strings (comparison is based on alphabetical order), numbers, and dates.
>	Greater than. Information technology can be used with strings (comparison is based on alphabetical order), numbers, and dates.
>=	Greater than or equal to. It can be used with strings (comparison is based on alphabetical order), numbers, and dates.
[NOT] BETWEEN x AND y	Selects a record if it has a value greater than or equal to x and less than or equal to y. When preceded by Non, it selects a tape if information technology has a value outside the specified range. For case, this expression selects all records with a value greater than or equal to ane and less than or equal to 10: OBJECTID BETWEEN 1 AND 10 This is the equivalent of the following expression: OBJECTID >= one AND OBJECTID <= ten Yet, the expression with BETWEEN provides meliorate performance if y'all're querying an indexed field.
[NOT] EXISTS	Returns True if the subquery returns at least one tape; otherwise, it returns FALSE. For example, this expression returns TRUE if the OBJECTID field contains a value of l: EXISTS (SELECT * FROM parcels WHERE OBJECTID = 50) EXISTS is supported in file and enterprise geodatabases only.
[Non] IN	Selects a record if information technology has one of several strings or values in a field. When preceded by NOT, it selects a tape if it doesn't take ane of several strings or values in a field. For example, this expression searches for 4 different state names: STATE_NAME IN ('Alabama', 'Alaska', 'California', 'Florida')
IS [Non] NULL	Selects a record if it has a null value for the specified field. When NULL is preceded by NOT, it selects a record if it has any value for the specified field.
x [Not] Similar y [ESCAPE 'escape-character']	Use the Like operator (instead of the = operator) with wildcards to build a partial string search. The per centum symbol (%) ways that anything is acceptable in its place: 1 grapheme, a hundred characters, or no character. Alternatively, if you want to search with a wildcard that represents one character, utilise an underscore (_). If you need to access noncharacter data, use the CAST function. For example, this query returns numbers that brainstorm with viii from the integer field SCORE_INT: CAST (SCORE_INT Every bit VARCHAR(10)) LIKE '8%' To include the percent symbol or underscore in your search cord, use the ESCAPE keyword to designate another character every bit the escape character, which in plough indicates that a real per centum sign or underscore immediately follows. For example, this expression returns whatever string containing 10%, such equally ten% Discount or A10%: Corporeality LIKE '%10$%%' ESCAPE '$'

Logical operators

Logical operators
Operator	Description
AND	Combines two conditions and selects a tape if both conditions are true. For example, the following expression selects any business firm with more than one,500 square feet and a garage for more than two cars: Surface area > 1500 AND GARAGE > 2
OR	Combines 2 conditions and selects a tape if at to the lowest degree one condition is true. For example, the following expression selects whatsoever house with more than 1,500 square feet or a garage for more than two cars: Expanse > 1500 OR GARAGE > 2
NOT	Selects a record if information technology doesn't match the expression. For instance, the following expression selects all states but California: Non STATE_NAME = 'California'

String operators


Operator	Description
\|\|	Returns a character string that is the result of concatenating two or more cord expressions. FIRST_NAME \|\| MIDDLE_NAME \|\| LAST_NAME

Functions

The following is the full list of functions supported by file geodatabases, shapefiles, coverages, and other file-based data sources. The functions are also supported by enterprise geodatabases, although these data sources may crave unlike syntax or part names. In add-on to the functions below, enterprise geodatabases support other capabilities. See your DBMS documentation for details.

Date functions

Date functions
Function	Description
CURRENT_DATE	Returns the current date.
Excerpt(extract_field FROM extract_source)	Returns the extract_field portion of the extract_source. The extract_source argument is a appointment-time expression. The extract_field statement can be one of the post-obit keywords: YEAR, MONTH, Twenty-four hours, Hr, Infinitesimal, or SECOND.
Current Time	Returns the current fourth dimension.

Cord functions

Arguments denoted as string_exp can exist the proper noun of a column, a character string literal, or the result of some other scalar office, where the underlying data blazon tin can exist represented as a grapheme type.

Arguments denoted as character_exp are variable-length character strings.

Arguments denoted equallystart or length can be a numeric literal or the issue of another scalar role, where the underlying data type can be represented as a numeric type.

These string functions are 1 based; that is, the first grapheme in the string is grapheme i.

Cord functions
Function	Description
CHAR_LENGTH(string_exp)	Returns the length in characters of the string expression.
LOWER(string_exp)	Returns a cord equal to that in string_exp, with all uppercase characters converted to lowercase.
POSITION(character_exp IN character_exp)	Returns the position of the get-go grapheme expression in the second character expression. The result is an exact numeric with an implementation-defined precision and a scale of nix.
SUBSTRING(string_exp FROM start FOR length)	Returns a character string that is derived from string_exp, first at the character position specified past starting time for length characters.
TRIM(BOTH \| LEADING \| TRAILING trim_character FROM string_exp)	Returns the string_exp with the trim_character removed from the leading, abaft, or both ends of the cord.
UPPER(string_exp)	Returns a string equal to that in string_exp, with all lowercase characters converted to capital.

Numeric functions

All numeric functions return a numeric value.

Arguments denoted as numeric_exp, float_exp, or integer_exp can exist the proper name of a column, the upshot of some other scalar part, or a numeric literal, where the underlying data type could be represented as a numeric blazon.

Numeric functions
Function	Description
ABS(numeric_exp)	Returns the absolute value of numeric_exp.
ACOS(float_exp)	Returns the arccosine of float_exp equally an angle, expressed in radians.
ASIN(float_exp)	Returns the arcsine of float_exp as an angle, expressed in radians.
ATAN(float_exp)	Returns the arctangent of float_exp as an angle, expressed in radians.
CEILING(numeric_exp)	Returns the smallest integer greater than or equal to numeric_exp.
COS(float_exp)	Returns the cosine of float_exp, where float_exp is an angle expressed in radians.
Floor(numeric_exp)	Returns the largest integer less than or equal to numeric_exp.
LOG(float_exp)	Returns the natural logarithm of float_exp.
LOG10(float_exp)	Returns the base x logarithm of float_exp.
Modernistic(integer_exp1, integer_exp2)	Returns the residual of integer_exp1 divided by integer_exp2.
Power(numeric_exp, integer_exp)	Returns the value of numeric_exp to the ability of integer_exp.
ROUND(numeric_exp, integer_exp)	Returns numeric_exp rounded to integer_exp places to the right of the decimal point. If integer_exp is negative, numeric_exp is rounded to \|integer_exp\| places to the left of the decimal point.
SIGN(numeric_exp)	Returns an indicator of the sign of numeric_exp. If numeric_exp is less than zero, -1 is returned. If numeric_exp equals zero, 0 is returned. If numeric_exp is greater than zero, i is returned.
SIN(float_exp)	Returns the sine of float_exp, where float_exp is an angle expressed in radians.
TAN(float_exp)	Returns the tangent of float_exp, where float_exp is an angle expressed in radians.
TRUNCATE(numeric_exp, integer_exp)	Returns numeric_exp truncated to integer_exp places to the right of the decimal betoken. If integer_exp is negative, numeric_exp is truncated to \|integer_exp\| places to the left of the decimal point.

CAST function

The Bandage() function converts a value or an expression from one data type to another specified data type. The syntax is as follows:

CAST (expression Equally data_type(length))

Where expression is a required parameter and can exist a literal value or a valid expression of whatsoever type (for example, column name, variable) that will be converted.
Where data_type is a required parameter and the keyword used is the resulting data type to which the expression will exist bandage. Encounter the table below for a list of keywords to utilise for valid information types.
Where length is an optional parameter and specifies the length of the resulting data type.

For example, in some scenarios, a string functioning might be necessary, just if the data is stored in a number type field, the query wouldn't work. Even so, using the CAST() function, you tin cast the number field to a string for a SQL functioning. This code casts the number field SQLNUM as a text field, which can then be used in a text operation.

Cast(SQLNUM AS CHARACTER(12))

The post-obit tabular array contains the keywords to use for data type conversions and can be specified in capital letter or lowercase.

Supported data type conversions when using the Cast function
Data type	Keyword
Long Integer	INTEGER INT
Brusque Integer	SMALLINT
Float (single-precision floating point)	Real FLOAT [p] defaults to 7, which is equivalent to Existent. p > 7 is equivalent to DOUBLE PRECISION
Double (double-precision floating point)	DOUBLE PRECISION NUMERIC (p[,s]) DECIMAL (p[,s])
String	CHAR(due north) VARCHAR(n) Grapheme(n)
Datetime	DATE Time TIMESTAMP
p—Precision s—Scale n—Defines the length of the string in characters ( )—Required parameter [ ]—Optional parameter

Bandage function examples

Example one:
Bandage(AREA AS INTEGER)

Casting Area, which is a Float data type, to an INTEGER returns an integer and truncates any result value later the decimal.
Instance 2:
Cast(Rent As Bladder) + Utilities > 2000.45

Casting Rent, which is a Graphic symbol information blazon, to a FLOAT data type and where Utilities is as well a Float data blazon.