Misplaced Pages

#759240

83-544: ODBC accomplishes DBMS independence by using an ODBC driver as a translation layer between the application and the DBMS. The application uses ODBC functions through an ODBC driver manager with which it is linked, and the driver passes the query to the DBMS. An ODBC driver can be thought of as analogous to a printer driver or other driver, providing a standard set of functions for the application to use, and implementing DBMS-specific functionality. An application that can use ODBC

166-445: A Microsoft Works database file in the dBase file format so that it can be read by Microsoft Excel . A package is available for Emacs to read xbase files. LibreOffice and OpenOffice Calc can read and write all generic dbf files. dBase's database system was one of the first to provide a header section for describing the structure of the data in the file. This meant that the program no longer required advance knowledge of

249-502: A printer driver presents a standard set of printing commands, the API, to applications using the printing system. Calls made to those APIs are converted by the driver into the format used by the actual hardware, say PostScript or PCL . In the case of ODBC, the drivers encapsulate many functions that can be broken down into several broad categories. One set of functions is primarily concerned with finding, connecting to and disconnecting from

332-481: A 10-percent raise, and then prints the names and salaries. Note how one does not have to keep mentioning the table name. The assumed ("current") table stays the same until told otherwise. Because of its origins as an interpreted interactive language, dBase used a variety of contextual techniques to reduce the amount of typing needed. This facilitated incremental, interactive development but also made larger-scale modular programming difficult. A tenet of modular programming

415-433: A JDBC driver. Examples: OpenLink ODBC-JDBC Bridge , SequeLink ODBC-JDBC Bridge . A JDBC-ODBC bridge consists of a JDBC driver which employs an ODBC driver to connect to a target database. This driver translates JDBC method calls into ODBC function calls. Programmers usually use such a bridge when a given database lacks a JDBC driver, but is accessible through an ODBC driver. Sun Microsystems included one such bridge in

498-470: A SQL statement like SELECT * FROM city could be inserted as text within C source code, and during compiling it would be converted into a custom format that directly called a function within a library that would pass the statement into the SQL system. Results returned from the statements would be interpreted back into C data formats like char * using similar library code. There were several problems with

581-550: A data access standard was a requirement – in the mainframe field it was highly likely that all of the computers in a shop were from one vendor and clients were computer terminals talking directly to them, but in the micro field there was no such standardization and any client might access any server using any networking system. By the late 1980s there were several efforts underway to provide an abstraction layer for this purpose. Some of these were mainframe related, designed to allow programs running on those machines to translate between

664-411: A magazine devoted to the professional use of dBase, Data Based Advisor ; its circulation exceeded 35,000 after eight months. All of these activities fueled the rapid rise of dBase as the leading product of its type. As platforms and operating systems proliferated in the early 1980s, the company found it difficult to port the assembly language -based dBase to target systems. This led to a rewrite of

747-419: A major focus for SQL vendors during the 1980s. Older mainframe databases, and the newer microcomputer based systems that were based on them, generally did not have a SQL-like command processor between the user and the database engine. Instead, the data was accessed directly by the program – a programming library in the case of large mainframe systems, or a command line interface or interactive forms system in

830-876: A memo field is a 10-byte pointer into a .dbt file which can include a much larger text field. dBase was very limited in its ability to process memo fields, but some other xBase languages such as Clipper treated memo fields as strings just like character fields for all purposes except permanent storage. dBase uses .ndx files for single indexes, and .mdx (multiple-index) files for holding between 1 and 48 indexes. Some xBase languages such as VP-Info include compatibility with .ndx files while others use different file formats such as .ntx used by Clipper and .idx/.cdx used by FoxPro or FlagShip. Later iterations of Clipper included drivers for .ndx, .mdx, .idx and .cdx indexes. BYTE ' s Jerry Pournelle in July 1980 called Vulcan "infuriatingly excellent" because

913-515: A new member of the xBase family was born: the XSharp (X#) language, maintained as an open source project with a compiler, its own IDE, and Microsoft Visual Studio integration. XSharp produces .NET assemblies and uses the familiar xBase language. The XSharp product was originally created by a group of four enthusiasts who have worked for the Vulcan.NET project in the past. The compiler is created on top of

SECTION 10

#1732772192760

996-413: A planned dBase Advisor Magazine was aborted due to the market failure of dBase IV. By the year 2000, the xBase market had faded as developers shifted to new database systems and programming languages. Computer Associates (later known as CA) eventually dropped Clipper. Borland restructured and sold dBase. Of the major acquirers, Microsoft stuck with xBase the longest, evolving FoxPro into Visual FoxPro, but

1079-487: A port of dBase for the then-in-development PC. The resultant program was one of the initial pieces of software available when the IBM PC went on sale in the fall of 1981. dBase was one of a few "professional" programs on the platform then, and became a huge success. The customer base included not only end-users, but an increasing number of "value added resellers", or VARs, who purchased dBase, wrote applications with it, and sold

1162-575: A programmer at JPL, to write an enhanced version of RETRIEVE, which became the JPLDIS project. JPLDIS was written in FORTRAN on the UNIVAC 1108 mainframe, and was presented publicly in 1973. When Hatfield left JPL in 1974, Jeb Long took over his role. While working at JPL as a contractor, C. Wayne Ratliff entered the office football pool . He had no interest in the game as such, but felt he could win

1245-511: A programming interface to control and manage specific lower-level interfaces that are often linked to a specific type of hardware, or other low-level service. In the case of hardware, the specific subclass of drivers controlling physical or virtual hardware devices are known as device drivers. A client library for connecting to a database is often known as a driver, for example, the MySQL native driver for PHP . This article related to

1328-536: A selection of driver dynamic-link libraries (DLL) that allowed the same C interface to redirect input and output to other ISAM-based databases, like Paradox and xBase . Jet allowed using one set of calls to access common microcomputer databases in a fashion similar to Blueprint, by then renamed DataLens. However, Jet did not use SQL; like DataLens, the interface was in C and consisted of data structures and function calls. The SAG standardization efforts presented an opportunity for Microsoft to adapt their Jet system to

1411-587: A single library could be used with (potentially) any programming language on a given platform. The first draft of the Microsoft Data Access API was published in April 1989, about the same time as Lotus' announcement of Blueprint. In spite of Blueprint's great lead – it was running when MSDA was still a paper project – Lotus eventually joined the MSDA efforts as it became clear that SQL would become

1494-521: A standardized dynamic SQL concept. Much of the system was based on Sybase's DB-Library system, with the Sybase-specific sections removed and several additions to support other platforms. DB-Library was aided by an industry-wide move from library systems that were tightly linked to a specific language, to library systems that were provided by the operating system and required the languages on that platform to conform to its standards. This meant that

1577-448: A table statement which made referencing a table field unambiguous and simple. For example. one can open a table and assign an alias to it in this fashion, "use EMP alias Employee", and henceforth, refer to table variables as "Employee->Name". Another notable feature is the re-use of the same clauses for different commands. For example, the FOR clause limits the scope of a given command. (It

1660-448: A type of software is a stub . You can help Misplaced Pages by expanding it . DBASE dBase (also stylized dBASE ) was one of the first database management systems for microcomputers and the most successful in its day. The dBase system included the core database engine , a query system, a forms engine , and a programming language that tied all of these components together. Originally released as Vulcan for PTDOS in 1978,

1743-465: Is an example of a feature that made dBase programming flexible and dynamic, sometimes called "meta ability" in the profession. This could allow programming expressions to be placed inside tables, somewhat reminiscent of formulas in spreadsheet software. However, it could also be problematic for pre-compiling and for making programming code secure from hacking. But, dBase tended to be used for custom internal applications for small and medium companies where

SECTION 20

#1732772192760

1826-476: Is included in the driver and the DSNs. A bridge is a special kind of driver: a driver that uses another driver-based technology. An ODBC-JDBC bridge consists of an ODBC driver which uses the services of a JDBC driver to connect to a database. This driver translates ODBC function-calls into JDBC method-calls. Programmers usually use such a bridge when they lack an ODBC driver for some database but have access to

1909-419: Is not uncommon to find ODBC drivers for database engines that are meant to be embedded, like SQLite , as a way to allow existing tools to act as front-ends to these engines for testing and debugging. ODBC is based on the device driver model, where the driver encapsulates the logic needed to convert a standard set of commands and functions into the specific calls required by the underlying system. For instance,

1992-410: Is referred to as "ODBC-compliant". Any ODBC-compliant application can access any DBMS for which a driver is installed. Drivers exist for all major DBMSs, many other data sources like address book systems and Microsoft Excel , and even for text or comma-separated values (CSV) files. ODBC was originally developed by Microsoft and Simba Technologies during the early 1990s, and became the basis for

2075-451: Is somewhat comparable to SQL's WHERE clause.) Different commands such as LIST, DELETE, REPLACE, BROWSE, etc. could all accept a FOR clause to limit (filter) the scope of their activity. This simplifies the learning of the language. dBase was also one of the first business-oriented languages to implement string evaluation . Here the "&" tells the interpreter to evaluate the string stored in "myMacro" as if it were programming code. This

2158-454: Is that the correct execution of a program module must not be affected by external factors such as the state of memory variables or tables being manipulated in other program modules. Because dBase was not designed with this in mind, developers had to be careful about porting (borrowing) programming code that assumed a certain context and it would make writing larger-scale modular code difficult. Work-area-specific references were still possible using

2241-521: The CP/M port caught the attention of Ashton-Tate in 1980. They licensed it, re-released it as dBASE II , and later ported it to IBM PC computers running DOS . On the PC platform in particular, dBase became one of the best-selling software titles for a number of years. A major upgrade was released as dBase III and ported to a wider variety of platforms, including UNIX and VMS . By the mid-1980s, Ashton-Tate

2324-606: The Call Level Interface (CLI) standardized by SQL Access Group in the Unix and mainframe field. ODBC retained several features that were removed as part of the CLI effort. Full ODBC was later ported back to those platforms, and became a de facto standard considerably better known than CLI. The CLI remains similar to ODBC, and applications can be ported from one platform to the other with few changes. The introduction of

2407-783: The JVM , but viewed it as a stop-gap measure while few JDBC drivers existed (The built-in JDBC-ODBC bridge was dropped from the JVM in Java 8). Sun never intended its bridge for production environments, and generally recommended against its use. As of 2008 independent data-access vendors deliver JDBC-ODBC bridges which support current standards for both mechanisms, and which far outperform the JVM built-in. Examples: OpenLink JDBC-ODBC Bridge , SequeLink JDBC-ODBC Bridge , ZappySys JDBC-ODBC Bridge . An OLE DB-ODBC bridge consists of an OLE DB Provider which uses

2490-572: The Roslyn compiler code, the code behind the C# and VB compilers from Microsoft. Today, implementations of the dBase language have expanded to include many features targeted for business applications, including object-oriented programming, manipulation of remote and distributed data via SQL, Internet functionality, and interaction with modern devices. The following example opens an employee table ("empl"), gives every manager who supervises 1 or more employees

2573-550: The Soviet Union . Its adaptation to the Russian language was reduced to the mechanical replacement of the name, the russification of the help files and the correction of the sorting tables for the Russian language. Introduced in 1988, after delays, dBase IV had "more than 300 new or improved features". By then, FoxPro had made inroads, and even dBase IV's support for Query by Example and SQL were not enough. Along

Open Database Connectivity - Misplaced Pages Continue

2656-514: The mainframe -based relational database during the 1970s led to a proliferation of data access methods. Generally these systems operated together with a simple command processor that allowed users to type in English-like commands, and receive output. The best-known examples are SQL from IBM and QUEL from the Ingres project. These systems may or may not allow other applications to access

2739-489: The ANSI/ISO standard language for creating, modifying, and retrieving data stored in relational database management systems. Eventually, it became clear that the dBase world had expanded far beyond Ashton-Tate. A "third-party" community formed, consisting of Fox Software, Nantucket, Alpha Software, Data Based Advisor Magazine, SBT and other application development firms, and major developer groups. Paperback Software launched

2822-618: The C language formats. An ODBC driver enables an ODBC-compliant application to use a data source , normally a DBMS. Some non-DBMS drivers exist, for such data sources as CSV files, by implementing a small DBMS inside the driver itself. ODBC drivers exist for most DBMSs, including Oracle , PostgreSQL , MySQL , Microsoft SQL Server (but not for the Compact aka CE edition ), Mimer SQL , Sybase ASE , SAP HANA and IBM Db2 . Because different technologies have different capabilities, most ODBC drivers do not implement all functionality defined in

2905-504: The DBMS that driver talks to. A second set is used to send SQL commands from the ODBC system to the DBMS, converting or interpreting any commands that are not supported internally. For instance, a DBMS that does not support cursors can emulate this functionality in the driver. Finally, another set of commands, mostly used internally, is used to convert data from the DBMS's internal formats to a set of standardized ODBC formats, which are based on

2988-559: The Driver Manager (DM) provides these features. The DM can enumerate the installed drivers and present this as a list, often in a GUI-based form. But more important to the operation of the ODBC system is the DM's concept of a Data Source Name (DSN). DSNs collect additional information needed to connect to a specific data source, versus the DBMS itself. For instance, the same MySQL driver can be used to connect to any MySQL server, but

3071-525: The Embedded SQL approach. Like the different varieties of SQL, the Embedded SQLs that used them varied widely, not only from platform to platform, but even across languages on one platform – a system that allowed calls into IBM Db2 would look very different from one that called into their own SQL/DS . Another key problem to the Embedded SQL concept was that the SQL code could only be changed in

3154-524: The Fox products). In December 1990, U.S. District judge Terry Hatter Jr. dismissed Ashton-Tate's lawsuit and invalidated Ashton-Tate's copyrights for not disclosing that dBase had been based, in part, on the public domain JPLDIS . In October 1991, while the case was still under appeal, Borland International acquired Ashton-Tate, and as one of the merger's provisions the U.S. Justice Department required Borland to end

3237-401: The ODBC standard. Some drivers offer extra functionality not defined by the standard. Device drivers are normally enumerated, set up and managed by a separate Manager layer, which may provide additional functionality. For instance, printing systems often include functionality to provide spooling functionality on top of the drivers, providing print spooling for any supported printer. In ODBC

3320-463: The SQL language itself, or attempt a wider standardization which included a dynamic SQL language-embedding system as well, what they called a Call Level Interface (CLI). While attending the meeting with an early draft of what was then still known as MS Data Access, Kyle Geiger of Microsoft invited Jeff Balboni and Larry Barnes of Digital Equipment Corporation (DEC) to join the SQLC meetings as well. SQLC

3403-628: The Unix field was increasingly embracing it. This was propelled by two changes within the market, the introduction of graphical user interfaces (GUIs) like GNOME that provided a need to access these sources in non-text form, and the emergence of open software database systems like PostgreSQL and MySQL , initially under Unix. The later adoption of ODBC by Apple for using the standard Unix-side iODBC package Mac OS X 10.2 (Jaguar) (which OpenLink Software had been independently providing for Mac OS X 10.0 and even Mac OS 9 since 2001) further cemented ODBC as

Open Database Connectivity - Misplaced Pages Continue

3486-480: The ability to save partially complete DSN's, with code and logic to ask the user for any missing information at runtime. For instance, a DSN can be created without a required password. When an ODBC application attempts to connect to the DBMS using this DSN, the system will pause and ask the user to provide the password before continuing. This frees the application developer from having to create this sort of code, as well as having to know which questions to ask. All of this

3569-413: The arrow notation ("B->customer") so that multiple tables could be manipulated at the same time. In addition, if the developer had the foresight to name their tables appropriately, they could clearly refer to a large number of tables open at the same time by notation such as ("employee->salary") and ("vacation->start_date"). Alternatively, the alias command could be appended to the initial opening of

3652-411: The case of dBASE and similar applications. Data from dBASE could not generally be accessed directly by other programs running on the machine. Those programs may be given a way to access this data, often through libraries, but it would not work with any other database engine, or even different databases in the same engine. In effect, all such systems were static, which presented considerable problems. By

3735-755: The completed systems to their customers. The May 1983 release of dBase II RunTime further entrenched dBase in the VAR market by allowing the VARs to deploy their products using the lower-cost RunTime system. Although some critics stated that dBase was difficult to learn, its success created many opportunities for third parties. By 1984, more than 1,000 companies offered dBase-related application development, libraries of code to add functionality, applications using dBase II Runtime, consulting, training, and how-to books. A company in San Diego (today known as Advisor Media) premiered

3818-455: The connection information to connect to a local private server is different from the information needed to connect to an internet-hosted public server. The DSN stores this information in a standardized format, and the DM provides this to the driver during connection requests. The DM also includes functionality to present a list of DSNs using human readable names, and to select them at run-time to connect to different resources. The DM also includes

3901-624: The criteria defined by Dr. Edgar F. Codd 's relational model . It used a runtime interpreter architecture, which allowed the user to execute commands by typing them in a command line "dot prompt". Similarly, program scripts (text files with PRG extensions) ran in the interpreter (with the DO command). Over time, Ashton-Tate's competitors introduced so-called clone products and compilers that had more robust programming features such as user-defined functions (UDFs), arrays for complex data handling. Ashton-Tate and its competitors also began to incorporate SQL ,

3984-509: The data directly, and those that did use a wide variety of methodologies. The introduction of SQL aimed to solve the problem of language standardization, although substantial differences in implementation remained. Since the SQL language had only rudimentary programming features, users often wanted to use SQL within a program written in another language, say Fortran or C . This led to the concept of Embedded SQL , which allowed SQL code to be embedded within another language. For instance,

4067-418: The data structure, but rather could ask the data file how it was structured. There are several variations on the .dbf file structure, and not all dBase-related products and .dbf file structures are compatible. VP-Info is unique in that it can read all variants of the dbf file structure. A second filetype is the .dbt file format for memo fields. While character fields are limited to 254 characters each,

4150-489: The de facto database standard. After considerable industry input, in the summer of 1989 the standard became SQL Connectivity ( SQLC ). In 1988 several vendors, mostly from the Unix and database communities, formed the SQL Access Group (SAG) in an effort to produce a single basic standard for the SQL language. At the first meeting there was considerable debate over whether or not the effort should work solely on

4233-638: The driver interfaces and provided direct links to their products. Skipping the intermediate conversions to and from Jet or similar wrappers often resulted in higher performance. However, by then Microsoft had changed focus to their OLE DB concept (recently reinstated ), which provided direct access to a wider variety of data sources from address books to text files. Several new systems followed which further turned their attention from ODBC, including ActiveX Data Objects (ADO) and ADO.net , which interacted more or less with ODBC over their lifetimes. As Microsoft turned its attention away from working directly on ODBC,

SECTION 50

#1732772192760

4316-404: The early examples of such a system was Lotus Development 's DataLens , initially known as Blueprint. Blueprint, developed for 1-2-3, supported a variety of data sources, including SQL/DS, DB2, FOCUS and a variety of similar mainframe systems, as well as microcomputer systems like dBase and the early Microsoft/Ashton-Tate efforts that would eventually develop into Microsoft SQL Server . Unlike

4399-541: The first independently developed third-party ODBC drivers, for the PROGRESS DBMS , and soon followed with their UDBC (a cross-platform API equivalent of ODBC and the SAG/CLI) SDK and associated drivers for PROGRESS , Sybase, Oracle, and other DBMS, for use on Unix-like OS ( AIX , HP-UX , Solaris , Linux , etc.), VMS , Windows NT , OS/2 , and other OS. Meanwhile, the CLI standard effort dragged on, and it

4482-648: The flexible and fast VP-Info with a unique built-in compiler. The community of dBase variants sought to create a dBase language standard, supported by IEEE committee X3J19 and initiative IEEE 1192. They said "xBase" to distinguish it from the Ashton-Tate product. Ashton-Tate saw the rise of xBase as an illegal threat to its proprietary technology. In 1988 they filed suit against Fox Software and Santa Cruz Operation (SCO) for copying dBase's "structure and sequence" in FoxBase+ (SCO marketed XENIX and UNIX versions of

4565-483: The gap when Microsoft initially deprecated this bridge for their 64-bit OS. (Microsoft later relented, and 64-bit Windows starting with Windows Server 2008 and Windows Vista SP1 have shipped with a 64-bit version of MSDASQL.) Examples: OpenLink OLEDB-ODBC Bridge Archived 2017-03-27 at the Wayback Machine , SequeLink OLEDB-ODBC Bridge . An ADO.NET-ODBC bridge consists of an ADO.NET Provider which uses

4648-421: The lack of protection against copying, as compared to compiled software, was often less of an issue. A major legacy of dBase is its .dbf file format, which has been adopted in a number of other applications. For example, the shapefile format, developed by ESRI for spatial data in its PC ArcInfo geographic information system , uses .dbf files to store feature attribute data. Microsoft recommends saving

4731-504: The later ODBC, Blueprint was a purely code-based system, lacking anything approximating a command language like SQL. Instead, programmers used data structures to store the query information, constructing a query by linking many of these structures together. Lotus referred to these compound structures as query trees . Around the same time, an industry team including members from Sybase (Tom Haggin), Tandem Computers ( Jim Gray & Rao Yendluri) and Microsoft (Kyle Geiger) were working on

4814-631: The lawsuit against Fox and allow other companies to use the dBase/xBase language without the threat of legal action. By the end of 1992, major software companies raised the stakes by acquiring the leading xBase products. Borland acquired Ashton-Tate's dBase products (and later WordTech's xBase products), Microsoft acquired Fox Software's FoxBASE+ and FoxPro products, and Computer Associates acquired Nantucket's Clipper products. Advisor Media built on its Data Based Advisor magazine by launching FoxPro Advisor and Clipper Advisor (and other) developer magazines and journals, and live conferences for developers. However,

4897-429: The market. This changed with the poor reception of dBase IV , whose design and stability were so lacking that many users switched to other products. In the early 1990s, xBase products constituted the leading database platform for implementing business applications. The size and impact of the xBase market did not go unnoticed, and within one year, the three top xBase firms were acquired by larger software companies: By

4980-523: The mid-1980s the rapid improvement in microcomputers, and especially the introduction of the graphical user interface and data-rich application programs like Lotus 1-2-3 led to an increasing interest in using personal computers as the client-side platform of choice in client–server computing. Under this model, large mainframes and minicomputers would be used primarily to serve up data over local area networks to microcomputers that would interpret, display and manipulate that data. For this model to work,

5063-416: The nascent company, decided to change the name to the more business-like "dBase". Pawluk devised the use of lower case "d" and all-caps "BASE" to create a distinctive name. Pawluk suggested calling the new product version two ("II") to suggest it was less buggy than an initial release. dBase II was the result and became a standard CP/M application along with WordStar and SuperCalc. In 1981, IBM commissioned

SECTION 60

#1732772192760

5146-511: The new CLI standard. This would not only make Windows a premier platform for CLI development, but also allow users to use SQL to access both Jet and other databases as well. What was missing was the SQL parser that could convert those calls from their text form into the C-interface used in Jet. To solve this, MS partnered with PageAhead Software to use their existing query processor, SIMBA. SIMBA

5229-546: The opening decade of the 21st century, most of the original xBase products had faded from prominence and many had disappeared entirely. Products known as dBase still exist, owned by dBase LLC. In the late 1960s, Fred Thompson at the Jet Propulsion Laboratory (JPL) was using a Tymshare product named RETRIEVE to manage a database of electronic calculators, which were at that time very expensive products. In 1971, Thompson collaborated with Jack Hatfield,

5312-561: The original SQLC standard, retaining many of the advanced features that were removed from the CLI version. These included features like scrollable cursors , and metadata information queries. The commands in the API were split into groups; the Core group was identical to the CLI, the Level 1 extensions were commands that would be easy to implement in drivers, while Level 2 commands contained the more advanced features like cursors. A proposed standard

5395-406: The platform in the C programming language , using automated code conversion tools. The resulting code worked, but was essentially undocumented and inhuman in syntax , a problem that would prove to be serious in the future. In May 1984, the rewritten dBase III was released. Although reviewers widely panned its lowered performance, the product was otherwise well reviewed. After a few rapid upgrades,

5478-487: The pool by processing the post-game statistics found in newspapers. In order to do this, he turned his attention to a database system and, by chance, came across the documentation for JPLDIS. He used this as the basis for a port to PTDOS on his kit-built IMSAI 8080 microcomputer, and called the resulting system Vulcan (after the home planet of Mr. Spock on Star Trek ). George Tate and Hal Lashlee had built two successful start-up companies: Discount Software, which

5561-451: The product is no longer offered. In 2006 Advisor Media stopped its last-surviving xBase magazine, FoxPro Advisor. The era of xBase dominance has ended, but there are still xBase products. The dBase product line is now owned by dBase LLC which currently sells dBASE PLUS 12.3 and a DOS-based dBASE CLASSIC (dbDOS to run it on 64-bit Windows). Some open source implementations are available, such as Harbour , xHarbour , and Clip. In 2015,

5644-407: The program's source code, so that even small changes to the query required considerable programmer effort to modify. The SQL market referred to this as static SQL , versus dynamic SQL which could be changed at any time, like the command-line interfaces that shipped with almost all SQL systems, or a programming interface that left the SQL as plain text until it was called. Dynamic SQL systems became

5727-680: The services of an ODBC driver to connect to a target database. This provider translates ADO.NET method calls into ODBC function calls. Programmers usually use such a bridge when a given database lacks an ADO.NET provider, but is accessible through an ODBC driver. Microsoft ships one as part of the MDAC system component bundle , together with other database drivers, to simplify development in C# . Third parties have also developed such. Examples: OpenLink ADO.NET-ODBC Bridge , SequeLink ADO.NET-ODBC Bridge . Driver (software) A driver in software provides

5810-636: The services of an ODBC driver to connect to a target database. This provider translates OLE DB method calls into ODBC function calls. Programmers usually use such a bridge when a given database lacks an OLE DB provider, but is accessible through an ODBC driver. Microsoft ships one, MSDASQL.DLL, as part of the MDAC system component bundle , together with other database drivers, to simplify development in COM-aware languages (e.g. Visual Basic ). Third parties have also developed such, notably OpenLink Software whose 64-bit OLE DB Provider for ODBC Data Sources filled

5893-407: The software was powerful but the documentation was poor. He praised its speed and sophisticated queries, but said that "we do a lot of pounding at the table and screaming in rage at the documentation". "Is [dBASE IV 1.0] worth the wait? I think so", Malcolm Rubel wrote in the magazine in 1989, describing it as "a quantum leap over dBASE III Plus in functionality, power, and ease of use". He said that

5976-708: The standard for cross-platform data access. Sun Microsystems used the ODBC system as the basis for their own open standard, Java Database Connectivity (JDBC). In most ways, JDBC can be considered a version of ODBC for the programming language Java instead of C . JDBC-to-ODBC bridges allow Java-based programs to access data sources through ODBC drivers on platforms lacking a native JDBC driver, although these are now relatively rare. Inversely, ODBC-to-JDBC bridges allow C-based programs to access data sources through JDBC drivers on platforms or from databases lacking suitable ODBC drivers. ODBC remains in wide use today, with drivers available for most platforms and most databases. It

6059-483: The system stabilized and was once again a best-seller throughout the 1980s, and formed the famous "application trio" of PC compatibles (dBase, Lotus 123 , and WordPerfect ). By the fall of 1984, the company had over 500 employees and was taking in US$ 40 million a year in sales (equivalent to $ 117 million in 2023), the vast majority from dBase products. There was also an unauthorized clone of dBase III called Rebus in

6142-454: The variety of SQL's and provide a single common interface which could then be called by other mainframe or microcomputer programs. These solutions included IBM's Distributed Relational Database Architecture ( DRDA ) and Apple Computer 's Data Access Language . Much more common, however, were systems that ran entirely on microcomputers, including a complete protocol stack that included any required networking or file translation support. One of

6225-563: The votes and became the draft standard, but only after large portions of the API were removed – the standards document was trimmed from 120 pages to 50 during this time. It was also during this period that the name Call Level Interface was formally adopted. In 1995 SQL/CLI became part of the international SQL standard, ISO/IEC 9075-3. The SAG itself was taken over by the X/Open group in 1996, and, over time, became part of The Open Group 's Common Application Environment . MS continued working with

6308-434: The way, Borland , which had bought Ashton-Tate , brought out a revised dBase IV in 1992 but with a focus described as "designed for programmers" rather than "for ordinary users". For handling data, dBase provided detailed procedural commands and functions to dBase is an application development language and integrated navigational database management system which Ashton-Tate labeled as " relational " but it did not meet

6391-450: Was a potential solution to the call for the CLI, which was being led by DEC. The new SQLC "gang of four", MS, Tandem, DEC and Sybase, brought an updated version of SQLC to the next SAG meeting in June 1990. The SAG responded by opening the standard effort to any competing design, but of the many proposals, only Oracle Corp had a system that presented serious competition. In the end, SQLC won

6474-502: Was not until March 1995 that the definitive version was finalized. By then, Microsoft had already granted Visigenic Software a source code license to develop ODBC on non-Windows platforms. Visigenic ported ODBC to the classic Mac OS , and a wide variety of Unix platforms, where ODBC quickly became the de facto standard. "Real" CLI is rare today. The two systems remain similar, and many applications can be ported from ODBC to CLI with few or no changes. Over time, database vendors took over

6557-464: Was one of the "big three" software publishers in the early business-software market, along with Lotus Development and WordPerfect . Starting in the mid-1980s, several companies produced their own variations on the dBase product and especially the dBase programming language. These included FoxBASE+ (later renamed FoxPro), Clipper , and other so-called xBase products. Many of these were technically stronger than dBase, but could not push it aside in

6640-424: Was one of the first to sell PC software programs through the mail to consumers, and Software Distributors, which was one of the first wholesale distributors of PC software in the world. They entered into an agreement with Ratliff to market Vulcan, and formed Ashton-Tate (the name Ashton was chosen purely for marketing reasons) to do so. Ratliff ported Vulcan from PTDOS to CP/M . Hal Pawluk, who handled marketing for

6723-468: Was released in December 1991, and industry input was gathered and worked into the system through 1992, resulting in yet another name change to ODBC . During this time, Microsoft was in the midst of developing their Jet database system . Jet combined three primary subsystems; an ISAM -based database engine (also named Jet , confusingly), a C-based interface allowing applications to access that data, and

6806-502: Was unavoidable due to the path that the calls took through the Jet-based stack; ODBC calls to SQL databases were first converted from Simba Technologies 's SQL dialect to Jet's internal C-based format, then passed to a driver for conversion back into SQL calls for the database. Digital Equipment and Oracle both contracted Simba Technologies to develop drivers for their databases as well. Circa 1993, OpenLink Software shipped one of

6889-545: Was used as a parser above Jet's C library, turning Jet into an SQL database. And because Jet could forward those C-based calls to other databases, this also allowed SIMBA to query other systems. Microsoft included drivers for Excel to turn its spreadsheet documents into SQL-accessible database tables. ODBC 1.0 was released in September 1992. At the time, there was little direct support for SQL databases (versus ISAM), and early drivers were noted for poor performance. Some of this

#759240