%----------------------------------------------------------------------- %----------------------------------------------------------------------- % A Simple Query Processor in Prolog % % Author: Rodger Knaus % Instant Recall % 5900 Walton Rd. % Bethesda, Md. 20817 % (301) 530 - 0898 % BBS: (301) 983-8439 (2400 bps) % % Version of Prolog: Arity Prolog, v. 4 % % See the Practical Prolog column in % AI Expert (April, 1988) for a discussion of this program % % Note about this listing: This listing is complete except % for a few low level predicates, such as list_length which % you can easily write yourself. % % %----------------------------------------------------------------------- %----------------------------------------------------------------------- %----------------------------------------------------------------------- % % Listing 1 -- The top Level of a Query Processor % % % Call: process_query( Field_list, Tables, Conditions) % % Purpose: Retrieves data in the Prolog database specified by % Field_list, Tables, and Conditions % % Input arguments: % % Field_list = list of fields to be displayed % % Tables = list of predicate names for the facts which % contain the fields in Field_list. % % Conditions = a list of boolean conditions which the retrieved % data are to satisfy % % Output arguments: % % none % % Success conditions: % % Succeeds whenever the input arguments can be translated into % a query in Prolog. % % Effects: % % When the input arguments can be translated into Prolog, any % data retrieved by the query in Prolog is displayed. If the % translation can not be carried out, an error message is % displayed. % % % try to retrieve data process_query(Field_list, Tables, Conditions ) :- % translate inputs into a Prolog question generate_query( Field_list, Tables, Conditions, Generated_goal),!, % With the Prolog question, retrieve and display data get_all( Field_list, Generated_goal), % Stay with this rule if it succeeds !. % put out error message if previous rule fails process_query( Field_list, Tables, Conditions) :- nl, write( $Error in process_query for :$), nl, write( $Field_list = $ ), write( Field_list ), nl, write( $Tables = $ ), write( Tables ), nl, write( $Conditions = $ ), write( Conditions ), nl, fail. % %----------------------------------------------------------------------- % %---------------------------------------------------------------------- % | % Listing 2 -- Predicate for Defining a Data Retrieval Predicate | % | generate_query(Field_list, Tables, Conditions, prdbms_goal(X)) :- % % Step 1 -- retract all temporaryy information left from % % processing previous queries % retract_old_clauses, !, % % Step 2 -- construct list of calls for table rows % % that contain the needed information % get_calls_to_tables(Field_list, Tables, Table_calls), !, % % Step 3 -- translate conditions to Prolog % build_conditions_terms( Table_calls, Conditions, Condition_terms), !, % % Step 4 -- build list of variables representing % list of fields replace_field_names( Table_calls, Field_list, Variable_list), % Step 5 -- term setting variable in rule head Goal_term = ( X = Variable_list ), % Step 6 -- build list of terms in prdbms_goal rule body % append_lists( [ Table_calls, % Condition_terms, % [ Goal_term ] ], % Rule_body_as_list), !, % % Step 7 -- Build a conjunction of rule body terms % build_conjunction( Rule_body_as_list, Body ), !, % % Step 8 -- assert a new rule for predicate goal % asserta( (prdbms_goal(X) :- Body)) . % | %---------------------------------------------------------------------- % %--------------------------------------------------------------------------- % % Listing 3 -- Retracting Old Information from the Database % %/****************** retract_old_clauses *****************************/ %/* %retract_old_clauses retracts facts and rules which might be left % from processing previous user queries. %*/ % retract_old_clauses :- % retract rules that are Prolog implementations of old queries retract_all_clauses(prdbms_goal, 1), % retract old variable dictionary facts retract_all( temp_variable_meaning( _ , _)). % %/****************** retract_all_clauses *****************************/ %/* % Call: retract_all_clauses(Functor, Arity) % % Purpose: retracts all clauses whose head has a given functor and arity. % % Input arguments: % % Functor: Functor for the head of rules to be retracted % % Arity: Arity of functor of head of rules to be retracted % % Output arguments: none % % Success conditions: always succeeds % % Effect: retracts all clauses with head functor Functor of arity Arity % % Example: % % retract_all_clauses(factorial, 2) retracts any rules in the database % of the form % % factorial(_,_) :- _. % */ % retract_all_clauses(Functor, Arity) :- % build a term with Functor/Arity as functor and % all different variables as arguments functor(Head, Functor, Arity), % build a rule with head Head and arbitrary tail Rule = ( Head :- _), % retract everything that matches Rule retract_all(Rule). % %/****************** retract_all ************************************/ % /* % Call: retract_all(Form) % % Input arguments: % % Form = a Prolog term such that anything which matches it is to be % retracted from the Prolog database % % Success conditions: always succeeds % % Effect: retracts any clause that matches Form from the database % */ % retract_all(Form):- retractall(Form). retractall(Form):- repeat, retractall1(Form). /* Fails until no more patterns match Form */ % if there is something in the database matching Form, retractall1(Form):- % retract it, retract(Form), % cut to stay in this rule !, % and fail to cause backtracking back up to get another Form fail. % if nothing else matches Form, then succeed retractall1(_):-!. % % %--------------------------------------------------------------------------- %--------------------------------------------------------------------------- % % Listing 4 -- Replacing Field Names with Values % % /* % Call: % % replace_field_names( Input_structure, Output_structure) % % Input argument: % % Input_structure = a Prolog structure containing field names % % Output argument: % % Output_structure = the corresponding structure with field names % replaced by variables. % % Success conditions: always succeeds % % Side Effects: none % % Example: % % Assumptions: The database contains % % temp_variable_meaning( item, X1). % temp_variable_meaning( quantity, X4). % % Call: replace_field_names( [(item = diskettes), (quantity > 5) ], % Result) % % On exit: % % Result = [(X1 = diskettes), (X4 > 5) ] % % % */ % map variables into themselves replace_field_names( _, Input, Input ):- var( Input), !. % map atoms replace_field_names( Table_calls, Input, Result):- atomic( Input), !, replace_field_name_atom( Table_calls, Input, Result). % map the empty list into itself replace_field_names( _, [], []):- !. % map lists recursively replace_field_names( Table_calls, [ H | T ], [H1 | T1 ]):- !, replace_field_names( Table_calls, H, H1), replace_field_names( Table_calls, T, T1). % map functor and argument structures replace_field_names( Table_calls, Structure, Result ):- % map structures by first changing them to lists, Structure =.. Input_list, % then mapping them, replace_field_names( Table_calls, Input_list, Result_as_list), % finally changing them back to structures Result =.. Result_as_list, !. % report error if this rule is reached replace_field_names(_, Structure, Structure ):- nl, write($This structure could not be mapped by replace_field_names:$), nl, write(Structure). /* Using this predicate we can define the helper predicate that translates user-supplied conditions into Prolog */ build_conditions_terms( Table_calls, Conditions, Condition_terms) :- replace_field_names( Table_calls, Conditions, Condition_terms). /* The next predicate maps atoms for 'build_conditions_terms', replacing field names with the corresponding variable */ % Strategy is recursion on the list of Tables % default mapping of an atom is the atom replace_field_name_atom( [], Input, Input) :- !. % try to find the variable for Field in Table replace_field_name_atom( [Table | Tables], Field, Result) :- % get the name of the functor of Table functor(Table, Predicate_name, _), % see if Field is in this table % if so, get its argument Position call(has_field( Predicate_name, Field, Position)), !, % get the corresponding variable Result from Table arg(Position, Table, Result). % if no success above, try the next table replace_field_name_atom( [ _ | Tables], Input, Result) :- replace_field_name_atom( Tables, Input, Result). % |--------------------------------------------------------------------------- %------------------------------------------------------------------------- % % Listing 6 -- Building a Conjunction from a List of Terms % % /* % Call: build_conjunction( List, Conjunction) % % Input arguments: % % List = a list of terms % % Output arguments % % Conjunction = the list of terms ANDed together. % % Success conditions: % % Succeeds whenever the input is a list. % % Note: This predicate also works in the opposite direction, converting % a conjunction to a list of terms. % % */ % the AND of no items is always true build_conjunction( [], true):-!. % the AND of one item is the item itself build_conjunction( [Term], Term) :- !. % Here is the recursive rule build_conjunction( [ Term | Terms ], ( Term , Terms_as_conjunction)) :- build_conjunction( Terms , Terms_as_conjunction). %------------------------------------------------------------------------- %---------------------------------------------------------------------- % % Listing 7 -- A Data Retrieval Loop % % /* % Call: get_all(Field_list, Goal ) % % Input arguments: % % Field_list = list of names of user fields % % Goal = goal that finds a single instance of the desired data % % Success conditions % % always succeeds % % Effects: displays all instances of data satisfying the user query % */ % get_all(Field_list, Goal ) :- call( Goal ), arg(1, Goal , Value_list), display_item( Field_list, Value_list), fail. get_all(_, _ ) :-!. % %---------------------------------------------------------------------- %------------------- Predicates from body of column -------------------- % gets pattern matching an arbitrary data item in a table % Note: this is the special case when there is only one table get_calls_to_tables(Field_list, [Table], [Table_call]) :- find_arity(Table, Arity), functor( Table_call, Table, Arity). % finds the Arity of nTable_name find_arity(Table_name, Arity) :- findall( X, has_field(Table_name, X, _), Fields), list_length(Fields, Arity). % build term that sets output variable in head of generated rule % for processing the query build_goal_output_term( Field_list , Output_variable, Goal_output_term) :- % get list of variables replace_field_names( Field_list , Varible_list), % build the output term Goal_output_term = ( Variable = Varible_list ). % a simple display predicate for a table row display_item( Field_list, Value_list) :- nl, write( Value_list). % Since we are assuming a single table call, we omit the definition % of 'find_table_call_for_field'. In this special case you can use find_table_call_for_field(_, [Table_call], Table_call). % ------------------------------------------------------------------------- %-------------------- End of program -------------------------------- %------------------ Start of test data and predicates ------------------ /********** test database *************************************************/ transaction( diskettes, 1, 1/24, 100, 24.95, $Dicount Diskettes$, $Visa4$ ). transaction( 'hard disk', 2, 2/13, 1, 345.00, $Computer Serv. Ctr.$, $Visa$). transaction( eyeglasses, 3, 2/14, 1, 250.00, $Dr. Feinberg$, $check 345$). supplier( $Dicount Diskettes$, address( [$Box 2314$, $Chicago, Ill.$], _ ), [diskettes, ribbons, paper]). supplier( $Computer Serv. Ctr.$, address( [$5211 Nebraska Ave. NW$, $Wash. D.C.$], $20015$ ), 'hard disk'). supplier( $Dr. Feinberg$, address( [$4545 Conn. Ave. NW$, $Wash. D.C.$], $20016$), eyeglasses). item( diskettes , supplies ). item( 'hard disk' , 'capital expenditures' ). item( eyeglasses , 'medical expenses' ). /************************** data dictionary ******************************/ % This is a data dictionary for the above database has_field(transaction, item, 1). has_field(transaction, id, 2). has_field(transaction, date, 3). has_field(transaction, quantity, 4). has_field(transaction, price, 5). has_field(transaction, supplier, 6). has_field(transaction, 'how paid', 7). has_field(supplier, name, 1). has_field(supplier, address, 2). has_field(supplier, items, 3). has_field(item, item, 1). has_field(item, class, 2). /************************** test predicates ******************************/ % This is a test predicate for process_query. It should produce the % following output on the screen with the example data above: % [diskettes, 1/24 ] test :- process_query( [ item , date], [ transaction ] , =( item, diskettes) ). /********************** end test predicates ******************************/ %------------------- End of listing ------------------------------------  te