Пример #1
0
    def __init__(self, name, table, backref=None, default=None, **kwds):
        '''a reference column
        
        - name: name of this reference
        - table: the table this reference refers to
        '''
        
        # length is not a valid input
        length = kwds.get('length')
        if length: raise ValueError, "'length' is not a valid keyword for 'Reference'"
        
        # 
        self._checkReferredTable(table)

        Column.__init__(self, name, default, **kwds)

        # 
        self.referred_table = table

        if backref:
            from BackReference import BackReference
            br = BackReference(self)
            setattr(table, backref, br)

        # establish constraint
        name = table.getTableName()
        self.constraints = 'REFERENCES %s (id)' % name
        
        return
Пример #2
0
def test2_update_dimension_3():

  temp = Query(dbms=dbms, columns=[Column("1","numeric(1)"),Column("'DESCONOCIDO'","varchar()")])
  cond = Query(
    dbms=dbms,
    sources=[lkp],
    columns=[Column(dbms.count("TEST_ID"), "numeric(3)")]
  )

  statements = "IF (" + cond.code()  + ") = 0 BEGIN\n"
  statements +=  lkp.insert(
      query= temp
  )
  statements += "END\n"

  statements += lkp.update_scd1(
    source = table,
    join_conditions = [["CauBajCod = TEST_ID"]]

  )

  statements += lkp.update_from(
    columns = [lkp.columns["TEST_DESC"]],
    source = table,
    where = [table.columns["CauBajCod"].equals(lkp.columns["TEST_ID"])]
    )
  return statements
 def __init__(self, name, **kwds):
     '''a versatile reference column
     
     - name: name of this reference
     '''
     Column.__init__(self, name, **kwds)
     return
Пример #4
0
 def __init__(self, table, name=None, backref=None, default=None, **kwds):
     '''a reference column
     - table: the table this reference refers to
     - name: name of this reference
     '''
     # length is not a valid input
     length = kwds.get('length')
     if length:
         raise ValueError, "'length' is not a valid keyword for 'Reference'"
     # we don't want to check for id
     #self._checkReferredTable(table)
     if name is None:
         name = table.__class__.__name__
         name = table.__name__
     Column.__init__(self, name, default, **kwds)
     #
     self.referred_table = table
     if backref:
         from BackReference import BackReference
         br = BackReference(self)
         setattr(table, backref, br)
     # establish constraint
     try:
         tablename = table.getTableName()
     except:
         tablename = table.__class__.__name__
     self.constraints = 'REFERENCES %s (id)' % tablename
Пример #5
0
    def _init_column(self):
        # extract total number of people
        num = 0 if self.main_table.follower is None else len(
            self.main_table.follower)
        # ref column
        for i in range(2):
            col = Column(num,
                         column_type[2],
                         role[1],
                         last_row=column_last_row[3])
            self.container[attach_column_type[i]] = col
        # init column
        self.container[attach_column_type[2]] = Column(
            num,
            column_type[2],
            role[1],
            last_row=column_last_row[3],
            number_format=10)

        self.container[attach_column_type[3]] = Column(
            num, column_type[1], role[2], last_row=column_last_row[3])

        self.container[attach_column_type[4]] = Column(
            num,
            column_type[1],
            role[2],
            last_row=column_last_row[3],
            formula_type=formula_type[2])

        self.container[attach_column_type[5]] = Column(
            num,
            column_type[1],
            role[2],
            last_row=column_last_row[3],
            formula_type=formula_type[2])
Пример #6
0
 def __init__(self, name, tableRegistry, length=1024, **kwds):
     '''a versatile reference column
     
     - name: name of this reference
     '''
     Column.__init__(self, name, **kwds)
     self.length = length
     self.tableRegistry = tableRegistry
     return
Пример #7
0
 def __init__(self, name, tableRegistry, length = 1024, **kwds):
     '''a versatile reference column
     
     - name: name of this reference
     '''
     Column.__init__(self, name, **kwds)
     self.length = length
     self.tableRegistry = tableRegistry
     return
Пример #8
0
def test_2_update_dimension_2():

    column1 = Column('Name', 'Person', 'varchar(20)', False)
    column2 = Column('Age', 'Person', 'numeric(2)', False)
    table = Table(sql, 'Person', [column1, column2], [column1.name])

    column1 = Column('Person_Name', 'Person', 'varchar(20)', False)
    column2 = Column('Person_Age', 'Person', 'numeric(2)', False)
    lkp = SCDimension1(sql, 'Lkp_Person', [column1, column2], [column1.name])

    return lkp.update_scd1(
        table, [[lkp.columns['Person_Name'].equals(table.columns['Name'])]])
Пример #9
0
    def add_col(self, new_col, override=False):
        """ Adds new column object to DataFrame. """
        if type(new_col) == dict:
            new_col = Column(new_col['colname'], new_col['coltype'],
                             new_col['unit'])

        if override:
            # replace column in current DataFrame object with df2 column (if there are overlapping column types)
            self.remove_col(self.get_column_by_type(new_col.get_coltype()))
            self.columns.append(new_col)

        else:
            # only add column object from df2 if there does not exist a column object in current df of same type
            if new_col.get_coltype() not in (self.get_col_types()):
                self.columns.append(new_col)
Пример #10
0
    def __get__(self, instance, cls = None):
        ret = Column.__get__(self, instance, cls = cls)
        
        # class variable request
        if ret is self: return self

        return self._cast( ret )
Пример #11
0
    def __get__(self, instance, cls = None):
        ret = Column.__get__(self, instance, cls = cls)
        
        # class variable request
        if ret is self: return self

        return self._cast( ret )
Пример #12
0
    def __get__(self, instance, cls=None):
        ret = Column.__get__(self, instance, cls=cls)
        if ret is None:
            import time

            return time.ctime()
        return self._cast(ret)
Пример #13
0
    def _init_req_columns(self, columns):
        """ Creates column objects for each column required by dataframe type. Throws error if a required column is not found in data. """

        new_columns = []

        # looping through required columns
        for col in self.req_columns:
            '''
			try: 
				# getting the variable type of the column 
				unit = self.df[columns[col]['name']].dtype
			except: 
				# exit if the column isn't found in the data 
				print(col, ' column not found in data.')
				sys.exit(1)
			'''
            try:
                # creating new column object
                new_col = Column(columns[col]['name'], columns[col]['type'],
                                 columns[col]['unit'])
                new_columns.append(new_col)
            except:
                print(
                    'Please ensure you have all required columns in config file.'
                )
                sys.exit(1)

        return new_columns
Пример #14
0
def parseLine(line):
    """
	Reads a line and attempts a JSON decode. This function automatically looks for the first instance of an opening bracket '{', 
	and continues until the end of the line. The parsing will respect a given offset, but perhaps that's a bit redundant.
	@param {name: "line", dataType: "string", comment: "Line of input."}
	@return 
	"""
    global args, columnConfig

    try:
        result = json.loads(
            line[line[args.offset:].index('{'):].encode('utf-8'))
    except ValueError:
        return []
    except UnicodeEncodeError:
        return []

    # You didn't specify any columns
    if not args.columns:
        return "No specified columns to print.\n"

    columnList = []
    for column in columnConfig:
        columnList.append(
            Column(column["name"],
                   result[column["name"]].encode('utf-8')
                   if column["name"] in result else "",
                   justify=column["justify"],
                   minWidth=column["minWidth"],
                   maxWidth=column["maxWidth"]))

    return columnList
Пример #15
0
    def __init__(self, name, table, default="", **kwds):
        '''a reference column
        
        - name: name of this reference
        - table: the table this reference refers to
        '''
        self._checkReferredTable(table)
        self.length = table.id.length
        
        length = kwds.get('length')
        if length: raise ValueError, "'length' is not a valid keyword for 'Reference'"
        
        Column.__init__(self, name, default, **kwds)

        self.referred_table = table
        return
Пример #16
0
    def createTable(self):
        con = sqlite3.connect(self.name + '.db')
        con.row_factory = sqlite3.Row
        cur = con.cursor()

        print('1. CREATE FROM DB STUDIO LEVEL')
        print('2. CREATE BY SQL QUERY')
        userChoice = pyip.inputChoice(['1', '2'], ('(1/2)'))
        if userChoice == '1':
            tableName = pyip.inputStr('Table name:')
            # CREATING TABLE OBJECT
            table = Table(tableName)
            columnsAmount = pyip.inputInt('Columns amount:')
            for i in range(columnsAmount):
                columnName = pyip.inputStr('Column name: ')
                columnType = pyip.inputStr('Column type: ')
                # CREATING COLUMN OBJECT
                column = Column(columnName, columnType)
                # ADDING COLUMN OBJECT TO THE COLUMNS PROPERTY IN TABLE OBJECT
                table.columns.append(column)
        # ADDING TABLE TO THE TABLES PROPERTY IN DATABASE OBJECT
        self.tables.append(table)
        # CREATING SQL QUERY
        query = 'CREATE TABLE ' + table.name + ' (\n'
        for i in range(len(table.columns)):
            query += table.columns[i].name + table.columns[i].type + ',\n'
            # HEREEEE

            for i in range(len(table.columns)):
                print(table.columns[i].name, table.columns[i].type,
                      table.columns[i].value)
Пример #17
0
    def convertToTable(self, myNodeObj, columnObj, listObj, length):
        
        if columnObj == None:
            #root node
            spanning = 0
            for node in myNodeObj.getNodeList():
                newColumn = Column()
                listObj.append(newColumn)
                spanning += self.convertToTable(node, newColumn, listObj, length)
            return spanning

        else:
            #not root node
            pos = 0
            if myNodeObj.getContent() != "null":
                columnObj.addCell(myNodeObj.getTextElement())
                pos = len(columnObj.getCellsList())
                if myNodeObj.getTextElement().getColspan() == 1:
                    self.updateColumnValues(columnObj, myNodeObj.getTextElement())

            else:
                textElement = TextElement()
                columnObj.addCell(textElement)
                pos = len(columnObj.getCellsList())

            if len(myNodeObj.getNodeList()) >= 1:
                columnClone = columnObj.clone()
                spanning = 0
                spanning += self.convertToTable(myNodeObj.getNodeElement(0), columnObj, listObj, length)
                for posCounter in range(1, len(myNodeObj.getNodeList())):
                    newColumn = Column()
                    newColumn.setCellsList(columnClone.getCellsList())
                    listObj.append(newColumn)
                    spanning +=self.convertToTable(myNodeObj.getNodeElement(posCounter),\
                    newColumn, listObj, length)
                    
                textElement = columnObj.getCellsListElement(pos-1)
                textElement.setColspan(spanning)

                return spanning

            else:
                # no children means that we are at the leaf of a branch
                while len(columnObj.getCellsList()) < length:
                    textElement = TextElement()
                    columnObj.addCell(textElement)
                return 1
Пример #18
0
    def __init__(self, name, table, default="", **kwds):
        '''a reference column
        
        - name: name of this reference
        - table: the table this reference refers to
        '''
        self._checkReferredTable(table)
        self.length = table.id.length

        length = kwds.get('length')
        if length:
            raise ValueError, "'length' is not a valid keyword for 'Reference'"

        Column.__init__(self, name, default, **kwds)

        self.referred_table = table
        return
Пример #19
0
def test_2_update_dimension_1():

    column1 = Column('Name', 'Person', 'varchar(20)', False)
    column2 = Column('Age', 'Person', 'numeric(2)', False)
    table = Table(tdms, 'Person', [column1, column2], [column1.name])

    column1 = Column('Person_Name', 'Person', 'varchar(20)', False)
    column2 = Column('Person_Age', 'Person', 'numeric(2)', False)
    lkp = SCDimension1(sql, 'Lkp_Person', [column1, column2], [column1.name])

    query = Query(dbms=sql,
                  sources=[table],
                  columns=[table.columns["Name"], table.columns["Age"]],
                  alias='')

    return lkp.update_scd1(
        query, [[lkp.columns['Person_Name'].equals(table.columns['Name'])]])
Пример #20
0
def test_2_update_dimension_1():

    column1 = Column('Name', 'varchar(20)', False)
    column2 = Column('Age', 'numeric(2)', False)
    table = Table(tdms, 'Person', [column1, column2], [column1.name])

    column1 = Column('Person_Name', 'varchar(20)', False)
    column2 = Column('Person_Age', 'numeric(2)', False)
    column_valid = Column('Valid_Record', 'numeric(1)', False)
    column_init_date = Column('Init_Date', 'date', False)
    column_end_date = Column('End_Date', 'date')

    lkp = SCDimension2(sql, 'Lkp_Person', [column1, column2], column_valid,
                       column_init_date, column_end_date, [column1.name])

    query = Query(dbms=sql,
                  sources=[table],
                  columns=[table.columns["Name"], table.columns["Age"]],
                  alias='')

    return lkp.update_scd2(source=query,
                           join_conditions=[[
                               lkp.columns['Person_Name'].equals(
                                   query.columns['Name'])
                           ]])
Пример #21
0
    def __get__(self, instance, cls=None):
        ret = Column.__get__(self, instance, cls=cls)

        # class variable request
        if ret is self: return self

        if not isinstance(ret, reference):
            ret = self._cast(ret)
        return ret
Пример #22
0
 def get_columns(self):
     post_url = self.url + '/posts'
     r = requests.get(post_url)
     soup = BeautifulSoup(r.content)
     for each_column in soup.find_all("a", "avatar-link"):
         #if not collumnBloom.is_element_exist(each_column['href']):
         #    collumnBloom.insert_element(each_column['href'])
         from Column import Column
         yield Column(each_column['href'])
Пример #23
0
 def __get__(self, instance, cls = None):
     ret = Column.__get__(self, instance, cls = cls)
     
     # class variable request
     if ret is self: return self
     
     if not isinstance(ret, reference):
         ret = self._cast( ret )
     return ret
Пример #24
0
 def generate_columns(self):
     self.columns = []
     for i in self.table_definition:
         self.columns.append(
             Column(self.cnx, i['COLUMN_NAME'], i['IS_NULLABLE'],
                    i['DATA_TYPE'], i['CHARACTER_MAXIMUM_LENGTH'],
                    i['NUMERIC_PRECISION'], i['NUMERIC_SCALE'],
                    i['COLUMN_TYPE'], i['IS_AUTOINC'], i['IS_UNIQUE'],
                    i['REFERENCED_SCHEMA'], i['REFERENCED_TABLE'],
                    i['REFERENCED_COLUMN'], self.table_name))
Пример #25
0
    def _init_opt_columns(self, columns):
        """ Creates column objects for all optional columns. """
        new_columns = []

        # looping through all user defined columns
        for col in columns:
            if col not in self.req_columns:
                unit = self.df[columns[col]['NAME']].dtype
                if unit == 'O':
                    self.preprocess_opt_columns(columns[col]['NAME'])
                new_col = Column(columns[col]['NAME'], columns[col]['TYPE'],
                                 unit)
                new_columns.append(new_col)

        return new_columns
Пример #26
0
 def __init__(self, master=None):
     Frame.__init__(self, master)
     self.master = master
     self.master.title("SportStreamer")
     self.master.configure(background='slate grey')
     self.forum = None
     self.game = None
     self.Sports = Column(self.master, 'SeaGreen3')
     self.Games = Column(self.master, 'SkyBlue3')
     self.Links = Column(self.master, 'forest green')
     self.make_sport_buttons()
    def convertToTable(self, myNodeObj, columnObj, listObj, length):

        if columnObj == None:
            #root node
            spanning = 0
            for node in myNodeObj.getNodeList():
                newColumn = Column()
                listObj.append(newColumn)
                spanning += self.convertToTable(node, newColumn, listObj,
                                                length)
            return spanning

        else:
            #not root node
            pos = 0
            if myNodeObj.getContent() != "null":
                columnObj.addCell(myNodeObj.getTextElement())
                pos = len(columnObj.getCellsList())
                if myNodeObj.getTextElement().getColspan() == 1:
                    self.updateColumnValues(columnObj,
                                            myNodeObj.getTextElement())

            else:
                textElement = TextElement()
                columnObj.addCell(textElement)
                pos = len(columnObj.getCellsList())

            if len(myNodeObj.getNodeList()) >= 1:
                columnClone = columnObj.clone()
                spanning = 0
                spanning += self.convertToTable(myNodeObj.getNodeElement(0),
                                                columnObj, listObj, length)
                for posCounter in range(1, len(myNodeObj.getNodeList())):
                    newColumn = Column()
                    newColumn.setCellsList(columnClone.getCellsList())
                    listObj.append(newColumn)
                    spanning +=self.convertToTable(myNodeObj.getNodeElement(posCounter),\
                    newColumn, listObj, length)

                textElement = columnObj.getCellsListElement(pos - 1)
                textElement.setColspan(spanning)

                return spanning

            else:
                # no children means that we are at the leaf of a branch
                while len(columnObj.getCellsList()) < length:
                    textElement = TextElement()
                    columnObj.addCell(textElement)
                return 1
Пример #28
0
def test_2_update_dimension_2():

    column1 = Column('Name', 'Person', 'varchar(20)', False)
    column2 = Column('Age', 'Person', 'numeric(2)', False)
    table = Table(sql, 'Person', [column1, column2], [column1.name])

    column1 = Column('Person_Name', 'Person', 'varchar(20)', False)
    column2 = Column('Person_Age', 'Person', 'numeric(2)', False)
    column_valid = Column('Valid_Record', 'numeric(1)', False)
    column_init_date = Column('Init_Date', 'date', False)
    column_end_date = Column('End_Date', 'date')

    lkp = SCDimension2(sql, 'Lkp_Person', [column1, column2], column_valid,
                       column_init_date, column_end_date, [column1.name])

    return lkp.update_scd2(source=table,
                           join_conditions=[[
                               lkp.columns['Person_Name'].equals(
                                   table.columns['Name'])
                           ]])
Пример #29
0
class TwoCols:
    thing = 0
    nextTime = 0
    def __init__(self, app):
        self.app = app
        self.col1 = Column(int(self.app.width/3), self.app)
        self.col2 = Column(int(2*self.app.width/3), self.app)

    def move(self):
        self.col1.move()
        self.col2.move()
        if self.nextTime == 0:
            self.nextTime = self.thing + random.randint(50, 300)
        
        self.thing += 1
        if self.thing % 400 == 0:
            self.generateNewNotes()
            self.nextTime = 0

    def generateNewNotes(self):
        if random.randint(1,2) == 1:
            self.col1.newNote()
        else:
            self.col2.newNote()
Пример #30
0
 def __init__(self, name, **kwds):
     Column.__init__(self, name, **kwds)
     return
Пример #31
0
 def __init__(self, name, tz=True, **kwds):
     Column.__init__(self, name, **kwds)
     self.tz = tz
     return
Пример #32
0
 def __init__(self, **kwds):
     Column.__init__(self, **kwds)
     return
Пример #33
0
 def __init__(self, name=None, length=48, default="", **kwds):
     if name is None:
         name = 'str' + str(id(self))
     Column.__init__(self, name, default, **kwds)
     self.length = length
Пример #34
0
 def __init__(self, name, length, **kwds):
     Column.__init__(self, name, **kwds)
     self.length = length
     return
Пример #35
0
 def add_column(self, column_name, column_type):
     self.columns.append(Column(column_name, column_type))
Пример #36
0
 def declaration(self):
     default = self.default
     self.default = None
     ret = Column.declaration(self)
     self.default = default
     return ret
Пример #37
0
 def __init__(self, name, length, **kwds):
     Column.__init__(self, name, **kwds)
     self.length = length
     return
Пример #38
0
 def add_column(self, column_name, column_type, column_equivalences):
     self.columns.append(
         Column(column_name, column_type, column_equivalences))
Пример #39
0
 def __get__(self, instance, cls=None):
     ret = Column.__get__(self, instance, cls = cls)
     if ret is None:
         return self._getDefaultValue()
     return self._cast(ret)
Пример #40
0
 def __init__(self, name, default=0, **kwds):
     Column.__init__(self, name, default, **kwds)
     return
Пример #41
0
 def __init__(self, name, shape=None, **kwds):
     Column.__init__(self, name, **kwds)
     self.shape = shape
     return
Пример #42
0
 def __init__(self, name, length, default="", **kwds):
     Column.__init__(self, name, default, **kwds)
     self.length = length
     return