For example, if record A has price 5, and record B has noprice value, then:. WHEREprice = 5 matches A. WHERENOT(price = 5) matches neither A nor B. WHEREprice 5 matches neither A nor B.

• Findattribute Called With A Null Value Calculator

WHERENOT(price 5) matches A. WHERE price = 99 matches neither A nor B. WHERENOT(price = 99) matches A.

WHEREprice 99 matches A. WHERE NOT(price 99) matches neitherA nor BSortingFor any sort order specified, EQL returns:. Normal results.

Null is a perfectly valid value for many of the properties in my config and I dont want to have to null check attributes everywhere: var attribute = element.Attribute(attribute); var value = attribute null? Null: attribute.Value; A further reason I dont want to write code like this is that it will make it easier to mis type names of. Hi all, I'm trying to create a model that will take selected feature classes, search their attributes, and remove any Null values in these tables. Some of these fields will be an integar field type so I would need to replace these Null's with 0.

Records for a NaNvalue. Records with aNULL value.

The Greek lowercase character is used to represent Null in.Null (or NULL) is a special marker used in to indicate that a data value does not exist in the database. Introduced by the creator of the database model, Null serves to fulfil the requirement that all true support a representation of 'missing information and inapplicable information'. Codd also introduced the use of the lowercase (ω) symbol to represent Null in. In SQL, NULL is a used to identify this marker.A null should not be confused with a value of 0. A null value indicates a lack of a value — a lack of a value is not the same thing as a value of zero in the same way that a lack of an answer is not the same thing as an answer of 'no'. For example, consider the question 'How many books does Adam own?' The answer may be 'zero' (we know that he owns none) or 'null' (we do not know how many he owns).

In a database table, the column reporting this answer would start out with no value (marked by Null), and it would not be updated with the value 'zero' until we have ascertained that Adam owns no books.SQL null is a state, not a value. This usage is quite different from most programming languages, where of a reference means it is not pointing to any object. Contents.History E. Codd mentioned nulls as a method of representing missing data in the in a 1975 paper in the FDT Bulletin of. Codd's paper that is most commonly cited in relation with the semantics of Null (as adopted in SQL) is his 1979 paper in the, in which he also introduced his, although much of the other proposals from the latter paper have remained obscure. Section 2.3 of his 1979 paper details the semantics of Null propagation in arithmetic operations as well as comparisons employing a logic when comparing to nulls; it also details the treatment of Nulls on other set operations (the latter issue still controversial today).

In circles, the original proposal of Codd (1975, 1979) is now referred to as 'Codd tables'. Codd later reinforced his requirement that all RDBMSs support Null to indicate missing data in a 1985 two-part article published in magazine.The 1986 SQL standard basically adopted Codd's proposal after an implementation prototype in. Although recognized nulls (alongside duplicate rows) as one of the most controversial features of SQL, he defended the design of Nulls in SQL invoking the pragmatic arguments that it was the least expensive form of system support for missing information, saving the programmer from many duplicative application-level checks (see ) while at the same time providing the database designer with the option not to use Nulls if they so desire; for example, in order to avoid well known anomalies (discussed in the of this article). Chamberlin also argued that besides providing some missing-value functionality, practical experience with Nulls also led to other language features which rely on Nulls, like certain grouping constructs and outer joins. Finally, he argued that in practice Nulls also end up being used as a quick way to patch an existing schema when it needs to evolve beyond its original intent, coding not for missing but rather for inapplicable information; for example, a database that quickly needs to support electric cars while having a miles-per-gallon column.Codd indicated in his 1990 book The Relational Model for Database Management, Version 2 that the single Null mandated by the SQL standard was inadequate, and should be replaced by two separate Null-type markers to indicate the reason why data is missing. In Codd's book, these two Null-type markers are referred to as 'A-Values' and 'I-Values', representing 'Missing But Applicable' and 'Missing But Inapplicable', respectively. Codd's recommendation would have required SQL's logic system be expanded to accommodate a four-valued logic system.

Because of this additional complexity, the idea of multiple Nulls with different definitions has not gained widespread acceptance in the database practitioners' domain. It remains an active field of research though, with numerous papers still being published.Challenges Null has been the focus of controversy and a source of debate because of its associated (3VL), special requirements for its use in, and the special handling required by aggregate functions and SQL grouping operators.

Computer science professor Ron van der Meyden summarized the various issues as: 'The inconsistencies in the SQL standard mean that it is not possible to ascribe any intuitive logical semantics to the treatment of nulls in SQL.' Although various proposals have been made for resolving these issues, the complexity of the alternatives has prevented their widespread adoption.Null propagation Arithmetic operations Because Null is not a data value, but a marker for an absent value, using mathematical operators on Null gives an unknown result, which is represented by Null. In the following example, multiplying 10 by Null results in Null. SELECT.

FROM t WHERE i = NULL;The example query above logically always returns zero rows because the comparison of the i column with Null always returns Unknown, even for those rows where i is Null. The Unknown result causes the SELECT statement to summarily discard each and every row. (However, in practice, some SQL tools will retrieve rows using a comparison with Null.)Null-specific and 3VL-specific comparison predicates Basic SQL comparison operators always return Unknown when comparing anything with Null, so the SQL standard provides for two special Null-specific comparison predicates. The IS NULL and IS NOT NULL predicates (which use a syntax) test whether data is, or is not, Null.The SQL standard contains the optional feature F571 'Truth value tests' that introduces three additional logical unary operators (six in fact, if we count their negation, which is part of their syntax), also using postfix notation. They have the following truth tables: pp IS TRUEp IS NOT TRUEp IS FALSEp IS NOT FALSEp IS UNKNOWNp IS NOT UNKNOWNTrueTrueFalseFalseTrueFalseTrueFalseFalseTrueTrueFalseFalseTrueUnknownFalseTrueFalseTrueTrueFalseThe F571 feature is orthogonal to the presence of the boolean datatype in SQL (discussed later in this article) and, despite syntactic similarities, F571 does not introduce boolean or three-valued in the language. The F571 feature was actually present in, well before the boolean datatype was introduced to the standard in 1999.

SELECT 'ok' WHERE 1 NOT IN ( SELECT CAST ( NULL AS INTEGER )) UNION SELECT 'ok' WHERE 1 IN ( SELECT CAST ( NULL AS INTEGER ));produces no rows because IN translates to an iterated version of equality over the argument set and 1NULL is Unknown, just as a 1=NULL is Unknown. (The CAST in this example is needed only in some SQL implementations like PostgreSQL, which would reject it with a type checking error otherwise.

In many systems plain SELECT NULL works in the subquery.) The missing case above is of course. ( A = B ) OR ( A IS NULL AND B IS NULL ) CASE expressions SQL provides. One is called 'simple CASE' and operates like a. The other is called a 'searched CASE' in the standard, and operates like an.The simple CASE expressions use implicit equality comparisons which operate under the same rules as the DML WHERE clause rules for Null. Thus, a simple CASE expression cannot check for the existence of Null directly.

A check for Null in a simple CASE expression always results in Unknown, as in the following. SELECT CASE i WHEN NULL THEN 'Is Null' - This will never be returned WHEN 0 THEN 'Is Zero' - This will be returned when i = 0 WHEN 1 THEN 'Is One' - This will be returned when i = 1 END FROM t;Because the expression i = NULL evaluates to Unknown no matter what value column i contains (even if it contains Null), the string 'Is Null' will never be returned.On the other hand, a 'searched' CASE expression can use predicates like IS NULL and IS NOT NULL in its conditions. The following example shows how to use a searched CASE expression to properly check for Null.

SELECT DECODE ( i, NULL, 'Null Result', 0, 'Zero', 1, 'One' ) FROM t;Finally, all these constructs return a NULL if no match is found; they have a default ELSE NULL clause.IF statements in procedural extensions (SQL Persistent Stored Modules) defines extensions for SQL, such as the statement. However, the major SQL vendors have historically included their own proprietary procedural extensions. Procedural extensions for looping and comparisons operate under Null comparison rules similar to those for DML statements and queries.

The following code fragment, in ISO SQL standard format, demonstrates the use of Null 3VL in an IF statement. IF i = NULL THEN SELECT 'Result is True' ELSEIF NOT ( i = NULL ) THEN SELECT 'Result is False' ELSE SELECT 'Result is Unknown';The IF statement performs actions only for those comparisons that evaluate to True. For statements that evaluate to False or Unknown, the IF statement passes control to the clause, and finally to the clause. The result of the code above will always be the message 'Result is Unknown' since the comparisons with Null always evaluate to Unknown.Analysis of SQL Null missing-value semantics The groundbreaking work of and (1984) provided a framework in which to evaluate the intended semantics of various proposals to implement missing-value semantics, that is referred to as.

This section roughly follows chapter 19 of the 'Alice' textbook. A similar presentation appears in the review of Ron van der Meyden, §10.4. In selections and projections: weak representation Constructs representing missing information, such as Codd tables, are actually intended to represent a set of relations, one for each possible instantiation of their parameters; in the case of Codd tables, this means replacement of Nulls with some concrete value.

SELECT Name FROM Emp WHERE Age = 22 UNION SELECT Name FROM Emp WHERE Age 22;Whatever concrete value one would choose for the NULL age of Harriet, the above query will return the full column of names of any model of Emp, but when the (lifted) query is run on Emp itself, Harriet will always be missing, i.e. We have:Query result on Emp:NameGeorgeCharlesQuery result on any model of Emp:NameGeorgeHarrietCharlesThus when unions are added to the query language, Codd tables are not even a weak representation system of missing information, meaning that queries over them don't even report all sure information. It's important to note here that semantics of UNION on Nulls, which are discussed in a later section, did not even come into play in this query. The 'forgetful' nature of the two sub-queries was all that it took to guarantee that some sure information went unreported when the above query was run on the Codd table Emp.For, the example needed to show that sure information may be unreported by some query is slightly more complicated. Consider the tableJ F1F2F311NULL1321NULL23313233and the query. SELECT F1, F3 FROM ( SELECT F1, F2 FROM J ) AS F12 NATURAL JOIN ( SELECT F2, F3 FROM J ) AS F23; Query result on J:F1F33133Query result on any model of J:F1F133The intuition for what happens above is that the Codd tables representing the projections in the subqueries lose track of the fact that the Nulls in the columns F12.F2 and F23.F2 are actually copies of the originals in the table J. This observation suggests that a relatively simple improvement of Codd tables (which works correctly for this example) would be to use Skolem constants (meaning which are also ), say ω 12 and ω 22 instead of a single NULL symbol.

Such an approach, called v-tables or Naive tables, is computationally less expensive that the c-tables discussed above. However it is still not a complete solution for incomplete information in the sense that v-tables are only a weak representation for queries not using any negations in selection (and not using any set difference either).

The first example considered in this section is using a negative selection clause, WHERE Age 22, so it is also an example where v-tables queries would not report sure information.Check constraints and foreign keys The primary place in which SQL three-valued logic intersects with SQL (DDL) is in the form of. A check constraint placed on a column operates under a slightly different set of rules than those for the DML WHERE clause. While a DML WHERE clause must evaluate to True for a row, a check constraint must not evaluate to False. (From a logic perspective, the are True and Unknown.) This means that a check constraint will succeed if the result of the check is either True or Unknown. The following example table with a check constraint will prohibit any integer values from being inserted into column i, but will allow Null to be inserted since the result of the check will always evaluate to Unknown for Nulls.

CREATE TABLE t ( i INTEGER, CONSTRAINT cki CHECK ( i 0 ) );Because of the change in designated values relative to the WHERE clause, from a logic perspective the law of excluded middle is a tautology for CHECK constraints, meaning CHECK ( p OR NOT p) always succeeds. Furthermore, assuming Nulls are to be interpreted as existing but unknown values, some pathological CHECKs like the one above allow insertion of Nulls that could never be replaced by any non-null value.In order to constrain a column to reject Nulls, the NOT NULL constraint can be applied, as shown in the example below.

The NOT NULL constraint is semantically equivalent to a with an IS NOT NULL predicate. CREATE TABLE Books ( title VARCHAR ( 100 ), authorlast VARCHAR ( 20 ), authorfirst VARCHAR ( 20 ), FOREIGN KEY ( authorlast, authorfirst ) REFERENCES Authors ( lastname, firstname ));would allow insertion of rows where authorlast or authorfirst are NULL irrespective of how the table Authors is defined or what it contains. More precisely, a null in any of these fields would allow any value in the other one, even on that is not found in Authors table. For example, if Authors contained only ('Doe', 'John'), then ('Smith', NULL) would satisfy the foreign key constraint. Added two extra options for narrowing down the matches in such cases. If MATCH PARTIAL is added after the REFERENCES declaration then any non-null must match the foreign key, e. ('Doe', NULL) would still match, but ('Smith', NULL) would not.

Finally, if MATCH FULL is added then ('Smith', NULL) would not match the constraint either, but (NULL, NULL) would still match it.Outer joins. Example query with Null placeholders in the result set. The Null markers are represented by the word NULL in place of data in the results. Results are from, as shown in SQL Server Management Studio.SQL, including left outer joins, right outer joins, and full outer joins, automatically produce Nulls as placeholders for missing values in related tables. For left outer joins, for instance, Nulls are produced in place of rows missing from the table appearing on the right-hand side of the LEFT OUTER JOIN operator. The following simple example uses two tables to demonstrate Null placeholder production in a left outer join.The first table ( Employee) contains employee ID numbers and names, while the second table ( PhoneNumber) contains related employee ID numbers and, as shown below.EmployeeIDLastNameFirstName1JohnsonJoe2LewisLarry3ThompsonThomas4PattersonPatriciaPhoneNumberIDNumber155-9876The following sample SQL query performs a left outer join on these two tables.

FirstName, pn. Number FROM Employee e LEFT OUTER JOIN PhoneNumber pn ON e. ID;The result set generated by this query demonstrates how SQL uses Null as a placeholder for values missing from the right-hand ( PhoneNumber) table, as shown below.Query resultIDLastNameFirstNameNumber1JohnsonJoe555-23232LewisLarryNULL3ThompsonThomas555-98764PattersonPatriciaNULLAggregate functions SQL defines to simplify server-side aggregate calculations on data. Except for the COUNT(.) function, all aggregate functions perform a Null-elimination step, so that Nulls are not included in the final result of the calculation.Note that the elimination of Null is not equivalent to replacing Null with zero.

For example, in the following table, AVG(i) (the average of the values of i) will give a different result from that of AVG(j):ij00250250NULL0Here AVG(i) is 200 (the average of 150, 200, and 250), while AVG(j) is 150 (the average of 150, 200, 250, and 0). A well-known side effect of this is that in SQL AVG(z) is not equivalent with SUM(z)/COUNT(.).The output of an aggregate function can also be Null. Here is an example. SELECT COUNT (.

), MIN ( e. Wage ), MAX ( e.

Wage ) FROM Employee e WHERE e. LastName LIKE '%Jones%';This query will always output exactly one row, counting of the number of employees whose last name contains 'Jones', and giving the minimum and maximum wage found for those employees.

However, what happens if none of the employees fit the given criteria? Calculating the minimum or maximum value of an empty set is impossible, so those results must be NULL, indicating there is no answer. This is not an Unknown value, it is a Null representing the absence of a value. The result would be:COUNT(.)MIN(e.Wage)MAX(e.Wage)0NULLNULLWhen two nulls are equal: grouping, sorting, and some set operations Because defines all Null markers as being unequal to one another, a special definition was required in order to group Nulls together when performing certain operations. SQL defines 'any two values that are equal to one another, or any two Nulls', as 'not distinct'. This definition of not distinct allows SQL to group and sort Nulls when the GROUP BY clause (and other keywords that perform grouping) are used.Other SQL operations, clauses, and keywords use 'not distinct' in their treatment of Nulls.

These include the following:. PARTITION BY clause of ranking and windowing functions like ROWNUMBER.

UNION, INTERSECT, and EXCEPT operator, which treat NULLs as the same for row comparison/elimination purposes. DISTINCT keyword used in SELECT queriesThe principle that Nulls aren't equal to each other (but rather that the result is Unknown) is effectively violated in the SQL specification for the UNION operator, which does identify nulls with each other.

Consequently, some set operations in SQL, like union or difference, may produce results not representing sure information, unlike operations involving explicit comparisons with NULL (e.g. Those in a WHERE clause discussed above). In Codd's 1979 proposal (which was basically adopted by SQL92) this semantic inconsistency is rationalized by arguing that removal of duplicates in set operations happens 'at a lower level of detail than equality testing in the evaluation of retrieval operations.' The SQL standard does not explicitly define a default sort order for Nulls. Instead, on conforming systems, Nulls can be sorted before or after all data values by using the NULLS FIRST or NULLS LAST clauses of the ORDER BY list, respectively.

Not all DBMS vendors implement this functionality, however. Vendors who do not implement this functionality may specify different treatments for Null sorting in the DBMS.

Effect on index operation Some SQL products do not index keys containing NULLs. For instance, versions prior to 8.3 did not, with the documentation for a index stating thatB-trees can handle equality and range queries on data that can be sorted into some ordering. In particular, the PostgreSQL query planner will consider using a B-tree index whenever an indexed column is involved in a comparison using one of these operators: Constructs equivalent to combinations of these operators, such as BETWEEN and IN, can also be implemented with a B-tree index search. (But note that IS NULL is not equivalent to = and is not indexable.)In cases where the index enforces uniqueness, NULLs are excluded from the index and uniqueness is not enforced between NULLs. Again, quoting from the documentation:When an index is declared unique, multiple table rows with equal indexed values will not be allowed. Nulls are not considered equal. A multicolumn unique index will only reject cases where all of the indexed columns are equal in two rows.This is consistent with the -defined behavior of scalar Null comparisons.Another method of indexing Nulls involves handling them as not distinct in accordance with the SQL:2003-defined behavior.

For example, documentation states the following:For indexing purposes, NULLs compare as equal. Therefore, a unique index, or UNIQUE constraint, cannot be created if the keys are NULL in more than one row.

Select columns that are defined as NOT NULL when columns for a unique index or unique constraint are chosen.Both of these indexing strategies are consistent with the SQL:2003-defined behavior of Nulls. Because indexing methodologies are not explicitly defined by the SQL:2003 standard, indexing strategies for Nulls are left entirely to the vendors to design and implement.Null-handling functions SQL defines two functions to explicitly handle Nulls: NULLIF and COALESCE. Both functions are abbreviations for. NULLIF The NULLIF function accepts two parameters.

If the first parameter is equal to the second parameter, NULLIF returns Null. Otherwise, the value of the first parameter is returned.

See also: andThe NULL is untyped in SQL, meaning that it is not designated as an integer, character, or any other specific. Because of this, it is sometimes mandatory (or desirable) to explicitly convert Nulls to a specific data type.

For instance, if functions are supported by the RDBMS, SQL might not be able to automatically resolve to the correct function without knowing the data types of all parameters, including those for which Null is passed.Conversion from the NULL literal to a Null of a specific type is possible using the CAST introduced in. SELECT 'ok' WHERE ( NULL 1 ) IS NULL;parses and executes successfully in some environments (e.g. Or ) which unify a NULL boolean with Unknown but fails to parse in others (e.g. Behaves similarly to in this regard (with the minor exception that regards TRUE and FALSE as no different from the ordinary integers 1 and 0). PostgreSQL additionally implements a IS UNKNOWN predicate, which can be used to test whether a three-value logical outcome is Unknown, although this is merely syntactic sugar.BOOLEAN data type The ISO standard introduced the BOOLEAN data type to SQL, however it's still just an optional, non-core feature, coded T031.When restricted by a NOT NULL constraint, the SQL BOOLEAN works like the from other languages. Unrestricted however, the BOOLEAN datatype, despite its name, can hold the truth values TRUE, FALSE, and UNKNOWN, all of which are defined as boolean literals according to the standard. The standard also asserts that NULL and UNKNOWN 'may be usedinterchangeably to mean exactly the same thing'.The Boolean type has been subject of criticism, particularly because of the mandated behavior of the UNKNOWN literal, which is never equal to itself because of the identification with NULL.As discussed above, in the implementation of, Null is used to represent all UNKNOWN results, including the UNKNOWN BOOLEAN.

PostgreSQL does not implement the UNKNOWN literal (although it does implement the IS UNKNOWN operator, which is an orthogonal feature.) Most other major vendors do not support the Boolean type (as defined in T031) as of 2012. The procedural part of Oracle's supports BOOLEAN however variables; these can also be assigned NULL and the value is considered the same as UNKNOWN. Controversy Common mistakes Misunderstanding of how Null works is the cause of a great number of errors in SQL code, both in ISO standard SQL statements and in the specific SQL dialects supported by real-world database management systems. These mistakes are usually the result of confusion between Null and either 0 (zero) or an empty string (a string value with a length of zero, represented in SQL as '). Null is defined by the SQL standard as different from both an empty string and the numerical value 0, however. While Null indicates the absence of any value, the empty string and numerical zero both represent actual values.A classic error is the attempt to use the equals operator = in combination with the keyword NULL to find rows with Nulls.

According to the SQL standard this is an invalid syntax and shall lead to an error message or an exception. But most implementations accept the syntax and evaluate such expressions to UNKNOWN. The consequence is that no rows are found - regardless of whether rows with Nulls exist or not.

The proposed way to retrieve rows with Nulls is the use of the predicate IS NULL instead of = NULL. SELECT. FROM sometable WHERE num 1; - Rows where num is NULL will not be returned, - contrary to many users' expectations.These confusions arise because the is restricted in SQL's logic.

When dealing with equality comparisons using the NULL literal or the UNKNOWN truth-value, SQL will always return UNKNOWN as the result of the expression. This is a and makes SQL an example of a Non-Reflexive logic.Similarly, Nulls are often confused with empty strings. Consider the LENGTH function, which returns the number of characters in a string. When a Null is passed into this function, the function returns Null. This can lead to unexpected results, if users are not well versed in 3-value logic.

An example is below. SELECT. FROM sometable WHERE LENGTH ( string ). ^ Ron van der Meyden, ' in Chomicki, Jan; Saake, Gunter (Eds.) Logics for Databases and Information Systems, Kluwer Academic Publishers, p. 344; (note: page numbering differs in preprint from the published version). Codd, E.F. (October 14, 1985).

'Is Your Database Really Relational?' . Codd, E.F. (October 21, 1985).

'Does Your DBMS Run By The Rules?' . ^ Don Chamberlin (1998). Morgan Kaufmann.

Pp. 28–32. ^ Codd, E.F. The Relational Model for Database Management (Version 2 ed.). ^ ISO/IEC (2003). ISO/IEC 9075-2:2003, 'SQL/Foundation'. Section 6.2.6: numeric value expressions.

ISO/IEC (2003). ISO/IEC 9075-2:2003, 'SQL/Foundation'. Section 6.2.8: string value expression. ISO/IEC (2003). Section 4.4.2: The null value. ^ Coles, Michael (June 27, 2005). SQL Server Central.

Red Gate Software. ^ Hans-Joachim, K.

Findattribute Called With A Null Value Calculator

Semantics in Databases. Second International Workshop Dagstuhl Castle, Germany, January 7–12, 2001. Revised Papers. Lecture Notes in Computer Science. Pp. 119–138. ISO/IEC (2003).

ISO/IEC 9075-2:2003, 'SQL/Foundation'. Section 8.7: null predicate. C.J.

Date (2004), An introduction to database systems, 8th ed., Pearson Education, p. 594. Jim Melton; Jim Melton Alan R. Simon (1993).

Morgan Kaufmann. Pp. 145–147. C. Date, Relational database writings, 1991-1994, Addison-Wesley, 1995, p. Date (2004), An introduction to database systems, 8th ed., Pearson Education, p. 584.; Lipski Jr., W. 'Incomplete information in relational databases'.

31 (4): 761–791.;; (1995). Addison-Wesley. ^ Coles, Michael (February 26, 2007). SQL Server Central. Red Gate Software. ISO/IEC (2003).

ISO/IEC 9075-2:2003, 'SQL/Foundation'. Section 4.15.4: Aggregate functions. ISO/IEC (2003).

ISO/IEC 9075-2:2003, 'SQL/Foundation'. Section 3.1.6.8: Definitions: distinct. Retrieved 6 November 2008. Retrieved November 6, 2008. September 2007. Retrieved November 6, 2008.

ISO/IEC (2003). ISO/IEC 9075-2:2003, 'SQL/Foundation'. Section 6.11: case expression.; Alan R. Simon (2002).

SQL:1999: Understanding Relational Language Components. Morgan Kaufmann. P. 53. 'ISO/IEC 9075-1:1999 SQL Standard'.

Missing or empty url=. C. Date (2011). O'Reilly Media, Inc. P. 83. ISO/IEC 9075-2:2011 §4.5. Martyn Prigmore (2007).

Pearson Education Canada. P. 197. Troels Arvin,. Steven Feuerstein; Bill Pribyl (2009).

Oracle PL/SQL Programming. O'Reilly Media, Inc. Pp. 74, 91. Arenhart, Krause (2012), 'Classical Logic or Non-Reflexive Logic?

A case of Semantic Underdetermination', Revista Portuguesa de Filosofia, 68 (1/2): 73–86,:,. Darwen, Hugh; Chris Date. Retrieved May 29, 2007. Darwen, Hugh. Retrieved May 29, 2007. Date, Chris (May 2005). Database in Depth: Relational Theory for Practitioners.

O'Reilly Media, Inc. P. 73. Date, Chris. Data Management Association, San Francisco Bay Area Chapter. Archived from on 2007-05-19. Retrieved May 29, 2007.Further reading. E.

Understanding relations (installment #7). FDT Bulletin of ACM-SIGMOD, 7(3-4):23–28, 1975. Codd, E. 'Extending the database relational model to capture more meaning'. ACM Transactions on Database Systems. 4 (4): 397–434. Especially §2.3.

(2000). The Database Relational Model: A Retrospective Review and Analysis: A Historical Account and Assessment of E. Codd's Contribution to the Field of Database Technology. Klein, Hans-Joachim (1994). ACM SIGMOD Record. 23 (3): 14–20. Claude Rubinson, SIGMOD Record, December 2007 (Vol.

4). John Grant,. SIGMOD Record, September 2008 (Vol. 3). Waraporn, Narongrit, and Kriengkrai Porkaew. International Journal of Computer Science 35.3 (2008): 305-313. Bernhard Thalheim, Klaus-Dieter Schewe (2011).

Frontiers in Artificial Intelligence and Applications. 225 (Information Modelling and Knowledge Bases XXII). CS1 maint: Uses authors parameter. Enrico Franconi and Sergio Tessaris, Proceedings of the 6th Alberto Mendelzon International Workshop on Foundations of Data Management, Ouro Preto, Brazil, June 27–30, 2012. Pp. 114–128External links.