home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1993 #1 / NN_1993_1.iso / spool / comp / database / ingres / 2209 < prev    next >
Encoding:
Text File  |  1993-01-11  |  6.4 KB  |  139 lines
  1. Newsgroups: comp.databases.ingres
  2. Path: sparky!uunet!spool.mu.edu!darwin.sura.net!uvaarpa!cv3.cv.nrao.edu!mail-to-news-gateway
  3. From: GOLD@ILP.MIT.EDU (Mark D. Gold)
  4. Subject: Re: Help - ABF/4GL questions - summary
  5. Message-ID: <930110234123.4d4@ILP.MIT.EDU>
  6. Sender: root@nrao.edu (Operator)
  7. Organization: National Radio Astronomy Observatory
  8. Date: Mon, 11 Jan 1993 04:41:23 GMT
  9. Lines: 128
  10.  
  11. I would like to thank everyone who responded to my question regarding 
  12. the use of temporary tables and repeated inserts in ABF/4GL and 
  13. handling Ctrl-Y and Ctrl-C interrupts.
  14.  
  15. >>Subj:    Re: Help - ABF/4GL questions.
  16. >>
  17. >>I'm having several problems writing 4GL procedures.  I was hoping 
  18. >>that an INGRES expert could point me in the right direction.
  19. >>
  20. >>1.  One 4GL procedure does the following work:
  21. >>
  22. >>    a.  create temporary table x
  23. >>
  24. >>    b.  3 large, complex inserts (with selects) into table x
  25. >>
  26. >>    c.  3 large, complex select loops which each have
  27. >>            REPEATED inserts into table x within the loops
  28. >>            (the select loops also call C procedures)
  29. >>
  30. >>      d.  create array z, in which is stored a large list of id#s
  31. >>
  32. >>    e.  unload array z statement with 7 REPEATED insert
  33. >>            statements into table x within the unload statement
  34. >>
  35. >>      f.  modify table x to heapsort on....
  36. >>
  37. >>    g.  call report passing temporary table.
  38. >>
  39. >>
  40. >>    If I use REPEATED INSERTS throughout the 4GL procedure, the 
  41. >>procedure runs approximately 4 times faster than when I just use 
  42. >>regular INSERTS (i.e., 15 minutes : 1 hour).  However, I need to be 
  43. >>able to define the name of the temporary table ("table x" above) at 
  44. >>the start of the 4GL procedure based on the username and sessionid 
  45. >>using dbmsinfo.  This means (I assume) that I would have to store the 
  46. >>temporary table name in a variable at the start of the 4GL procedure. 
  47. >>Unfortunately, I can't use a REPEATED INSERT into a tablename that is 
  48. >>stored in a variable, even though the variable will not be changing 
  49. >>thoughout the 4GL procedure.
  50. >>
  51. >>This limitation means that we have to either (1) live with an 
  52. >>extremely slow 4GL procedure, or (2) hard-code the temporary table 
  53. >>name into the 4GL procedure, which means that each username will have a 
  54. >>copy of that temporary table AND only one person at a time logged 
  55. >>onto the same account will be able to use the temporary table.
  56. >>Option #1 is unacceptable for us.  
  57.  
  58.  
  59. Three items that I neglected to discuss in detail were:
  60.  
  61. 1.  We need the ability to set up ONE account per company dialing-in 
  62.     to our database.  Since any number of users can be using that one
  63.     account at the same time, we needed to find a way that each of
  64.     those users could create a temporary table without conflicting
  65.     with other users logged in to the same account.
  66.  
  67.     In addition, creating an indexed column in this temporary table
  68.     signifying the user's session_id (i.e., dbmsinfo('_bintim'))
  69.     would have caused two problems: a) slowing down inserts on a 
  70.     table that could get as big a 500,000 1800-byte rows; and
  71.     b) some users waiting while one user sorts the table for reports.
  72.  
  73. 2.  The select loops that I mention in "c." (above) which calls C-procedures
  74.     simply make changes to non-keyed data from the select statements.
  75.     Unfortunately, it is not practical (if possible) to replace this
  76.     existing C-procedure with 4GL code.
  77.  
  78. 3.  The 4GL procedure took a list of faculty ID#'s (parents) and gathered
  79.     data regarding faculty and their projects (children) and project
  80.     abstract lines, project keywords (children of projects) into a temporary
  81.     table.  In item "d." above, I was putting the project ID#'s into
  82.     an array and then looping through that array to obtain the children
  83.     of the projects (keywords, abstract lines, etc., etc.)
  84.  
  85.  
  86. I received some excellant ideas from "the net".  Since I had to use a 
  87. unique temporary table name, I either had to put it in a variable 
  88. (i.e., INSERT INTO :temp_table) or use the execellant suggestion to 
  89. use the ReportWriter to create the SQL statements that I needed with 
  90. the REPEATED INSERTs and hard-coded temporary table name.
  91.  
  92. >In other words, create an SQL file WHILE your application is
  93. >running. (use .RW, or operating system text-manipulation
  94. >facilities)  This file would include statements to create
  95. >your temporary table with the parameters you specify
  96. >(including a table name generated at run time).
  97.  
  98. I decided against the suggestion in this case for several reasons, 
  99. but mainly because 1) I needed to use not only SQL statements, but 
  100. 4GL statements; and 2) the time it would take to generate a 3,000 
  101. line file of SQL statements would be troublesome in cases where the 
  102. user is just reporting on one or two faculty members.
  103.  
  104. What I ended up doing was abandoning the REPEATED INSERTS in my 
  105. select loops.  I also eliminated the need for the REPEATED INSERTS
  106. when I unloaded the array I created in "d." (see "d." in original
  107. problem description)by creating INSERTs with SUBSELECT that each
  108. retrieved faculty data, project data (children), and one group of 
  109. children of projects (i.e., project co-investigators).  The SELECT 
  110. statements were rather involved, but it seemed to work....
  111.  
  112. Unfortunately, some of these INSERTs with SUBSELECT inserted so many
  113. rows into my temporary table, that my transaction log would fill up 
  114. and the program would bomb.  For example, one of the INSERTs with 
  115. SUBSELECT could fill up as much as 1/3-gigabyte in the transaction 
  116. log, even though the table being inserted into was modified to cheap.
  117.  
  118. So, in the end, I decided to keep the transactions smaller by putting 
  119. the whole procedure in a WHILE loop and running it on up to 100 faculty 
  120. members at a time.
  121.  
  122. I have to admit that I am a little frustrated with the ReportWriter 
  123. and 4GL, and plan to write any other complex reports in C.  But I am 
  124. very grateful to all the respondants and plan to use the suggestions 
  125. wherever possible.
  126.  
  127.  
  128. As far as the questions I had with Ctrl-C, Ctrl-Y, and F6 (VAX) 
  129. interrupts, I didn't receive any interrupt handlers.  I did get the 
  130. suggestion to run a clean-up procedure on a nightly basis.  Several 
  131. people suggested that I don't let Users use Ctrl-C or Ctrl-Y.  It was 
  132. also suggested that I could add interrupt handlers to a 3gl program.
  133.  
  134.             - Mark
  135. --------------------------------------------------------------
  136. Mark D. Gold             Massachusetts Institute of Technology
  137. gold@ilp.mit.edu         Industrial Liaison Program
  138. (617) 253-0430           Cambridge, Massachusetts  02139
  139.