/* ekfind.f -- translated by f2c (version 19980913). You must link the resulting object file with the libraries: -lf2c -lm (in that order) */ #include "f2c.h" /* Table of constant values */ static integer c__27869 = 27869; static integer c__100 = 100; static integer c__500 = 500; /* $Procedure EKFIND ( EK, find data ) */ /* Subroutine */ int ekfind_(char *query, integer *nmrows, logical *error, char *errmsg, ftnlen query_len, ftnlen errmsg_len) { extern /* Subroutine */ int zzekscan_(char *, integer *, integer *, integer *, integer *, integer *, integer *, integer *, doublereal *, char *, integer *, integer *, logical *, char *, ftnlen, ftnlen, ftnlen), zzeksemc_(char *, integer *, char *, logical *, char *, integer *, ftnlen, ftnlen, ftnlen), zzekqini_(integer *, integer *, integer *, char *, doublereal *, ftnlen), zzekpars_( char *, integer *, integer *, integer *, integer *, integer *, doublereal *, char *, integer *, integer *, integer *, char *, doublereal *, logical *, char *, ftnlen, ftnlen, ftnlen, ftnlen), zzeknres_(char *, integer *, char *, logical *, char *, integer *, ftnlen, ftnlen, ftnlen), zzektres_(char *, integer *, char *, doublereal *, logical *, char *, integer *, ftnlen, ftnlen, ftnlen), chkin_(char *, ftnlen); char eqryc[2000]; doublereal eqryd[100]; integer eqryi[27875], chbegs[500], chends[500]; char chrbuf[2000]; extern logical return_(void); doublereal numvls[100]; integer errptr, lxbegs[500], lxends[500], ntoken, tokens[500], values[500] ; extern /* Subroutine */ int chkout_(char *, ftnlen), eksrch_(integer *, char *, doublereal *, integer *, logical *, char *, ftnlen, ftnlen); /* $ Abstract */ /* Find E-kernel data that satisfy a set of constraints. */ /* $ Copyright */ /* Copyright (1995), California Institute of Technology. */ /* U.S. Government sponsorship acknowledged. */ /* $ Required_Reading */ /* EK */ /* $ Keywords */ /* EK */ /* PARSE */ /* SEARCH */ /* $ Declarations */ /* Include Section: EK Encoded Query Internal Parameters */ /* ekquery.inc Version 3 16-NOV-1995 (NJB) */ /* Updated to reflect increased value of MAXCON in */ /* ekqlimit.inc. */ /* ekquery.inc Version 2 03-AUG-1995 (NJB) */ /* Updated to support representation of the SELECT clause. */ /* ekquery.inc Version 1 12-JAN-1995 (NJB) */ /* An encoded EK query is an abstract data type implemented */ /* as an integer cell, along with a double precision cell and */ /* a character string. The d.p. cell and string contain numeric */ /* and string values from the query string represented by the */ /* encoded query. */ /* The parameters in this file are intended for use only by the */ /* EK encoded query access routines. Callers of EK routines should */ /* not use these parameters. */ /* The following parameters are indices of specified elements */ /* in the integer portion of the encoded query. */ /* Encoded query architecture type: */ /* `Name resolution' consists of: */ /* - Verifying existence of tables: any table names listed */ /* in the FROM clause of a query must be loaded. */ /* - Validating table aliases used to qualify column names. */ /* - Verifying existence of columns and obtaining data types */ /* for columns. */ /* - Setting data type codes for literal values in the encoded */ /* query. */ /* - Checking consistency of operators and operand data types. */ /* - Making sure unqualified column names are unambiguous. */ /* - For constraints, mapping the table names used to qualify */ /* column names to the ordinal position in the FROM clause */ /* of the corresponding table. */ /* Initialization status---this flag indicates whether the encoded */ /* query has been initialized. Values are ITRUE or IFALSE. See the */ /* include file ekbool.inc for parameter values. */ /* Parse status---this flag indicates whether the parsing operation */ /* that produced an encoded query has been completed. Values are */ /* ITRUE or IFALSE. */ /* Name resolution status---this flag indicates whether names */ /* have been resolved in an encoded query. Values are ITRUE or */ /* IFALSE. */ /* Time resolution status---this flag indicates whether time values */ /* have been resolved in an encoded query. Time resolution */ /* consists of converting strings representing time values to ET. */ /* Values of the status are ITRUE or IFALSE. */ /* Semantic check status---this flag indicates whether semantic */ /* checking of constraints has been performed. */ /* Number of tables specified in FROM clause: */ /* Number of constraints in query: */ /* A special value is used to indicate the `maximal' constraint--- */ /* one that logically cannot be satisfied. If the constraints */ /* are equivalent to the maximal constraint, the location EQNCNS */ /* is assigned the value EQMXML */ /* Number of constraint conjunctions: */ /* Number of order-by columns: */ /* Number of SELECT columns: */ /* Size of double precision buffer: */ /* `Free' pointer into double precision buffer: */ /* Size of character string buffer: */ /* `Free' pointer into character string buffer: */ /* The following four base pointers will be valid after a query */ /* has been parsed: */ /* Base pointer for SELECT column descriptors: */ /* Base pointer for constraint descriptors: */ /* Base pointer for conjunction sizes: */ /* Base pointer for order-by column descriptors: */ /* After the quantities named above, the integer array contains */ /* series of descriptors for tables, constraints, and order-by */ /* columns, as well as a list of `conjunction sizes'---that is, */ /* the sizes of the groups of constraints that form conjunctions, */ /* after the input query has been re-arranged as a disjunction of */ /* conjunctions of constraints. */ /* The offsets of specific elements within descriptors are */ /* parameterized. The base addresses of the descriptors themselves */ /* must be calculated using the counts and sizes of the items */ /* preceding them. */ /* A diagram of the structure of the variable-size portion of the */ /* integer array is shown below: */ /* +-------------------------------------+ */ /* | Fixed-size portion of encoded query | */ /* +-------------------------------------+ */ /* | Encoded FROM clause | */ /* +-------------------------------------+ */ /* | Encoded constraint clause | */ /* +-------------------------------------+ */ /* | Conjunction sizes | */ /* +-------------------------------------+ */ /* | Encoded ORDER BY clause | */ /* +-------------------------------------+ */ /* | Encoded SELECT clause | */ /* +-------------------------------------+ */ /* Value Descriptors */ /* ---------------- */ /* In order to discuss the various descriptors below, we'll make use */ /* of sub-structures called `value descriptors'. These descriptors */ /* come in two flavors: character and double precision. For */ /* strings, a descriptor is a set of begin and end pointers that */ /* indicate the location of the string in the character portion of an */ /* encoded query, along with the begin and end pointers for the */ /* corresponding lexeme in the original query. The pointers are set */ /* to zero when they are not in use, for example if they refer to an */ /* optional lexeme that did not appear in the input query. */ /* All value descriptors start with a data type indicator; values */ /* are from ektype.inc. Integer and time values are referred to */ /* by double precision descriptors. */ /* Parameters for string value descriptor elements: */ /* Numeric value descriptors are similar to those for string values, */ /* the difference being that they have only one pointer to the value */ /* they represent. This pointer is the index of the value in the */ /* encoded query's numeric buffer. */ /* All value descriptors have the same size. In order to allow */ /* table descriptors to have the same size as value descriptors, */ /* we include an extra element in the descriptor. */ /* Column Descriptors */ /* ----------------- */ /* Each column descriptor consists of a character descriptor for the */ /* name of the column, followed by an index, which gives the ordinal */ /* position of the column in the logical table to which the column */ /* belongs. The index element is filled in during name resolution. */ /* Table Descriptors */ /* ----------------- */ /* Each table descriptor consists of a character descriptor for the */ /* name of the table, followed by an index, which gives the ordinal */ /* position of the table in the FROM clause in the original query. */ /* The index element is filled in during name resolution. Aliases */ /* and table names have identical descriptor structures. */ /* Constraint descriptors */ /* ------------------ */ /* Each constraint is characterized by: */ /* - A code indicating whether the constraint compares values */ /* in two columns or the value in a column and a literal */ /* value. The values of this element are EQCOL and EQVAL. */ /* - A descriptor for the table used to qualify the */ /* column name on the left side of the constraint. */ /* - A character value descriptor for the column name on the left */ /* side of the query. */ /* - An operator code indicating the relational operator used */ /* in the constraint. */ /* If the constraint compares values from two columns, the */ /* next items are table and column name descriptors that apply to */ /* the column named on the right side of the relational operator. */ /* If the constraint has a literal value on the right side, the */ /* operator code is followed by... */ /* - a value descriptor. */ /* - Size of a constraint descriptor: */ /* Conjunction sizes */ /* ----------------- */ /* The size of each conjunction of constraints occupies a single */ /* integer. */ /* Order-by Column Descriptors */ /* --------------------------- */ /* Each order-by column descriptor contains descriptors for */ /* the table containing the column and for the name of the column */ /* itself; one additional element is used to indicate the direction */ /* of the ordering (ascending vs descending). */ /* - The last integer in the descriptor indicates whether the */ /* order direction is ascending or descending. */ /* - Size of an order-by column descriptor: */ /* Codes indicating sense of ordering (ascending vs descending): */ /* SELECT Column Descriptors */ /* --------------------------- */ /* Each SELECT column descriptor contains descriptors for */ /* the table containing the column and for the name of the column */ /* itself. */ /* - Size of a SELECT column descriptor: */ /* Miscellaneous parameters: */ /* EQIMIN is the minimum size of the integer portion of */ /* an encoded query. EQIMIN depends on the parameters */ /* MAXTAB */ /* MAXCON */ /* MAXORD */ /* MAXSEL */ /* all of which are declared in the include file ekqlimit.inc. */ /* The functional definition of EQIMIN is: */ /* INTEGER EQIMIN */ /* PARAMETER ( EQIMIN = EQVBAS */ /* . + MAXTAB * EQVDSZ * 2 */ /* . + MAXCON * EQCDSZ */ /* . + MAXCON */ /* . + MAXORD * EQODSZ */ /* . + MAXSEL * EQSDSZ ) */ /* End Include Section: EK Encoded Query Internal Parameters */ /* Include Section: EK Query Limit Parameters */ /* ekqlimit.inc Version 3 16-NOV-1995 (NJB) */ /* Parameter MAXCON increased to 1000. */ /* ekqlimit.inc Version 2 01-AUG-1995 (NJB) */ /* Updated to support SELECT clause. */ /* ekqlimit.inc Version 1 07-FEB-1995 (NJB) */ /* These limits apply to character string queries input to the */ /* EK scanner. This limits are part of the EK system's user */ /* interface: the values should be advertised in the EK required */ /* reading document. */ /* Maximum length of an input query: MAXQRY. This value is */ /* currently set to twenty-five 80-character lines. */ /* Maximum number of columns that may be listed in the */ /* `order-by clause' of a query: MAXSEL. MAXSEL = 50. */ /* Maximum number of tables that may be listed in the `FROM */ /* clause' of a query: MAXTAB. */ /* Maximum number of relational expressions that may be listed */ /* in the `constraint clause' of a query: MAXCON. */ /* This limit applies to a query when it is represented in */ /* `normalized form': that is, the constraints have been */ /* expressed as a disjunction of conjunctions of relational */ /* expressions. The number of relational expressions in a query */ /* that has been expanded in this fashion may be greater than */ /* the number of relations in the query as orginally written. */ /* For example, the expression */ /* ( ( A LT 1 ) OR ( B GT 2 ) ) */ /* AND */ /* ( ( C NE 3 ) OR ( D EQ 4 ) ) */ /* which contains 4 relational expressions, expands to the */ /* equivalent normalized constraint */ /* ( ( A LT 1 ) AND ( C NE 3 ) ) */ /* OR */ /* ( ( A LT 1 ) AND ( D EQ 4 ) ) */ /* OR */ /* ( ( B GT 2 ) AND ( C NE 3 ) ) */ /* OR */ /* ( ( B GT 2 ) AND ( D EQ 4 ) ) */ /* which contains eight relational expressions. */ /* MXJOIN is the maximum number of tables that can be joined. */ /* MXJCON is the maximum number of join constraints allowed. */ /* Maximum number of order-by columns that may be used in the */ /* `order-by clause' of a query: MAXORD. MAXORD = 10. */ /* Maximum number of tokens in a query: 500. Tokens are reserved */ /* words, column names, parentheses, and values. Literal strings */ /* and time values count as single tokens. */ /* Maximum number of numeric tokens in a query: */ /* Maximum total length of character tokens in a query: */ /* Maximum length of literal string values allowed in queries: */ /* MAXSTR. */ /* End Include Section: EK Query Limit Parameters */ /* Include Section: EK Data Types */ /* ektype.inc Version 1 27-DEC-1994 (NJB) */ /* Within the EK system, data types of EK column contents are */ /* represented by integer codes. The codes and their meanings */ /* are listed below. */ /* Integer codes are also used within the DAS system to indicate */ /* data types; the EK system makes no assumptions about compatibility */ /* between the codes used here and those used in the DAS system. */ /* Character type: */ /* Double precision type: */ /* Integer type: */ /* `Time' type: */ /* Within the EK system, time values are represented as ephemeris */ /* seconds past J2000 (TDB), and double precision numbers are used */ /* to store these values. However, since time values require special */ /* treatment both on input and output, and since the `TIME' column */ /* has a special role in the EK specification and code, time values */ /* are identified as a type distinct from double precision numbers. */ /* End Include Section: EK Data Types */ /* Include Section: EK Operator Codes */ /* ekopcd.inc Version 1 30-DEC-1994 (NJB) */ /* Within the EK system, operators used in EK queries are */ /* represented by integer codes. The codes and their meanings are */ /* listed below. */ /* Relational expressions in EK queries have the form */ /* */ /* For columns containing numeric values, the operators */ /* EQ, GE, GT, LE, LT, NE */ /* may be used; these operators have the same meanings as their */ /* Fortran counterparts. For columns containing character values, */ /* the list of allowed operators includes those in the above list, */ /* and in addition includes the operators */ /* LIKE, UNLIKE */ /* which are used to compare strings to a template. In the character */ /* case, the meanings of the parameters */ /* GE, GT, LE, LT */ /* match those of the Fortran lexical functions */ /* LGE, LGT, LLE, LLT */ /* The additional unary operators */ /* ISNULL, NOTNUL */ /* are used to test whether a value of any type is null. */ /* End Include Section: EK Operator Codes */ /* Include Section: EK Column Name Size */ /* ekcnamsz.inc Version 1 17-JAN-1995 (NJB) */ /* Size of column name, in characters. */ /* End Include Section: EK Column Name Size */ /* $ Brief_I/O */ /* Variable I/O Description */ /* -------- --- -------------------------------------------------- */ /* QUERY I Query specifying data to be found. */ /* NMROWS O Number of matching rows. */ /* ERROR O Flag indicating whether query parsed correctly. */ /* ERRMSG O Parse error description. */ /* $ Detailed_Input */ /* QUERY is a character string that specifies a set of EK */ /* data to select from those present in currently */ /* loaded EK files. The selected data will be */ /* retrievable via the EK fetch routines EKGC, EKGD, */ /* and EKGI. */ /* The query consists of four clauses, the third and */ /* fourth of which are optional. The general form */ /* of a query is */ /* SELECT */ /* FROM */ /* [WHERE ] */ /* [ORDER BY ] */ /* where brackets indicate optional items. The */ /* elements of the query shown above are called, */ /* respectively, the `SELECT clause', the */ /* `FROM clause', the `WHERE clause', and the */ /* `ORDER BY clause'. The result of a query may be */ /* thought of as a new table, whose columns are those */ /* specified in the SELECT clause, whose rows are */ /* those satisfying the constraints of the WHERE */ /* clause, and whose rows are ordered according to */ /* the ORDER BY clause. */ /* The SELECT clause specifies a list of columns */ /* from which data are to be selected. In a simple */ /* (non-join) query, these columns must belong to */ /* the single table specified in the FROM clause. */ /* The form of a SELECT clause is */ /* SELECT [ ,...] */ /* In queries having multiple tables in the FROM */ /* clause, column names are ambiguous if they occur */ /* in more than one table in the FROM clause. Such */ /* column names must be qualified with table */ /* identifiers. These identifiers may be the names of */ /* the tables to which the columns belong, or table */ /* `aliases', names (usually short ones) associated */ /* with tables in the FROM clause. Table aliases have */ /* duration limited to the execution of the query to */ /* which they belong. */ /* The form of a qualified column name is */ /*
. */ /* or */ /*
. */ /* The FROM clause specifies the tables from which */ /* data are to be selected. In simple queries, only */ /* one table is listed. In this case the form of */ /* the FROM clause is */ /* FROM
*/ /* In queries involving multiple tables, the form of */ /* the FROM clause becomes */ /* FROM
[
] */ /* [ ,
[
] ... ] */ /* The aliases associated with the table names must */ /* be distinct and must not be the actual names of */ /* loaded EK tables. */ /* Queries involving multiple tables are called */ /* `joins'. */ /* The meaning of a FROM clause containing multiple */ /* tables is that the output is to be a subset of */ /* the rows of the Cartesian product of the listed */ /* tables. Normally, WHERE clause constraints are */ /* supplied to reduce the selected rows to a set of */ /* interest. */ /* The most common example of a join is a query with */ /* two tables listed in the FROM clause, and a WHERE */ /* clause constraint enforcing equality of members */ /* of a column in the first table with members of */ /* column in the second table. Such a query is */ /* called an `equi-join'. A join in which columns */ /* of different tables are related by an inequality */ /* is called a `non-equi-join'. Any type of join */ /* other than an equi-join may be very slow to */ /* evaluate, due to the large number of elements that */ /* may be contained in the Cartesian */ /* product of the listed tables. */ /* The WHERE clause lists constraints that must */ /* be met by each row satisfying the query. The */ /* constraints are specified as a logical combination */ /* of relational expressions. The form of the */ /* constraint list is */ /* WHERE */ /* where each consists of one */ /* or more simple relational expressions of the form */ /* */ /* where */ /* */ /* is a column name, a literal value, or the special */ /* symbol */ /* NULL */ /* and */ /* */ /* is any of */ /* EQ, GE, GT, LE, LIKE, LT, NE, NOT LIKE, <, <=, */ /* =, >, >=, !=, <> */ /* For comparison with null values, the special */ /* syntaxes */ /* IS NULL */ /* IS NOT NULL */ /* are allowed, in addition to the standard */ /* comparison syntaxes using the equality or */ /* inequality operators. */ /* The LIKE operator allows comparison of a string */ /* value against a template. The template syntax */ /* is that allowed by the SPICELIB routine MATCHI. */ /* Templates may include literal characters, the */ /* wild string marker '*', and the wild character */ /* marker '%'. Case is significant in templates. */ /* Templates are bracketed by quote characters, just */ /* as are literal strings. */ /* The query language also supports the BETWEEN and */ /* NOT BETWEEN constructs */ /* BETWEEN AND */ /* NOT BETWEEN AND */ /* The tokens */ /* */ /* */ /* may be literal values or column names. */ /* The BETWEEN operator considers values that match */ /* the bounds to satisfy the condition: the BETWEEN */ /* operator tests for inclusion in the closed interval */ /* defined by the bounds. */ /* In the WHERE clause, simple relational expressions */ /* may be combined using the logical operators AND, */ /* OR, and NOT, as in the Fortran programming */ /* language. Parentheses may be used to enforce a */ /* desired order of evaluation of logical expressions. */ /* The expression syntax is NOT symmetric: literal */ /* values must not appear on the left hand side of the */ /* operators that apply to them. */ /* The columns named in a constraint clause must */ /* belong to the tables listed in the FROM clause. */ /* If the query is a join, qualifying table names or */ /* aliases are required wherever their omission would */ /* result in ambiguity. */ /* Data types of the columns or constants used on the */ /* right-hand-sides of operators must match the data */ /* types of the corresponding columns on the */ /* left-hand-sides, except that comparison of integer */ /* and double precision quantities is permitted. */ /* Literal strings used in constraints are always */ /* bracketed by quotes. Either single quotes (') */ /* or double quotes (") may be used, but the same */ /* quote character must be used to start and end any */ /* literal string. Within character string values, */ /* quote characters must be doubled in order to be */ /* recognized. Case is significant in character */ /* except in comparisions using the LIKE and NOT LIKE */ /* operators, which ignore case: the expression */ /* ANIMAL LIKE "*A*" */ /* would be considered true when ANIMAL takes the */ /* value */ /* "cat" */ /* Time values are considered to be strings and */ /* require bracketing quotes. Currently, the */ /* only time values allowed are UTC times in ISO */ /* format, UTC times represented in forms accepted by */ /* the SPICELIB routine TPARSE, and SCLK strings in */ /* NAIF format. */ /* The ORDER BY clause indicates which columns to */ /* use to order the output generated by the query. */ /* The columns in the ORDER BY clause define a */ /* dictionary ordering, with the first listed column */ /* acting as a primary key, the second column acting */ /* as a secondary key, and so on. */ /* For each ORDER BY column, the keywords ASC or DESC */ /* may be supplied to indicate whether the items in */ /* that column are to be listed in ascending or */ /* descending order. Ascending order is the default. */ /* The direction in which data items increase is */ /* referred to as the `order sense'. */ /* The ORDER BY clause, if present, must appear */ /* last in the query. */ /* The form of the ORDER BY clause is */ /* ORDER BY [] */ /* [ , []...] */ /* Rows satisfying the query constraints will be */ /* returned so that the entries of the first column */ /* specified in the ORDER BY clause will be appear in */ /* the order specified by the order sense keyword, */ /* which is assumed to be ASC if absent. When entries */ /* in the first through Nth ORDER BY column are equal, */ /* the entries in the (N+1)st ORDER BY column */ /* determine the order of the rows, and so on. */ /* As in the WHERE clause, column names must be */ /* qualified by table names or table aliases where */ /* they would otherwise be ambiguous. */ /* The query language is word-oriented, and some */ /* indicate whether the words are reserved. Reserved */ /* words must be separated from other words by white */ /* space. It is not necessary to use white space */ /* to separate words and punctuation characters. */ /* The list of reserved words is */ /* AND */ /* BETWEEN */ /* BY */ /* COLUMN */ /* EQ */ /* FROM */ /* GE */ /* GT */ /* IS */ /* LE */ /* LT */ /* LIKE */ /* NE */ /* NOT */ /* NULL */ /* OR */ /* ORDER */ /* SELECT */ /* WHERE */ /* The left and right parenthesis characters are also */ /* reserved; they may not be used in queries outside */ /* of quoted strings. */ /* Case is not significant in queries, except within */ /* literal strings. */ /* $ Detailed_Output */ /* NMROWS is the number of rows that match the query */ /* criteria. NMROWS is defined if and only if */ /* ERROR is returned .FALSE. */ /* ERROR is a logical flag indicating whether the query */ /* failed to parse correctly. */ /* ERRMSG is a character string that describes EKFIND's */ /* diagnosis of a parse error, should one occur. */ /* Otherwise, ERRMSG will be returned blank. */ /* $ Parameters */ /* See the include files. */ /* $ Exceptions */ /* 1) Most of the exceptions that can occur on a call to */ /* EKFIND are caused by errors in the input query. EKFIND */ /* attempts to diagnose these via the output error flag and */ /* error message, instead of signalling errors. The following */ /* classes of errors are detected: */ /* Scanning errors---these result from badly formed query */ /* in which EKFIND could not identify all of the tokens. */ /* When these errors occur, EKFIND may be too confused to */ /* give a helpful diagnostic message. */ /* Parsing errors---these result from a badly formed */ /* query that EKFIND was able to separate into tokens */ /* but that EKFIND determined to be syntactically invalid: */ /* Name resolution errors---these result from referencing */ /* invalid or ambiguous column or table names in a query. */ /* Time resolution errors---these result from use of time */ /* strings that cannot be parsed. */ /* Semantic errors---these result from a syntactically */ /* valid query that violates a limit or a restriction on */ /* values used in a query. */ /* Some problems with queries are not trapped by EKFIND but */ /* instead cause errors to be signalled. These are listed below. */ /* 2) If no E-kernels are loaded at the time this routine is called, */ /* an error will be signalled by routines called by this routine. */ /* 3) If a leapseconds kernel is is not loaded before this routine */ /* is called, UTC time values may not be used in queries. If */ /* they are, an error will be signalled by routines called by */ /* this routine. */ /* 4) If an SCLK kernel for the appropriate spacecraft clock */ /* has not been loaded before this routine is called, SCLK */ /* values for that clock may not be used in queries. If */ /* they are, an error will be signalled by routines called by */ /* this routine. */ /* $ Files */ /* None. */ /* $ Particulars */ /* This routine operates almost entirely by side effects: it */ /* prepares the EK fetch routines to return event data that */ /* satisfy the input query. See the header of the routine */ /* EKQMGR or the EK Required Reading for examples of use of this */ /* routine in conjunction with the EK fetch routines. */ /* $ Examples */ /* 1) Examples of strings containing syntactically valid queries: */ /* SELECT COL1 FROM TAB1 */ /* select col1 from tab1 where col1 gt 5 */ /* SELECT COL2 FROM TAB1 WHERE COL2 > 5.7D0 ORDER BY COL2 */ /* SELECT COL2 FROM TAB1 WHERE COL1 != 5 */ /* SELECT COL2 FROM TAB1 WHERE COL1 GE COL2 */ /* SELECT COL1, COL2, COL3 FROM TAB1 ORDER BY COL1 */ /* SELECT COL3 FROM TAB1 WHERE COL5 EQ "ABC" */ /* SELECT COL3 FROM TAB1 WHERE COL5 = 'ABC' */ /* SELECT COL3 FROM TAB1 WHERE COL5 LIKE 'A*' */ /* SELECT COL3 FROM TAB1 WHERE COL5 LIKE 'A%%' */ /* SELECT COL4 FROM TAB1 WHERE COL4 = '1995 JAN 1 12:38:09.7' */ /* SELECT COL4 FROM TAB1 WHERE COL4 = "1995 JAN 1 12:38:09.7" */ /* SELECT COL4 FROM TAB1 WHERE */ /* COL4 NE 'GLL SCLK 02724646:67:7:2' */ /* SELECT COL1 FROM TAB1 WHERE COL1 != NULL */ /* SELECT COL1 FROM TAB1 WHERE COL1 IS NULL */ /* SELECT COL1 FROM TAB1 WHERE COL1 IS NOT NULL */ /* SELECT COL1, COL2, COL3 FROM TAB1 */ /* WHERE (COL1 BETWEEN 4 AND 6) AND (COL3 NOT LIKE "A%%") */ /* ORDER BY COL1, COL3 */ /* SELECT COL4 FROM TAB1 */ /* WHERE COL4 BETWEEN "1995 JAN 1 12:38" AND */ /* "October 23, 1995" */ /* SELECT COL1, COL2 FROM TAB1 WHERE */ /* NOT ( ( ( COL1 < COL2 ) AND ( COL1 > 5 ) ) OR */ /* ( ( COL1 >= COL2 ) AND ( COL2 <= 10 ) ) ) */ /* SELECT T1.COL1, T1.COL2, T2.COL2, T2.COL3 */ /* FROM TABLE1 T1, TABLE2 T2 */ /* WHERE T1.COL1 = T2.COL1 */ /* AND T1.COL2 > 5 */ /* ORDER BY T1.COL1, T2.COL2 */ /* 2) Examples of syntactically invalid queries: */ /* SELECT TIME WHERE TIME */ /* LT 1991 JAN 1 {FROM clause is absent} */ /* select time from table1 where */ /* time lt 1991 jan 1 {time string is not */ /* quoted} */ /* select time from table1 */ /* where time .lt. '1991 jan 1' {operator should be lt} */ /* select cmd from table1 */ /* where "cmd,6tmchg" != cmd {value is on left side */ /* of operator} */ /* select event_type from table1 */ /* where event_type eq "" {quoted string is empty */ /* ---use " " to indicate */ /* a blank string} */ /* select event_type from table1 */ /* where event_type = "COMMENT" */ /* order TIME {ORDER BY phrase is */ /* lacking BY keyword} */ /* select COL1 from table where */ /* where COL1 eq MOC_EVENT {literal string on */ /* right-hand-side of */ /* operator is not quoted} */ /* In the following examples, we'll assume that the program */ /* calling EKFIND has loaded an EK containing two segments */ /* having columns having the following names and attributes: */ /* TABLE1: */ /* ========== */ /* Column name Data type Size Indexed? */ /* ----------- --------- ---- -------- */ /* EVENT_TYPE CHARACTER*32 1 YES */ /* EVENT_PARAMETERS CHARACTER*(*) 1 NO */ /* COMMENT CHARACTER*80 VARIABLE NO */ /* TABLE2: */ /* ========== */ /* Column name Data type Size Indexed? */ /* ----------- --------- ---- -------- */ /* EVENT_TYPE CHARACTER*32 1 YES */ /* EVENT_PARAMETERS CHARACTER*80 1 NO */ /* COMMENT CHARACTER*80 VARIABLE NO */ /* COMMAND CHARACTER*80 1 YES */ /* Then the following queries are semantically invalid: */ /* SELECT EVENT_PARAMETERS */ /* FROM TABLE1 */ /* WHERE EVENT_DURATION = 7.0 {No column called */ /* EVENT_DURATION */ /* is present in a loaded */ /* EK} */ /* SELECT COMMENT FROM TABLE2 */ /* WHERE COMMENT EQ "N/A" {The COMMENT column does */ /* not have size 1 and */ /* therefore cannot be */ /* referenced in a query} */ /* $ Restrictions */ /* 1) A leapseconds kernel must be loaded before this routine may */ /* be called, if UTC time values are used in input queries. */ /* 2) An appropriate SCLK kernel must be loaded before this routine */ /* may be called, if SCLK values are used in input queries. */ /* 3) Data found in response to a query become unavailable */ /* when a fast load is initiated via EKIFLD. Any desired */ /* fetches of the data must be performed before a fast */ /* load or any other operation that modifies the EK scratch */ /* area is initiated. */ /* $ Literature_References */ /* None. */ /* $ Author_and_Institution */ /* N.J. Bachman (JPL) */ /* $ Version */ /* - SPICELIB Version 1.0.3, 19-DEC-2001 (NJB) */ /* Restrictions section was updated. */ /* - SPICELIB Version 1.0.2, 14-JAN-1997 (NJB) */ /* Syntax descriptions for comparisons using null values have been */ /* added. The $Examples section was augmented with sample queries */ /* demonstrating use of the IS NULL and IS NOT NULL comparison */ /* operators. */ /* - SPICELIB Version 1.0.1, 16-AUG-1996 (NJB) */ /* C$ Exceptions section of header was updated to indicate that */ /* calling this routine while no E-kernels are loaded will cause */ /* an error to be signalled. Previous version line was changed */ /* from "Beta" to "SPICELIB," and the previous version was */ /* corrected to 1.0.0. */ /* - SPICELIB Version 1.0.0, 24-OCT-1995 (NJB) */ /* -& */ /* $ Index_Entries */ /* find EK data */ /* issue EK query */ /* -& */ /* SPICELIB functions */ /* Local parameters */ /* Storage limits: */ /* Local variables */ /* Standard SPICE error handling. */ if (return_()) { return 0; } else { chkin_("EKFIND", (ftnlen)6); } /* Initialize the encoded query each time, for safety. */ zzekqini_(&c__27869, &c__100, eqryi, eqryc, eqryd, (ftnlen)2000); /* Find the tokens in the input query. */ zzekscan_(query, &c__500, &c__100, &ntoken, tokens, lxbegs, lxends, values, numvls, chrbuf, chbegs, chends, error, errmsg, query_len, (ftnlen)2000, errmsg_len); if (*error) { chkout_("EKFIND", (ftnlen)6); return 0; } /* Now parse the query. */ zzekpars_(query, &ntoken, lxbegs, lxends, tokens, values, numvls, chrbuf, chbegs, chends, eqryi, eqryc, eqryd, error, errmsg, query_len, ( ftnlen)2000, (ftnlen)2000, errmsg_len); if (*error) { chkout_("EKFIND", (ftnlen)6); return 0; } /* Resolve names. */ zzeknres_(query, eqryi, eqryc, error, errmsg, &errptr, query_len, (ftnlen) 2000, errmsg_len); if (*error) { chkout_("EKFIND", (ftnlen)6); return 0; } /* Resolve time values, if necessary. */ zzektres_(query, eqryi, eqryc, eqryd, error, errmsg, &errptr, query_len, ( ftnlen)2000, errmsg_len); if (*error) { chkout_("EKFIND", (ftnlen)6); return 0; } /* Perform semantic checks. */ zzeksemc_(query, eqryi, eqryc, error, errmsg, &errptr, query_len, (ftnlen) 2000, errmsg_len); if (*error) { chkout_("EKFIND", (ftnlen)6); return 0; } /* If we arrived here, the encoded query is ready for execution. */ /* Find the data satisfying the constraints. */ eksrch_(eqryi, eqryc, eqryd, nmrows, error, errmsg, (ftnlen)2000, errmsg_len); chkout_("EKFIND", (ftnlen)6); return 0; } /* ekfind_ */