In Oracle, when querying for row existence, exactly why is Choose 1 fast than Choose count(*)?

It is best still to make use of Is available in which the RDBMS supports it or perhaps an equivalent, because this stop processing rows the moment it finds a match.

Since Oracle does not support IF Is available in PL/SQL, CodeByMidnight's suggestion to make use of Is available would normally be achieved with something similar to

SELECT 1 
  INTO l_local_variable 
  FROM dual 
 WHERE EXISTS( 
    SELECT 1 
      FROM some_table 
     WHERE some_column = some_condition );

Oracle knows that it may stop processing the WHERE Is available clause the moment one row is located, therefore it does not need to potentially count a lot of rows that match the factors. This really is a lesser concern, obviously, if you're checking to determine whether a row having a particular key is available than if you're checking an ailment including unindexed posts or checking a disorder that might lead to a lot of rows being came back.

(Note: If only I possibly could publish this like a discuss CodeByMidnight's publish, but comments can't include formatted code).

UPDATE: Because of the clarification the initial poster produced in their comment, rapid, definitive response is that the SELECT 1 or SELECT COUNT(1) isn't any faster than the usual SELECT COUNT(*). Unlike whatever coding recommendations you're searching at, COUNT(*) may be the preferred method of counting all of the rows. There is a classic myth that the COUNT(1) was faster. At least, that has not been true in almost any version of Oracle launched previously decade which is unlikely it was ever true. It had been a broadly held belief, however. Today, code that does a COUNT(1) as opposed to a COUNT(*) generally makes me suspect the author is vulnerable to believe various Oracle misconceptions and that's why I recommend using COUNT(*).

I'd be suprised if choose count(*) wasn't correctly optimized, there's you don't need to load in most the posts as there won't be any column related processing.

Just because a star takes all cols in to the count, "1" is really a native datatype.

In MySQL "Choose COUNT(title_of_the_primary_key)" ought to be as quickly as your Choose 1. It is the index that counts. A count() with an index ought to be quite fast )

Other things being equal, "select 1 from my_table" will return the first result faster than "select count(*) from my_table", but when you retrieve all of the is a result of the query, the count(*) you will be faster since it involves a smaller amount data (1 integer, instead of 1 integer per each row within the table).

I do not think this is correct for Oracle. http://justoracle.blogspot.com/2006/12/count-vs-count1.html

But, in certain databases this is because because '*' needs to go to the tables meta-data. This would add an not-needed overhead. While 1 is simply a literal.