summary refs log tree commit diff stats
path: root/lib/pure/db_common.nim
blob: f8689024b50f52b4d78aa75d5e8fad5cc1b60a45 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#
#
#            Nim's Runtime Library
#        (c) Copyright 2015 Andreas Rumpf
#
#    See the file "copying.txt", included in this
#    distribution, for details about the copyright.
#

## Common datatypes and definitions for all ``db_*.nim`` (
## `db_mysql <db_mysql.html>`_, `db_postgres <db_postgres.html>`_,
## and `db_sqlite <db_sqlite.html>`_) modules.

type
  DbError* = object of IOError ## exception that is raised if a database error occurs

  SqlQuery* = distinct string ## an SQL query string


  DbEffect* = object of IOEffect ## effect that denotes a database operation
  ReadDbEffect* = object of DbEffect   ## effect that denotes a read operation
  WriteDbEffect* = object of DbEffect  ## effect that denotes a write operation

  DbTypeKind* = enum  ## a superset of datatypes that might be supported.
    dbUnknown,        ## unknown datatype
    dbSerial,         ## datatype used for primary auto-increment keys
    dbNull,           ## datatype used for the NULL value
    dbBit,            ## bit datatype
    dbBool,           ## boolean datatype
    dbBlob,           ## blob datatype
    dbFixedChar,      ## string of fixed length
    dbVarchar,        ## string datatype
    dbJson,           ## JSON datatype
    dbXml,            ## XML datatype
    dbInt,            ## some integer type
    dbUInt,           ## some unsigned integer type
    dbDecimal,        ## decimal numbers (fixed-point number)
    dbFloat,          ## some floating point type
    dbDate,           ## a year-month-day description
    dbTime,           ## HH:MM:SS information
    dbDatetime,       ## year-month-day and HH:MM:SS information,
                      ## plus optional time or timezone information
    dbTimestamp,      ## Timestamp values are stored as the number of seconds
                      ## since the epoch ('1970-01-01 00:00:00' UTC).
    dbTimeInterval,   ## an interval [a,b] of times
    dbEnum,           ## some enum
    dbSet,            ## set of enum values
    dbArray,          ## an array of values
    dbComposite,      ## composite type (record, struct, etc)
    dbUrl,            ## a URL
    dbUuid,           ## a UUID
    dbInet,           ## an IP address
    dbMacAddress,     ## a MAC address
    dbGeometry,       ## some geometric type
    dbPoint,          ## Point on a plane   (x,y)
    dbLine,           ## Infinite line ((x1,y1),(x2,y2))
    dbLseg,           ## Finite line segment   ((x1,y1),(x2,y2))
    dbBox,            ## Rectangular box   ((x1,y1),(x2,y2))
    dbPath,           ## Closed or open path (similar to polygon) ((x1,y1),...)
    dbPolygon,        ## Polygon (similar to closed path)   ((x1,y1),...)
    dbCircle,         ## Circle   <(x,y),r> (center point and radius)
    dbUser1,          ## user definable datatype 1 (for unknown extensions)
    dbUser2,          ## user definable datatype 2 (for unknown extensions)
    dbUser3,          ## user definable datatype 3 (for unknown extensions)
    dbUser4,          ## user definable datatype 4 (for unknown extensions)
    dbUser5           ## user definable datatype 5 (for unknown extensions)

  DbType* = object    ## describes a database type
    kind*: DbTypeKind ## the kind of the described type
    notNull*: bool    ## does the type contain NULL?
    name*: string     ## the name of the type
    size*: Natural    ## the size of the datatype; 0 if of variable size
    maxReprLen*: Natural ## maximal length required for the representation
    precision*, scale*: Natural ## precision and scale of the number
    min*, max*: BiggestInt ## the minimum and maximum of allowed values
    validValues*: seq[string] ## valid values of an enum or a set

  DbColumn* = object   ## information about a database column
    name*: string      ## name of the column
    tableName*: string ## name of the table the column belongs to (optional)
    typ*: DbType       ## type of the column
    primaryKey*: bool  ## is this a primary key?
    foreignKey*: bool  ## is this a foreign key?
  DbColumns* = seq[DbColumn]

template sql*(query: string): SqlQuery =
  ## constructs a SqlQuery from the string `query`. This is supposed to be
  ## used as a raw-string-literal modifier:
  ## ``sql"update user set counter = counter + 1"``
  ##
  ## If assertions are turned off, it does nothing. If assertions are turned
  ## on, later versions will check the string for valid syntax.
  SqlQuery(query)

proc dbError*(msg: string) {.noreturn, noinline.} =
  ## raises an DbError exception with message `msg`.
  var e: ref DbError
  new(e)
  e.msg = msg
  raise e
2010-03-11 20:27:25 +0100 committer hut <hut@lavabit.com> 2010-03-12 00:46:47 +0100 working on the configuration system / main method' href='/akspecs/ranger/commit/ranger/core/fm.py?id=0128bee71f734138d3f49f56092688bb0623c6a2'>0128bee7 ^
b4a0c387 ^
20f94973 ^
0c0b9489 ^
0c0b9489 ^


c2238598 ^




a9f69385 ^

16246965 ^



be7c282c ^




a1d7ed6e ^
ad1a4204 ^

b4b0eb24 ^
ad1a4204 ^



b4b0eb24 ^
a1d7ed6e ^
f8e96a97 ^

871c502d ^

361781cd ^







f2d8598d ^

361781cd ^




0cfc59d6 ^
361781cd ^
0cfc59d6 ^
361781cd ^
0cfc59d6 ^
361781cd ^
0cfc59d6 ^
7626fd1d ^
0cfc59d6 ^



9b83f114 ^
0cfc59d6 ^
3937f010 ^


0a16f0da ^
3937f010 ^
f2d8598d ^
361781cd ^

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
                                                                 
 



                                                                      
 






                                                                       
 



                                             
                     
                             

          
 
             
                                       

                                          
                                      
                                     
                               
                                                      
                                     
                                                         
                              
                                     
 
          
                                     
                                       
 
                                    

                               
                                                               
                                    
                                      
                                               
                            
                                           
                                          
                                

                                    
                                      
 



                                                                                    
                

                              

                                                                
 

                                                                              
                                          



                                                                        
                                                   
                                                                  
                                                               
                                                                                  



                                                  
 
                                                              
                                                                
 
                                   


                                             




                                                             

                                                                    



                                                       




                                                                            
                       

                                          
                                                  



                                                                     
                   
 

                                                 

                           







                                                      

                                   




                                                                       
                                             
                                                                     
 
                                           
 
                                                                   
 
                                                 



                                                                             
                                                                                             
 


                                                                                   
                                        
 
                        

                                                   
# Copyright (C) 2009, 2010  Roman Zimbelmann <romanz@lavabit.com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""
The File Manager, putting the pieces together
"""

from time import time
from collections import deque
import os
import sys

import ranger
from ranger.core.actions import Actions
from ranger.container.tags import Tags
from ranger.gui.defaultui import DefaultUI
from ranger.container import Bookmarks
from ranger.core.runner import Runner
from ranger import relpath_conf
from ranger.ext.get_executables import get_executables
from ranger.fsobject import Directory
from ranger.ext.signal_dispatcher import SignalDispatcher
from ranger import __version__
from ranger.core.loader import Loader

CTRL_C = 3
TICKS_BEFORE_COLLECTING_GARBAGE = 100
TIME_BEFORE_FILE_BECOMES_GARBAGE = 1200

class FM(Actions, SignalDispatcher):
	input_blocked = False
	input_blocked_until = 0
	def __init__(self, ui=None, bookmarks=None, tags=None):
		"""Initialize FM."""
		Actions.__init__(self)
		SignalDispatcher.__init__(self)
		self.ui = ui
		self.log = deque(maxlen=20)
		self.bookmarks = bookmarks
		self.tags = tags
		self.tabs = {}
		self.current_tab = 1
		self.loader = Loader()

		self.log.append('Ranger {0} started! Process ID is {1}.' \
				.format(__version__, os.getpid()))
		self.log.append('Running on Python ' + sys.version.replace('\n',''))

	# COMPAT
	@property
	def executables(self):
		"""For compatibility. Calls get_executables()"""
		return get_executables()

	def initialize(self):
		"""If ui/bookmarks are None, they will be initialized here."""
		if self.bookmarks is None:
			if ranger.arg.clean:
				bookmarkfile = None
			else:
				bookmarkfile = relpath_conf('bookmarks')
			self.bookmarks = Bookmarks(
					bookmarkfile=bookmarkfile,
					bookmarktype=Directory,
					autosave=self.settings.autosave_bookmarks)
			self.bookmarks.load()

		else:
			self.bookmarks = bookmarks

		if not ranger.arg.clean and self.tags is None:
			self.tags = Tags(relpath_conf('tagged'))

		if self.ui is None:
			self.ui = DefaultUI()
			self.ui.initialize()

		def mylogfunc(text):
			self.notify(text, bad=True)
		self.run = Runner(ui=self.ui, apps=self.apps,
				logfunc=mylogfunc)

		self.env.signal_bind('cd', self._update_current_tab)

	def block_input(self, sec=0):
		self.input_blocked = sec != 0
		self.input_blocked_until = time() + sec

	def input_is_blocked(self):
		if self.input_blocked and time() > self.input_blocked_until:
			self.input_blocked = False
		return self.input_blocked

	def loop(self):
		"""
		The main loop consists of:
		1. reloading bookmarks if outdated
		2. letting the loader work
		3. drawing and finalizing ui
		4. reading and handling user input
		5. after X loops: collecting unused directory objects
		"""

		self.env.enter_dir(self.env.path)

		gc_tick = 0

		# for faster lookup:
		ui = self.ui
		throbber = ui.throbber
		bookmarks = self.bookmarks
		loader = self.loader
		env = self.env
		has_throbber = hasattr(ui, 'throbber')

		try:
			while True:
				bookmarks.update_if_outdated()
				loader.work()
				if has_throbber:
					if loader.has_work():
						throbber(loader.status)
					else:
						throbber(remove=True)

				ui.redraw()

				ui.set_load_mode(loader.has_work())

				ui.handle_input()

				gc_tick += 1
				if gc_tick > TICKS_BEFORE_COLLECTING_GARBAGE:
					gc_tick = 0
					env.garbage_collect(TIME_BEFORE_FILE_BECOMES_GARBAGE)

		except KeyboardInterrupt:
			# this only happens in --debug mode. By default, interrupts
			# are caught in curses_interrupt_handler
			raise SystemExit

		finally:
			bookmarks.remember(env.cwd)
			bookmarks.save()